PySPlusthon 0.5.3__py3-none-any.whl

PySPlusthon/conditions/new_chat_members.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def new_chat_members(event) -> bool:
+    return bool(event.new_chat_members)

PySPlusthon/conditions/new_chat_photo.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def new_chat_photo(event) -> bool:
+    return bool(event.new_chat_photo)

PySPlusthon/conditions/new_chat_title.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def new_chat_title(event) -> bool:
+    return bool(event.new_chat_title)

PySPlusthon/conditions/number.py

@@ -0,0 +1,12 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def number(event) -> bool:
+    try:
+        int(event.content)
+    except ValueError:
+        return False
+    else:
+        return True

PySPlusthon/conditions/photo.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def photo(event) -> bool:
+    return bool(event.photo)

PySPlusthon/conditions/pinned_message.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def pinned_message(event) -> bool:
+    return bool(event.pinned_message)

PySPlusthon/conditions/poll.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def poll(event) -> bool:
+    return bool(event.poll)

PySPlusthon/conditions/private.py

@@ -0,0 +1,11 @@
+from .condition import create
+from ..objects import Message, CallbackQuery
+from ..enums import ChatType
+
+
+@create(can_process=(Message, CallbackQuery))
+def private(event) -> bool:
+    if isinstance(event, Message):
+        return event.chat.type == ChatType.PRIVATE
+    elif isinstance(event, CallbackQuery):
+        return event.message.chat.type == ChatType.PRIVATE

PySPlusthon/conditions/regex.py

@@ -0,0 +1,17 @@
+from re import compile
+
+from .condition import Condition
+from ..objects import Message, CallbackQuery
+
+
+class Regex(Condition):
+    def __init__(self, pattern, flags=0):
+        super().__init__(can_process=(Message, CallbackQuery))
+        self.pattern = compile(pattern, flags)
+
+    async def process(self, client, event) -> bool:
+        if isinstance(event, Message):
+            event = event.content
+        elif isinstance(event, CallbackQuery):
+            event = event.data
+        return bool(list(self.pattern.finditer(event)) or None)

PySPlusthon/conditions/reply.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def reply(event) -> bool:
+    return bool(event.reply_to_message)

PySPlusthon/conditions/sticker.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def sticker(event) -> bool:
+    return bool(event.sticker)

PySPlusthon/conditions/supergroup_chat_created.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def supergroup_chat_created(event) -> bool:
+    return bool(event.supergroup_chat_created)

PySPlusthon/conditions/text.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def text(event) -> bool:
+    return bool(event.text)

PySPlusthon/conditions/video.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def video(event) -> bool:
+    return bool(event.video)

PySPlusthon/conditions/voice.py

@@ -0,0 +1,7 @@
+from .condition import create
+from ..objects import Message
+
+
+@create(can_process=Message)
+def voice(event) -> bool:
+    return bool(event.voice)

PySPlusthon/dispatcher/__init__.py

@@ -0,0 +1,5 @@
+from .chain import Chain
+from .dispatcher import Dispatcher
+from .printing_chain import PrintingChain
+from .logging_chain import LoggingChain
+from .monitoring_chain import MonitoringChain

PySPlusthon/dispatcher/chain.py

@@ -0,0 +1,165 @@
+from ..event_handlers import (
+    ConnectHandler,
+    InitializeHandler,
+    EventHandler,
+    ErrorHandler,
+    UpdateHandler,
+    MessageHandler,
+    EditedMessageHandler,
+    CommandHandler,
+    CallbackQueryHandler,
+    ShippingQueryHandler,
+    ShutdownHandler,
+    DisconnectHandler
+)
+
+
+class Chain:
+
+    def __init__(self, name, condition=None, *chains):
+        self.name = name
+        self.condition = condition
+        self.chains = list(chains)
+        self.children = []
+        for attribute_name in dir(self):
+            attribute = getattr(self, attribute_name)
+            if isinstance(attribute, EventHandler):
+                attribute.self = self
+                self.add_event_handler(attribute)
+
+    async def check(self, client, event):
+        if self.condition is None:
+            return True
+        return await self.condition(client, event)
+
+    @staticmethod
+    def create_event_handler(event_handler, *args, **kwargs):
+        def decorator(callback):
+            return event_handler(callback, *args, **kwargs)
+        return decorator
+
+    def add_event_handler(self, event_handler, *args, **kwargs):
+        if isinstance(event_handler, type):
+            def decorator(callback):
+                event_handler_instance = event_handler(callback, *args, **kwargs)
+                self.add_event_handler(event_handler_instance)
+                return event_handler_instance
+            return decorator
+        self.children.append(event_handler)
+
+    @classmethod
+    def connect_handler(cls):
+        return cls.create_event_handler(ConnectHandler)
+
+    def on_connect(self):
+        return self.add_event_handler(ConnectHandler)
+
+    @classmethod
+    def initialize_handler(cls):
+        return cls.create_event_handler(InitializeHandler)
+
+    def on_initialize(self):
+        return self.add_event_handler(InitializeHandler)
+
+    @classmethod
+    def event_handler(cls, condition=None):
+        return cls.create_event_handler(EventHandler, condition)
+
+    def on_event(self, condition=None):
+        return self.add_event_handler(EventHandler, condition)
+
+    @classmethod
+    def error_handler(cls, condition=None):
+        return cls.create_event_handler(ErrorHandler, condition)
+
+    def on_error(self, condition=None):
+        return self.add_event_handler(ErrorHandler, condition)
+
+    @classmethod
+    def update_handler(cls, condition=None):
+        return cls.create_event_handler(UpdateHandler, condition)
+
+    def on_update(self, condition=None):
+        return self.add_event_handler(UpdateHandler, condition)
+
+    @classmethod
+    def message_handler(cls, condition=None):
+        return cls.create_event_handler(MessageHandler, condition)
+
+    def on_message(self, condition=None):
+        return self.add_event_handler(MessageHandler, condition)
+
+    @classmethod
+    def edited_message_handler(cls, condition=None):
+        return cls.create_event_handler(EditedMessageHandler, condition)
+
+    def on_edited_message(self, condition=None):
+        return self.add_event_handler(EditedMessageHandler, condition)
+
+    @classmethod
+    def command_handler(cls, condition=None, name=None, prefix="/", min_arguments=None, max_arguments=None):
+        return cls.create_event_handler(CommandHandler, condition, name, prefix, min_arguments, max_arguments)
+
+    def on_command(self, condition=None, name=None, prefix="/", min_arguments=None, max_arguments=None):
+        return self.add_event_handler(CommandHandler, condition, name, prefix, min_arguments, max_arguments)
+
+    @classmethod
+    def callback_query_handler(cls, condition=None):
+        return cls.create_event_handler(CallbackQueryHandler, condition)
+
+    def on_callback_query(self, condition=None):
+        return self.add_event_handler(CallbackQueryHandler, condition)
+
+    @classmethod
+    def pre_checkout_query_handler(cls, condition=None):
+        return cls.create_event_handler(PreCheckoutQueryHandler, condition)
+
+    def on_pre_checkout_query(self, condition=None):
+        return self.add_event_handler(PreCheckoutQueryHandler, condition)
+
+    @classmethod
+    def shipping_query_handler(cls, condition=None):
+        return cls.create_event_handler(ShippingQueryHandler, condition)
+
+    def on_shipping_query(self, condition=None):
+        return self.add_event_handler(ShippingQueryHandler, condition)
+
+    @classmethod
+    def shutdown_handler(cls):
+        return cls.create_event_handler(ShutdownHandler)
+
+    def on_shutdown(self):
+        return self.add_event_handler(ShutdownHandler)
+
+    @classmethod
+    def disconnect_handler(cls):
+        return cls.create_event_handler(DisconnectHandler)
+
+    def on_disconnect(self):
+        return self.add_event_handler(DisconnectHandler)
+
+    def remove_event_handler(self, event_handler):
+        self.children.remove(event_handler)
+
+    def add(self, *chains):
+        self.children.extend(chains)
+
+    def include(self, *chains):
+        self.chains.extend(chains)
+
+    def get(self, name):
+        for chain in self.chains:
+            if chain.name == name:
+                return chain
+        raise ValueError(f"Chain \"{name}\" does not exist")
+
+    def delete(self, name):
+        for i, c in enumerate(self.chains):
+            if c.name == name:
+                del self.chains[i]
+                return
+        for i, c in enumerate(self.children):
+            if isinstance(c, Chain) and c.name == name:
+                del self.children[i]
+                return
+        raise ValueError(f"Chain \"{name}\" does not exist")

PySPlusthon/dispatcher/dispatcher.py

@@ -0,0 +1,124 @@
+from asyncio import Queue, get_running_loop
+from concurrent.futures import ThreadPoolExecutor
+from os import cpu_count
+
+from .chain import Chain
+from ..errors import ContinueDispatching, BreakDispatching
+from ..event_handlers import EventHandler
+from ..objects import Update
+
+
+def is_subclass(cls, super_cls):
+    if not isinstance(cls, type):
+        return False
+    return issubclass(cls, super_cls)
+
+
+class Dispatcher:
+    reasonable_sync_workers = min(32, (cpu_count() or 1) + 4)
+    reasonable_async_workers = reasonable_sync_workers * 5
+
+    def __init__(
+            self,
+            *clients,
+            async_workers: int = None,
+            sync_workers: int = None,
+            use_concurrency: bool = True
+    ):
+        self.clients = clients
+        self.event_loop = None
+        self.events_queue = Queue()
+        self.is_started = False
+        self.async_workers_count = async_workers or self.reasonable_async_workers
+        self.async_workers = []
+        self.sync_workers_count = sync_workers or self.reasonable_sync_workers
+        self.sync_workers = None
+        self.use_concurrency = use_concurrency
+
+    async def start(self):
+        if self.is_started:
+            raise RuntimeError("Dispatcher is already started")
+        self.event_loop = get_running_loop()
+        self.is_started = True
+        if self.use_concurrency:
+            self.async_workers = [self.event_loop.create_task(self.worker()) for _ in range(self.async_workers_count)]
+            self.sync_workers = ThreadPoolExecutor(self.sync_workers_count, thread_name_prefix="Event Handler")
+
+    async def stop(self):
+        if not self.is_started:
+            raise RuntimeError("Dispatcher is already stopped")
+        self.is_started = False
+        if self.use_concurrency:
+            for _ in self.async_workers:
+                self.events_queue.put_nowait(None)
+            for async_worker in self.async_workers:
+                await async_worker
+            self.async_workers.clear()
+            self.sync_workers.shutdown()
+
+    async def propagate_chain(self, chain, client, event):
+        for child in chain.children:
+            if isinstance(child, Chain):
+                try:
+                    if not await child.check(client, event):
+                        continue
+                except ContinueDispatching:
+                    continue
+                except BreakDispatching:
+                    break
+                except Exception as error:
+                    await self.dispatch_event(client, error)
+                    continue
+                await self.propagate_chain(child, client, event)
+                break
+
+            elif isinstance(child, EventHandler):
+                if not isinstance(event, child.can_handle) and not is_subclass(event, child.can_handle):
+                    continue
+
+                try:
+                    if not await child.check(client, event):
+                        continue
+                    await child.handle(client=client, event=event)
+                    break
+                except ContinueDispatching:
+                    continue
+                except BreakDispatching:
+                    break
+                except Exception as error:
+                    await self.dispatch_event(client, error)
+                    break
+
+        for child in chain.chains:
+            try:
+                if not await child.check(client, event):
+                    continue
+            except ContinueDispatching:
+                continue
+            except BreakDispatching:
+                break
+            except Exception as error:
+                await self.dispatch_event(client, error)
+                continue
+
+            await self.propagate_chain(child, client, event)
+
+    async def worker(self):
+        while True:
+            item = await self.events_queue.get()
+            if item is None:
+                break
+            client, event = item
+            await self.propagate_chain(client, client, event)
+
+    async def dispatch_event(self, client, event):
+        if self.is_started:
+            if self.use_concurrency:
+                self.events_queue.put_nowait((client, event))
+            else:
+                await self.propagate_chain(client, client, event)
+
+    async def dispatch_raw_update(self, client, update):
+        update = Update.wrap(update).get_effective_update()
+        update.bind(client)
+        await self.dispatch_event(client, update)

PySPlusthon/dispatcher/logging_chain.py

@@ -0,0 +1,36 @@
+from logging import getLogger
+
+from .chain import Chain
+
+
+class LoggingChain(Chain):
+
+    def __init__(self, name="logging", condition=None, logger=None):
+        super().__init__(name, condition)
+        self.log = logger or getLogger(self.name)
+
+    @Chain.error_handler()
+    def log_error(self, error):
+        self.log.exception(error)
+
+    @Chain.connect_handler()
+    def log_connect(self, client):
+        self.log.info(f"{client} connected")
+
+    @Chain.initialize_handler()
+    def log_initialize(self, client):
+        sync_workers = client.dispatcher.sync_workers_count
+        async_workers = client.dispatcher.async_workers_count
+        self.log.info(f"{client} initialized (sync workers: {sync_workers} - async workers: {async_workers})")
+
+    @Chain.shutdown_handler()
+    def log_shutdown(self, client):
+        self.log.info(f"{client} shutting down")
+
+    @Chain.disconnect_handler()
+    def log_disconnect(self, client):
+        self.log.info(f"{client} disconnected")
+
+    @Chain.event_handler()
+    def log_event(self, event):
+        self.log.info(event)

PySPlusthon/dispatcher/monitoring_chain.py

@@ -0,0 +1,19 @@
+from sys import stdout
+
+from .chain import Chain
+
+
+class MonitoringChain(Chain):
+    def __init__(self, name="monitoring", condition=None, stream=None):
+        super().__init__(name, condition)
+        self.stream = stream or stdout
+
+    @Chain.message_handler()
+    def monitor_message(self, message):
+        if not message.author:
+            return
+        self.stream.write(f"{message.author.full_name}: {message.content}\n")
+
+    @Chain.callback_query_handler()
+    def monitor_callback_query(self, callback_query):
+        self.stream.write(f"{callback_query.author.full_name}: [{callback_query.data}]\n")

PySPlusthon/dispatcher/printing_chain.py

@@ -0,0 +1,21 @@
+from traceback import print_exception
+
+from .chain import Chain
+
+
+class PrintingChain(Chain):
+
+    def __init__(self, name="printing", condition=None):
+        super().__init__(name, condition)
+
+    @Chain.error_handler()
+    def print_error(self, error):
+        print_exception(None, error, error.__traceback__)
+
+    @Chain.initialize_handler()
+    def print_ready(self, client):
+        print(f"---{client} is ready---")
+
+    @Chain.shutdown_handler()
+    def print_stopped(self, client):
+        print(f"---{client} has stopped---")

PySPlusthon/enums/__init__.py

@@ -0,0 +1,7 @@
+from .name_enum import NameEnum
+from .chat_type import ChatType
+from .message_media_type import MessageMediaType
+from .chat_member_status import ChatMemberStatus
+from .transaction_status import TransactionStatus
+from .poll_type import PollType
+from .peer_type import PeerType

PySPlusthon/enums/chat_member_status.py

@@ -0,0 +1,9 @@
+from enum import auto
+
+from .name_enum import NameEnum
+
+
+class ChatMemberStatus(NameEnum):
+    MEMBER = auto()
+    ADMINISTRATOR = auto()
+    CREATOR = auto()

PySPlusthon/enums/chat_type.py

@@ -0,0 +1,9 @@
+from enum import auto
+
+from .name_enum import NameEnum
+
+
+class ChatType(NameEnum):
+    PRIVATE = auto()
+    GROUP = auto()
+    CHANNEL = auto()

PySPlusthon/enums/message_media_type.py

@@ -0,0 +1,16 @@
+from enum import auto
+
+from .name_enum import NameEnum
+
+
+class MessageMediaType(NameEnum):
+    PHOTO = auto()
+    VOICE = auto()
+    AUDIO = auto()
+    VIDEO = auto()
+    ANIMATION = auto()
+    CONTACT = auto()
+    LOCATION = auto()
+    STICKER = auto()
+    DOCUMENT = auto()
+    POLL = auto()

PySPlusthon/enums/name_enum.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+class NameEnum(Enum):
+    @staticmethod
+    def _generate_next_value_(name, start, count, last_values):
+        return name.lower()
+
+    def __repr__(self):
+        return super().__str__()
+
+    def __eq__(self, other):
+        return self.value == other

PySPlusthon/enums/peer_type.py

@@ -0,0 +1,8 @@
+from enum import auto
+
+from .name_enum import NameEnum
+
+
+class PeerType(NameEnum):
+    USER = auto()
+    CHANNEL = auto()

PySPlusthon/enums/poll_type.py

@@ -0,0 +1,8 @@
+from enum import auto
+
+from .name_enum import NameEnum
+
+
+class PollType(NameEnum):
+    REGULAR = auto()
+    QUIZ = auto()

PySPlusthon/enums/transaction_status.py

@@ -0,0 +1,10 @@
+from enum import auto
+
+from .name_enum import NameEnum
+
+
+class TransactionStatus(NameEnum):
+    PENDING = auto()
+    PAID = auto()
+    FAILED = auto()
+    REJECTED = auto()

PySPlusthon/errors/__init__.py

@@ -0,0 +1,11 @@
+from .dispatching_errors import BreakDispatching, ContinueDispatching
+from .rpc_errors import (
+    BadRequestError,
+    FloodError,
+    ForbiddenError,
+    InternalError,
+    NotFoundError,
+    RPCError,
+    UnauthorizedError,
+    TooManyRequestsError
+)

PySPlusthon/errors/dispatching_errors/__init__.py

@@ -0,0 +1,2 @@
+from .break_dispatching import BreakDispatching
+from .continue_dispatching import ContinueDispatching

PySPlusthon/errors/dispatching_errors/break_dispatching.py

@@ -0,0 +1,2 @@
+class BreakDispatching(Exception):
+    pass

PySPlusthon/errors/dispatching_errors/continue_dispatching.py

@@ -0,0 +1,2 @@
+class ContinueDispatching(Exception):
+    pass

PySPlusthon/errors/rpc_errors/__init__.py

@@ -0,0 +1,8 @@
+from .bad_request_error import BadRequestError
+from .flood_error import FloodError
+from .forbidden_error import ForbiddenError
+from .internal_error import InternalError
+from .not_found_error import NotFoundError
+from .rpc_error import RPCError
+from .too_many_requests import TooManyRequestsError
+from .unauthorized_error import UnauthorizedError

PySPlusthon/errors/rpc_errors/bad_request_error.py

@@ -0,0 +1,6 @@
+from .rpc_error import RPCError
+
+
+class BadRequestError(RPCError):
+    name = "Bad Request"
+    code = 400

PySPlusthon/errors/rpc_errors/flood_error.py

@@ -0,0 +1,6 @@
+from .rpc_error import RPCError
+
+
+class FloodError(RPCError):
+    name = "Flood"
+    code = 420