Merge pull request beveiled#110 from hikariatama/v1.6.3

V1.6.3

Author: hikariatama

.flake8

@@ -1,3 +1,3 @@
 [flake8]
-ignore = E501,W503,E203,ASN001,E701,E231,E225,W504
+ignore = E501,E203,E701,ASN001,E231,E503,W503,E225,W504
 exclude = .git,__pycache__,loaded_modules

CHANGELOG.md

@@ -1,5 +1,23 @@
 # Hikka Changelog
 
+## 🌑 Hikka 1.6.3
+
+- Add argument `item_type` to `db.pointer` to provide interface for NamedTuple objects
+- Add correct exception propagation to inline units
+- Add `-fs` arg to `.lm` command
+- Add IDM `flush_loader_cache`
+- Add ability to cancel QR login using keyboard interrupt
+- Add custom security groups
+- Add automatic NoNick for tsec methods
+- Add external debugging feature (off by default)
+- Fix form invoke error message
+- Fix `Backuper`
+- Fix backward compatiblity with security groups `SUDO` (0x2) and `SUPPORT` (0x4)
+- Fix quickstart language buttons translations
+- Fix language buttons disabling on restart
+- Migrate inline heta search to userbot instead of centralized service
+- Cosmetical changes
+
 ## 🌑 Hikka 1.6.2
 
 - Fix security issue with edited channel messages

hikka/__main__.py

@@ -60,12 +60,12 @@ def deps():
  try:
  import hikkatl # noqa: F811
 
- if tuple(map(int, hikkatl.__version__.split("."))) < (2, 0, 3):
+ if tuple(map(int, hikkatl.__version__.split("."))) < (2, 0, 4):
  raise ImportError
 
  import hikkapyro
 
- if tuple(map(int, hikkapyro.__version__.split("."))) < (2, 0, 102):
+ if tuple(map(int, hikkapyro.__version__.split("."))) < (2, 0, 103):
  raise ImportError
  except ImportError:
  print("🔄 Installing dependencies...")

hikka/_local_storage.py

@@ -15,6 +15,8 @@
 import requests
 
 from . import utils
+from .tl_cache import CustomTelegramClient
+from .version import __version__
 
 logger = logging.getLogger(__name__)
 
@@ -45,7 +47,12 @@ def _get_path(self, repo: str, module_name: str) -> str:
  )
 
  def save(self, repo: str, module_name: str, module_code: str):
- """Saves module to disk."""
+ """
+ Saves module to disk.
+ :param repo: Repository name.
+ :param module_name: Module name.
+ :param module_code: Module source code.
+ """
  size = len(module_code)
  if size > MAX_FILESIZE:
  logger.warning(
@@ -70,7 +77,12 @@ def save(self, repo: str, module_name: str, module_code: str):
  logger.debug("Saved module %s from %s to local cache.", module_name, repo)
 
  def fetch(self, repo: str, module_name: str) -> typing.Optional[str]:
- """Fetches module from disk."""
+ """
+ Fetches module from disk.
+ :param repo: Repository name.
+ :param module_name: Module name.
+ :return: Module source code or None.
+ """
  path = self._get_path(repo, module_name)
  if os.path.isfile(path):
  with open(path, "r") as f:
@@ -80,8 +92,9 @@ def fetch(self, repo: str, module_name: str) -> typing.Optional[str]:
 
 
 class RemoteStorage:
- def __init__(self):
+ def __init__(self, client: CustomTelegramClient):
  self._local_storage = LocalStorage()
+ self._client = client
 
  async def preload(self, urls: typing.List[str]):
  """Preloads modules from remote storage."""
@@ -122,7 +135,11 @@ async def preload_main_repo(self):
 
  @staticmethod
  def _parse_url(url: str) -> typing.Tuple[str, str, str]:
- """Parses a URL into a repository and module name."""
+ """
+ Parses a URL into a repository and module name.
+ :param url: URL to parse.
+ :return: Tuple of (url, repo, module_name).
+ """
  domain_name = url.split("/")[2]
 
  if domain_name == "raw.githubusercontent.com":
@@ -142,14 +159,22 @@ def _parse_url(url: str) -> typing.Tuple[str, str, str]:
  async def fetch(self, url: str, auth: typing.Optional[str] = None) -> str:
  """
  Fetches the module from the remote storage.
- :param ref: The module reference. Can be url, or a reference to official repo module.
+ :param url: URL to the module.
+ :param auth: Optional authentication string in the format "username:password".
+ :return: Module source code.
  """
  url, repo, module_name = self._parse_url(url)
  try:
  r = await utils.run_sync(
  requests.get,
  url,
  auth=(tuple(auth.split(":", 1)) if auth else None),
+ headers={
+ "User-Agent": "Hikka Userbot",
+ "X-Hikka-Version": ".".join(map(str, __version__)),
+ "X-Hikka-Commit-SHA": utils.get_git_hash(),
+ "X-Hikka-User": str(self._client.tg_id),
+ },
  )
  r.raise_for_status()
  except Exception:

hikka/compat/dragon.py

@@ -274,7 +274,7 @@ def format_small_module_help(self, module_name: str):
  " list:</b>\n"
  )
 
- for command, desc in commands.items():
+ for command in commands:
  cmd = command.split(maxsplit=1)
  args = " <code>" + cmd[1] + "</code>" if len(cmd) > 1 else ""
  help_text += f"<code>{self.misc.prefix}{cmd[0]}</code>{args}\n"

hikka/compat/pyroproxy.py

@@ -17,7 +17,7 @@
 from hikkapyro import errors as pyro_errors
 from hikkapyro import raw
 
-from .. import translations, utils
+from .. import utils
 from ..tl_cache import CustomTelegramClient
 from ..version import __version__
 
@@ -56,19 +56,13 @@ class PyroProxyClient(PyroClient):
  def __init__(self, tl_client: CustomTelegramClient):
  self.tl_client = tl_client
  super().__init__(
- **{
- "name": "proxied_pyrogram_client",
- "api_id": tl_client.api_id,
- "api_hash": tl_client.api_hash,
- "app_version": (
- f"Hikka v{__version__[0]}.{__version__[1]}.{__version__[2]}"
- ),
- "lang_code": tl_client.loader.db.get(
- translations.__name__, "lang", "en"
- ).split()[0],
- "in_memory": True,
- "phone_number": tl_client.hikka_me.phone,
- }
+ name="proxied_pyrogram_client",
+ api_id=tl_client.api_id,
+ api_hash=tl_client.api_hash,
+ app_version=".".join(map(str, __version__)) + " x64",
+ lang_code="en",
+ in_memory=True,
+ phone_number=tl_client.hikka_me.phone,
  )
 
  # We need to set this to True so pyro thinks he's connected

hikka/database.py

@@ -24,10 +24,27 @@
 from hikkatl.tl.types import Message, User
 
 from . import main, utils
-from .pointers import PointerDict, PointerList
+from .pointers import (
+ BaseSerializingMiddlewareDict,
+ BaseSerializingMiddlewareList,
+ NamedTupleMiddlewareDict,
+ NamedTupleMiddlewareList,
+ PointerDict,
+ PointerList,
+)
 from .tl_cache import CustomTelegramClient
 from .types import JSONSerializable
 
+__all__ = [
+ "Database",
+ "PointerList",
+ "PointerDict",
+ "NamedTupleMiddlewareDict",
+ "NamedTupleMiddlewareList",
+ "BaseSerializingMiddlewareDict",
+ "BaseSerializingMiddlewareList",
+]
+
 logger = logging.getLogger(__name__)
 
 
@@ -287,6 +304,7 @@ def pointer(
  owner: str,
  key: str,
  default: typing.Optional[JSONSerializable] = None,
+ item_type: typing.Optional[typing.Any] = None,
  ) -> typing.Union[JSONSerializable, PointerList, PointerDict]:
  """Get a pointer to database key"""
  value = self.get(owner, key, default)
@@ -306,4 +324,30 @@ def pointer(
  f"Pointer for type {type(value).__name__} is not implemented"
  )
 
+ if item_type is not None:
+ if isinstance(value, list):
+ for item in self.get(owner, key, default):
+ if not isinstance(item, dict):
+ raise ValueError(
+ "Item type can only be specified for dedicated keys and"
+ " can't be mixed with other ones"
+ )
+
+ return NamedTupleMiddlewareList(
+ pointer_constructor(self, owner, key, default),
+ item_type,
+ )
+ if isinstance(value, dict):
+ for item in self.get(owner, key, default).values():
+ if not isinstance(item, dict):
+ raise ValueError(
+ "Item type can only be specified for dedicated keys and"
+ " can't be mixed with other ones"
+ )
+
+ return NamedTupleMiddlewareDict(
+ pointer_constructor(self, owner, key, default),
+ item_type,
+ )
+
  return pointer_constructor(self, owner, key, default)

hikka/dispatcher.py

@@ -359,6 +359,7 @@ async def _handle_command(
  and not self._db.get(main.__name__, "no_nickname", False)
  and command not in self._db.get(main.__name__, "nonickcmds", [])
  and initiator not in self._db.get(main.__name__, "nonickusers", [])
+ and not self.security.check_tsec(initiator, command)
  and utils.get_chat_id(event)
  not in self._db.get(main.__name__, "nonickchats", [])
  ):
@@ -369,7 +370,11 @@ async def _handle_command(
  if (
  not func
  or not await self._handle_ratelimit(message, func)
- or not await self.security.check(message, func)
+ or not await self.security.check(
+ message,
+ func,
+ usernames=self._cached_usernames,
+ )
  ):
  return False
 

hikka/inline/core.py

@@ -7,6 +7,7 @@
 # 🔑 https://www.gnu.org/licenses/agpl-3.0.html
 
 import asyncio
+import contextlib
 import logging
 import time
 import typing
@@ -16,8 +17,10 @@
 from aiogram.utils.exceptions import TerminatedByOtherGetUpdates, Unauthorized
 from hikkatl.errors.rpcerrorlist import InputUserDeactivatedError, YouBlockedUserError
 from hikkatl.tl.functions.contacts import UnblockRequest
+from hikkatl.tl.types import Message
 from hikkatl.utils import get_display_name
 
+from .. import utils
 from ..database import Database
 from ..tl_cache import CustomTelegramClient
 from ..translations import Translator
@@ -69,6 +72,7 @@ def __init__(
  self._custom_map: typing.Dict[str, callable] = {}
  self.fsm: typing.Dict[str, str] = {}
  self._web_auth_tokens: typing.List[str] = []
+ self._error_events: typing.Dict[str, asyncio.Event] = {}
 
  self._markup_ttl = 60 * 60 * 24
  self.init_complete = False
@@ -216,3 +220,47 @@ def pop_web_auth_token(self, token: str) -> bool:
 
  self._web_auth_tokens.remove(token)
  return True
+
+ async def _invoke_unit(self, unit_id: str, message: Message) -> Message:
+ event = asyncio.Event()
+ self._error_events[unit_id] = event
+
+ q: "InlineResults" = None # type: ignore # noqa: F821
+ exception: Exception = None
+
+ async def result_getter():
+ nonlocal unit_id, q
+ with contextlib.suppress(Exception):
+ q = await self._client.inline_query(self.bot_username, unit_id)
+
+ async def event_poller():
+ nonlocal exception
+ await asyncio.wait_for(event.wait(), timeout=10)
+ if self._error_events.get(unit_id):
+ exception = self._error_events[unit_id]
+
+ result_getter_task = asyncio.ensure_future(result_getter())
+ event_poller_task = asyncio.ensure_future(event_poller())
+
+ _, pending = await asyncio.wait(
+ [result_getter_task, event_poller_task],
+ return_when=asyncio.FIRST_COMPLETED,
+ )
+
+ for task in pending:
+ task.cancel()
+
+ self._error_events.pop(unit_id, None)
+
+ if exception:
+ raise exception # skipcq: PYL-E0702
+
+ if not q:
+ raise Exception("No query results")
+
+ return await q[0].click(
+ utils.get_chat_id(message) if isinstance(message, Message) else message,
+ reply_to=(
+ message.reply_to_msg_id if isinstance(message, Message) else None
+ ),
+ )

hikka/inline/events.py

@@ -38,7 +38,7 @@ async def _message_handler(self, message: AiogramMessage):
  if (
  not hasattr(mod, "aiogram_watcher")
  or message.text == "/start"
- and mod.__class__.__name__ != "InlineStuffMod"
+ and mod.__class__.__name__ != "InlineStuff"
  ):
  continue