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 or self.get_id_by_token(self.__tokens[0])
self.__loop = loop or asyncio.get_event_loop()
# Sign assets
self.api: Api = Api(self.__tokens, throw_errors=throw_errors)
self.extension: AbstractExtension = extension if extension is not None else StandardExtension()
self._throw_errors: bool = throw_errors
Api.set_current(self.api)
AbstractExtension.set_current(self.extension)
# Main workers
self.branch: typing.Union[AbstractBranchGenerator, DictBranch] = DictBranch()
self.middleware: MiddlewareExecutor = MiddlewareExecutor()
self.on: Handler = Handler(self.group_id)
self.error_handler: VKErrorHandler = DefaultErrorHandler()
self._stop: bool = False
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__))