def __init__(self, name: str = None, description: str = None) -> None:
self.branch: typing.Optional[ABCBranchGenerator] = DictBranch()
self.middleware: MiddlewareExecutor = MiddlewareExecutor()
self.error_handler: VKErrorHandler = DefaultErrorHandler()
self.api: Api = None
self._name = name or "Unknown"
self._description = description or "Unknown"
def __init__(
self,
tokens: Token = None,
*,
group_id: int = None,
debug: typing.Union[str, bool] = True,
loop: asyncio.AbstractEventLoop = None,
throw_errors: bool = True,
log_to_path: typing.Union[str, bool] = None,
patcher: Patcher = None,
mobile: bool = False,
secret: str = None,
extension: AbstractExtension = None,
logs_folder: typing.Optional[str] = None,
only_asyncio_loop: bool = False,
**context,
):
"""
Init bot
:param tokens: bot tokens
:param group_id:
:param debug: should bot debug messages for emulating
:param log_to_path: make logs
:param secret: secret vk code for callback
:param extension:
"""
# Base bot classifiers
self.__tokens: typing.List[str] = [tokens] if isinstance(
tokens, str) else tokens
self.__debug: bool = debug
self.__wait = None
self.__secret = secret
self._status: BotStatus = BotStatus()
self.context: dict = context
if uvloop is not None:
if not only_asyncio_loop:
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
if isinstance(debug, bool):
debug = "INFO" if debug else "ERROR"
self.logger = LoggerLevel(debug)
if not Patcher.get_current():
Patcher.set_current(patcher if patcher is not None else Patcher(
pattern="^{}$", validators=DefaultValidators))
logger.remove()
logger.add(
sys.stderr,
colorize=True,
format=
"<level>[<blue>VKBottle</blue>] {message}</level> <white>[TIME {time:HH:MM:ss}]</white>",
filter=self.logger,
level=0,
enqueue=mobile is False,
)
logger.level("INFO", color="<white>")
logger.level("ERROR", color="<red>")
if log_to_path:
logger.add(
(logs_folder or "") +
"log_{time}.log" if log_to_path is True else log_to_path,
rotation="20 MB",
)
self.group_id = group_id
self.loop = loop
# Sign assets
self._api: Api = Api(self.__tokens, throw_errors=throw_errors)
self.error_handler: VKErrorHandler = DefaultErrorHandler()
self.extension: AbstractExtension = (extension if extension is not None
else StandardExtension())
self._throw_errors: bool = throw_errors
Api.set_current(self._api)
VKErrorHandler.set_current(self.error_handler)
AbstractExtension.set_current(self.extension)
# Main workers
self.branch: typing.Union[ABCBranchGenerator,
DictBranch] = DictBranch()
self.middleware: MiddlewareExecutor = MiddlewareExecutor()
self.on: BotHandler = BotHandler(self.group_id)
self._stop: bool = False
self.deconstructed_handle: BotProcessor = BotProcessor(self.group_id)
logger.info("Using JSON_MODULE - {}".format(USAGE))
logger.info("Using asyncio loop - {}".format(
asyncio.get_event_loop_policy().__class__.__module__))
def __init__(
self,
tokens: Token = None,
*,
login: str = None,
password: str = None,
user_id: int = None,
debug: typing.Union[str, bool] = True,
loop: asyncio.AbstractEventLoop = None,
expand_models: bool = True,
mobile: bool = False,
log_to_path: typing.Union[str, bool] = None,
vbml_patcher: vbml.Patcher = None,
mode: int = 234,
only_asyncio_loop: bool = False,
**context,
):
self.__tokens = [tokens] if isinstance(tokens, str) else tokens
self.context: dict = context
if uvloop is not None:
if not only_asyncio_loop:
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
if login and password:
self.__tokens = self.get_tokens(login, password)
self.loop = loop or asyncio.get_event_loop()
self.__debug: bool = debug
self._api: UserApi = UserApi(self.__tokens)
self.mode = mode
self._expand_models: bool = expand_models
self._patcher: vbml.Patcher = vbml_patcher or vbml.Patcher(
pattern="^{}$")
self.user_id: typing.Optional[int] = user_id or self.get_id_by_token(
self.__tokens[0])
self._api.user_id = user_id
self.error_handler: VKErrorHandler = DefaultErrorHandler()
UserApi.set_current(self._api)
VKErrorHandler.set_current(self.error_handler)
self.on: UserHandler = UserHandler()
self.branch: ABCBranchGenerator = DictBranch()
self.middleware: MiddlewareExecutor = MiddlewareExecutor()
self.error_handler: VKErrorHandler = DefaultErrorHandler()
self.deconstructed_handle: UserProcessor = UserProcessor(
self.user_id, expand_models=expand_models)
self._stop: bool = False
self.status = UserStatus()
if isinstance(debug, bool):
debug = "INFO" if debug else "ERROR"
self.logger = LoggerLevel(debug)
logger.remove()
logger.add(
sys.stderr,
colorize=True,
format="<level>[<blue>VKBottle</blue>] {message}</level>",
filter=self.logger,
level=0,
enqueue=mobile is False,
)
if log_to_path:
logger.add(
"log_user_{time}.log" if log_to_path is True else log_to_path,
rotation="20 MB",
)
logger.info("Using JSON_MODULE - {}".format(USAGE))
logger.info("Using asyncio loop - {}".format(
asyncio.get_event_loop_policy().__class__.__module__))