telegrinder 0.3.4__py3-none-any.whl → 0.4.0__py3-none-any.whl

telegrinder/bot/dispatch/abc.py

@@ -1,77 +1,76 @@
-import importlib.util as importlib_util
-import os
-import pathlib
-import sys
-import typing
-from abc import ABC, abstractmethod
-
-from fntypes.option import Option
-
-from telegrinder.api.api import API
-from telegrinder.tools.global_context.abc import ABCGlobalContext
-from telegrinder.types.objects import Update
-
-T = typing.TypeVar("T")
-
-
-class PathExistsError(BaseException):
-    pass
-
-
-class ABCDispatch(ABC):
-    @property
-    @abstractmethod
-    def global_context(self) -> ABCGlobalContext:
-        pass
-
-    @abstractmethod
-    async def feed(self, event: Update, api: API) -> bool:
-        pass
-
-    @abstractmethod
-    def load(self, external: typing.Self) -> None:
-        pass
-
-    @abstractmethod
-    def get_view(self, of_type: type[T]) -> Option[T]:
-        pass
-
-    def load_many(self, *externals: typing.Self) -> None:
-        for external in externals:
-            self.load(external)
-
-    def load_from_dir(self, directory: str | pathlib.Path) -> bool:
-        """Loads dispatchers from a directory containing Python modules where global variables
-        are declared with instances of dispatch.
-        Returns True if dispatchers were found, otherwise False."""
-
-        directory = pathlib.Path(directory)
-
-        if not directory.exists():
-            raise PathExistsError(f"Path {str(directory)!r} does not exists.")
-
-        dps: list[typing.Self] = []
-        for root, _, files in os.walk(directory):
-            for f in files:
-                if f.endswith(".py") and f != "__init__.py":
-                    module_path = os.path.join(root, f)
-                    module_name = os.path.splitext(os.path.relpath(module_path, directory))[0]
-                    module_name = module_name.replace(os.sep, ".")
-
-                    spec = importlib_util.spec_from_file_location(module_name, module_path)
-                    if spec is None or spec.loader is None:
-                        continue
-
-                    module = importlib_util.module_from_spec(spec)
-                    sys.modules[module_name] = module
-                    spec.loader.exec_module(module)
-
-                    for obj in module.__dict__.values():
-                        if isinstance(obj, self.__class__):
-                            dps.append(obj)
-
-        self.load_many(*dps)
-        return bool(dps)
-
-
-__all__ = ("ABCDispatch",)
+import importlib.util as importlib_util
+import os
+import pathlib
+import sys
+import typing
+from abc import ABC, abstractmethod
+
+from fntypes.option import Option
+
+from telegrinder.api.api import API
+from telegrinder.types.objects import Update
+
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.dispatch.view.abc import ABCView
+
+
+class PathExistsError(BaseException):
+    pass
+
+
+class ABCDispatch(ABC):
+    @abstractmethod
+    async def feed(self, event: Update, api: API[typing.Any]) -> bool:
+        pass
+
+    @abstractmethod
+    def load(self, external: typing.Self) -> None:
+        pass
+
+    @abstractmethod
+    def get_view[T](self, of_type: type[T]) -> Option[T]:
+        pass
+
+    @abstractmethod
+    def get_views(self) -> dict[str, "ABCView"]:
+        pass
+
+    def load_many(self, *externals: typing.Self) -> None:
+        for external in externals:
+            self.load(external)
+
+    def load_from_dir(self, directory: str | pathlib.Path) -> bool:
+        """Loads dispatchers from a directory containing Python modules where global variables
+        are declared with instances of dispatch.
+        Returns True if dispatchers were found, otherwise False.
+        """
+        directory = pathlib.Path(directory)
+
+        if not directory.exists():
+            raise PathExistsError(f"Path {str(directory)!r} does not exists.")
+
+        dps: list[typing.Self] = []
+        for root, _, files in os.walk(directory):
+            for f in files:
+                if f.endswith(".py") and f != "__init__.py":
+                    module_path = os.path.join(root, f)
+                    module_name = os.path.splitext(os.path.relpath(module_path, directory))[0]
+                    module_name = module_name.replace(os.sep, ".")
+
+                    spec = importlib_util.spec_from_file_location(module_name, module_path)
+                    if spec is None or spec.loader is None:
+                        continue
+
+                    module = importlib_util.module_from_spec(spec)
+                    sys.modules[module_name] = module
+                    spec.loader.exec_module(module)
+
+                    for obj in module.__dict__.values():
+                        if isinstance(obj, self.__class__):
+                            dps.append(obj)
+
+        self.load_many(*dps)
+        return bool(dps)
+
+
+__all__ = ("ABCDispatch",)

telegrinder/bot/dispatch/context.py

@@ -1,98 +1,96 @@
-from __future__ import annotations
-
-import enum
-import typing
-from reprlib import recursive_repr
-
-from telegrinder.types.objects import Update
-
-if typing.TYPE_CHECKING:
-    from telegrinder.node.composer import NodeCollection
-
-T = typing.TypeVar("T")
-
-Key: typing.TypeAlias = str | enum.Enum
-AnyValue: typing.TypeAlias = typing.Any
-
-
-class Context(dict[str, AnyValue]):
-    """Context class like dict & dotdict.
-
-    For example:
-    ```python
-    class MyRule(ABCRule[T]):
-        async def check(self, event: T, ctx: Context) -> bool:
-            ctx.me = (await event.ctx_api.get_me()).unwrap()
-            ctx["items"] = [1, 2, 3]
-            return True
-    ```
-    """
-
-    raw_update: Update
-    node_col: NodeCollection | None = None
-
-    def __init__(self, **kwargs: AnyValue) -> None:
-        cls_vars = vars(self.__class__)
-        defaults = {}
-
-        for k in self.__class__.__annotations__:
-            if k in cls_vars:
-                defaults[k] = cls_vars[k]
-                delattr(self.__class__, k)
-
-        dict.__init__(self, **defaults | kwargs)
-
-    @recursive_repr()
-    def __repr__(self) -> str:
-        return "{}({})".format(self.__class__.__name__, ", ".join(f"{k}={v!r}" for k, v in self.items()))
-
-    def __setitem__(self, __key: Key, __value: AnyValue) -> None:
-        dict.__setitem__(self, self.key_to_str(__key), __value)
-
-    def __getitem__(self, __key: Key) -> AnyValue:
-        return dict.__getitem__(self, self.key_to_str(__key))
-
-    def __delitem__(self, __key: Key) -> None:
-        dict.__delitem__(self, self.key_to_str(__key))
-
-    def __setattr__(self, __name: str, __value: AnyValue) -> None:
-        self.__setitem__(__name, __value)
-
-    def __getattr__(self, __name: str) -> AnyValue:
-        return self.__getitem__(__name)
-
-    def __delattr__(self, __name: str) -> None:
-        self.__delitem__(__name)
-
-    @staticmethod
-    def key_to_str(key: Key) -> str:
-        return key if isinstance(key, str) else str(key.value)
-
-    def copy(self) -> typing.Self:
-        return self.__class__(**dict.copy(self))
-
-    def set(self, key: Key, value: AnyValue) -> None:
-        self[key] = value
-
-    @typing.overload
-    def get(self, key: Key) -> AnyValue | None: ...
-
-    @typing.overload
-    def get(self, key: Key, default: T) -> T | AnyValue: ...
-
-    @typing.overload
-    def get(self, key: Key, default: None = None) -> AnyValue | None: ...
-
-    def get(self, key: Key, default: T | None = None) -> T | AnyValue | None:
-        return dict.get(self, key, default)
-
-    def get_or_set(self, key: Key, default: T) -> T:
-        if key not in self:
-            self.set(key, default)
-        return self.get(key, default)
-
-    def delete(self, key: Key) -> None:
-        del self[key]
-
-
-__all__ = ("Context",)
+from __future__ import annotations
+
+import enum
+import typing
+from reprlib import recursive_repr
+
+from telegrinder.types.objects import Update
+
+if typing.TYPE_CHECKING:
+    from telegrinder.node.composer import NodeCollection
+
+type Key = str | enum.Enum
+type AnyValue = typing.Any
+
+
+class Context(dict[str, AnyValue]):
+    """Context class like dict & dotdict.
+
+    For example:
+    ```python
+    class MyRule(ABCRule[T]):
+        async def check(self, event: T, ctx: Context) -> bool:
+            ctx.me = (await event.ctx_api.get_me()).unwrap()
+            ctx["items"] = [1, 2, 3]
+            return True
+    ```
+    """
+
+    raw_update: Update
+    node_col: NodeCollection | None = None
+
+    def __init__(self, **kwargs: AnyValue) -> None:
+        cls_vars = vars(self.__class__)
+        defaults = {}
+
+        for k in self.__class__.__annotations__:
+            if k in cls_vars:
+                defaults[k] = cls_vars[k]
+                delattr(self.__class__, k)
+
+        dict.__init__(self, **defaults | kwargs)
+
+    @recursive_repr()
+    def __repr__(self) -> str:
+        return "{}({})".format(self.__class__.__name__, ", ".join(f"{k}={v!r}" for k, v in self.items()))
+
+    def __setitem__(self, __key: Key, __value: AnyValue) -> None:
+        dict.__setitem__(self, self.key_to_str(__key), __value)
+
+    def __getitem__(self, __key: Key) -> AnyValue:
+        return dict.__getitem__(self, self.key_to_str(__key))
+
+    def __delitem__(self, __key: Key) -> None:
+        dict.__delitem__(self, self.key_to_str(__key))
+
+    def __setattr__(self, __name: str, __value: AnyValue) -> None:
+        self.__setitem__(__name, __value)
+
+    def __getattr__(self, __name: str) -> AnyValue:
+        return self.__getitem__(__name)
+
+    def __delattr__(self, __name: str) -> None:
+        self.__delitem__(__name)
+
+    @staticmethod
+    def key_to_str(key: Key) -> str:
+        return key if isinstance(key, str) else str(key.value)
+
+    def copy(self) -> typing.Self:
+        return self.__class__(**dict.copy(self))
+
+    def set(self, key: Key, value: AnyValue) -> None:
+        self[key] = value
+
+    @typing.overload
+    def get(self, key: Key) -> AnyValue | None: ...
+
+    @typing.overload
+    def get[T](self, key: Key, default: T) -> T | AnyValue: ...
+
+    @typing.overload
+    def get(self, key: Key, default: None = None) -> AnyValue | None: ...
+
+    def get[T](self, key: Key, default: T | None = None) -> T | AnyValue | None:
+        return dict.get(self, key, default)
+
+    def get_or_set[T](self, key: Key, default: T) -> T:
+        if key not in self:
+            self.set(key, default)
+        return self.get(key, default)
+
+    def delete(self, key: Key) -> None:
+        del self[key]
+
+
+__all__ = ("Context",)