PySPlusthon 0.5.3__py3-none-any.whl

PySPlusthon/errors/rpc_errors/forbidden_error.py

@@ -0,0 +1,6 @@
+from .rpc_error import RPCError
+
+
+class ForbiddenError(RPCError):
+    name = "Forbidden"
+    code = 403

PySPlusthon/errors/rpc_errors/internal_error.py

@@ -0,0 +1,6 @@
+from .rpc_error import RPCError
+
+
+class InternalError(RPCError):
+    name = "Internal"
+    code = 500

PySPlusthon/errors/rpc_errors/not_found_error.py

@@ -0,0 +1,6 @@
+from .rpc_error import RPCError
+
+
+class NotFoundError(RPCError):
+    name = "Not Found"
+    code = 404

PySPlusthon/errors/rpc_errors/rpc_error.py

@@ -0,0 +1,23 @@
+class RPCError(Exception):
+    name = "RPC Error"
+    code = None
+
+    @classmethod
+    def create(cls, code: int = None, description: str = None, reason: str = None, parameters: dict = None):
+        for rpc_error in cls.__subclasses__():
+            if code == rpc_error.code:
+                return rpc_error(code, description, reason, parameters)
+        return cls(code, description, reason, parameters)
+
+    def __init__(self, code: int = None, description: str = None, reason: str = None, parameters: dict = None):
+        self.code = code or self.code
+        self.description = description
+        self.reason = reason
+        self.parameters = parameters
+        super().__init__(str(self))
+
+    def __str__(self):
+        code = "" if self.code is None else f" {self.code}"
+        description = "" if not self.description else f": {self.description}"
+        reason = "" if self.reason is None else f" (caused by {self.reason})"
+        return f"{self.name}{code}{description}{reason}"

PySPlusthon/errors/rpc_errors/too_many_requests.py

@@ -0,0 +1,10 @@
+from .rpc_error import RPCError
+
+
+class TooManyRequestsError(RPCError):
+    name = "Too Many Requests"
+    code = 429
+
+    def __init__(self, code: int = None, description: str = None, reason: str = None, parameters: dict = None):
+        super().__init__(code, description, reason, parameters)
+        self.seconds = (parameters or {}).get("retry_after", 0)

PySPlusthon/errors/rpc_errors/unauthorized_error.py

@@ -0,0 +1,6 @@
+from .rpc_error import RPCError
+
+
+class UnauthorizedError(RPCError):
+    name = "Unauthorized"
+    code = 401

PySPlusthon/event_handlers/__init__.py

@@ -0,0 +1,12 @@
+from .event_handler import EventHandler
+from .connect_handler import ConnectHandler
+from .disconnect_handler import DisconnectHandler
+from .error_handler import ErrorHandler
+from .update_handler import UpdateHandler
+from .message_handler import MessageHandler
+from .callback_query_handler import CallbackQueryHandler
+from .command_handler import CommandHandler
+from .shipping_query_handler import ShippingQueryHandler
+from .edited_message_handler import EditedMessageHandler
+from .initialize_handler import InitializeHandler
+from .shutdown_handler import ShutdownHandler

PySPlusthon/event_handlers/callback_query_handler.py

@@ -0,0 +1,16 @@
+from .update_handler import UpdateHandler
+from ..objects import CallbackQuery
+
+
+class CallbackQueryHandler(UpdateHandler):
+    can_handle = CallbackQuery
+
+    def __init__(self, callback, condition=None):
+        super().__init__(callback, condition)
+
+    def handle(self, *args, client=None, event=None, **kwargs):
+        if client is not None:
+            kwargs["client"] = client
+        if event is not None:
+            kwargs["callback_query"] = event
+        return super().handle(*args, **kwargs)

PySPlusthon/event_handlers/command_handler.py

@@ -0,0 +1,46 @@
+from inspect import getfullargspec
+
+from .message_handler import MessageHandler
+from ..conditions import command
+from ..objects import Message
+
+
+class CommandHandler(MessageHandler):
+    can_handle = Message
+
+    @staticmethod
+    def get_min_arguments(callback):
+        args, _, __, defaults, *___ = getfullargspec(callback)
+        args_count = len(args)
+        defaults_count = 0 if defaults is None else len(defaults)
+        return args_count - defaults_count
+
+    @staticmethod
+    def get_max_arguments(callback):
+        args, varargs, *_ = getfullargspec(callback)
+        if varargs is not None:
+            return None
+        return len(args)
+
+    def __init__(self, callback, condition=None, name=None, prefix="/", min_arguments=None, max_arguments=None):
+        if name is None:
+            name = callback.__name__
+        if min_arguments is None:
+            min_arguments = self.get_min_arguments(callback)
+        if max_arguments is None:
+            max_arguments = self.get_max_arguments(callback)
+        command_condition = command(name, prefix, min_arguments, max_arguments)
+        if condition is None:
+            condition = command_condition
+        else:
+            condition = command_condition & condition
+        super().__init__(callback, condition)
+
+    def handle(self, *args, client=None, event=None, **kwargs):
+        if client is not None:
+            kwargs["client"] = client
+        if event is not None:
+            kwargs["message"] = event
+            _, *arguments = event.text.split()
+            args += tuple(arguments)
+        return super().handle(*args, **kwargs)

PySPlusthon/event_handlers/connect_handler.py

@@ -0,0 +1,19 @@
+from datetime import datetime
+
+from .initialize_handler import EventHandler
+
+
+class ConnectHandler(EventHandler):
+
+    @property
+    def can_handle(self):
+        return ConnectHandler
+
+    def __init__(self, callback):
+        super().__init__(callback)
+
+    async def handle(self, *args, client=None, event=None, **kwargs):
+        if client is not None:
+            kwargs["client"] = client
+        await super().handle(*args, **kwargs, time=datetime.now())
+

PySPlusthon/event_handlers/disconnect_handler.py

@@ -0,0 +1,18 @@
+from datetime import datetime
+
+from .shutdown_handler import EventHandler
+
+
+class DisconnectHandler(EventHandler):
+
+    @property
+    def can_handle(self):
+        return DisconnectHandler
+
+    def __init__(self, callback):
+        super().__init__(callback)
+
+    async def handle(self, *args, client=None, event=None, **kwargs):
+        if client is not None:
+            kwargs["client"] = client
+        await super().handle(*args, **kwargs, time=datetime.now())

PySPlusthon/event_handlers/edited_message_handler.py

@@ -0,0 +1,16 @@
+from .update_handler import UpdateHandler
+from ..objects import EditedMessage
+
+
+class EditedMessageHandler(UpdateHandler):
+    can_handle = EditedMessage
+
+    def __init__(self, callback, condition=None):
+        super().__init__(callback, condition)
+
+    def handle(self, *args, client=None, event=None, **kwargs):
+        if client is not None:
+            kwargs["client"] = client
+        if event is not None:
+            kwargs["edited_message"] = event
+        return super().handle(*args, **kwargs)

PySPlusthon/event_handlers/error_handler.py

@@ -0,0 +1,15 @@
+from .event_handler import EventHandler
+
+
+class ErrorHandler(EventHandler):
+    can_handle = Exception
+
+    def __init__(self, callback, condition=None):
+        super().__init__(callback, condition)
+
+    async def handle(self, *args, client=None, event=None, **kwargs):
+        if client is not None:
+            kwargs["client"] = client
+        if event is not None:
+            kwargs["error"] = event
+        await super().handle(*args, **kwargs)

PySPlusthon/event_handlers/event_handler.py

@@ -0,0 +1,53 @@
+from typing import Callable
+from inspect import iscoroutinefunction
+from functools import partial
+
+from ..conditions import Condition, create
+from ..smart_call import remove_unwanted_parameters
+
+
+class EventHandler:
+    can_handle = object
+
+    def __init__(self, callback: Callable, condition=None):
+        self.callback = callback
+        if not isinstance(condition, Condition) and condition is not None:
+            condition = create(condition)
+        self.condition = condition
+        self.self = None
+
+    def to_string(self, keyword="if", tabs=0):
+        result = []
+        condition = self.condition or self.can_handle.__name__
+        result.append(f"{keyword} {condition}:")
+        result.append(f"    {type(self).__name__}({self.can_handle.__name__})")
+        return "\n".join(f"{'    ' * tabs}{i}" for i in result)
+
+    def __repr__(self):
+        return self.to_string()
+
+    async def check(self, client, event):
+        if self.condition is None:
+            return True
+        return await self.condition(client, event)
+
+    async def handle(self, *args, client=None, event=None, **kwargs):
+        if client is not None:
+            kwargs["client"] = client
+        client = kwargs["client"]
+        if self.self is not None:
+            args = list(args)
+            args.insert(0, self.self)
+        if event is not None:
+            kwargs["event"] = event
+        args, kwargs = remove_unwanted_parameters(self.callback, *args, **kwargs)
+        if iscoroutinefunction(self.callback):
+            return await self.callback(*args, **kwargs)
+        return client.dispatcher.event_loop.run_in_executor(
+            client.dispatcher.sync_workers,
+            partial(self.callback, *args, **kwargs)
+        )
+
+    def __call__(self, *args, **kwargs):
+        args, kwargs = remove_unwanted_parameters(self.callback, *args, **kwargs)
+        return self.callback(*args, **kwargs)

PySPlusthon/event_handlers/initialize_handler.py

@@ -0,0 +1,18 @@
+from datetime import datetime
+
+from .event_handler import EventHandler
+
+
+class InitializeHandler(EventHandler):
+
+    @property
+    def can_handle(self):
+        return InitializeHandler
+
+    def __init__(self, callback):
+        super().__init__(callback)
+
+    async def handle(self, *args, client=None, event=None, **kwargs):
+        if client is not None:
+            kwargs["client"] = client
+        await super().handle(*args, **kwargs, time=datetime.now())

PySPlusthon/event_handlers/message_handler.py

@@ -0,0 +1,16 @@
+from .update_handler import UpdateHandler
+from ..objects import Message
+
+
+class MessageHandler(UpdateHandler):
+    can_handle = Message
+
+    def __init__(self, callback, condition=None):
+        super().__init__(callback, condition)
+
+    def handle(self, *args, client=None, event=None, **kwargs):
+        if client is not None:
+            kwargs["client"] = client
+        if event is not None:
+            kwargs["message"] = event
+        return super().handle(*args, **kwargs)

PySPlusthon/event_handlers/shipping_query_handler.py

@@ -0,0 +1,16 @@
+from .update_handler import UpdateHandler
+from ..objects import ShippingQuery
+
+
+class ShippingQueryHandler(UpdateHandler):
+    can_handle = ShippingQuery
+
+    def __init__(self, callback, condition=None):
+        super().__init__(callback, condition)
+
+    def handle(self, *args, client=None, event=None, **kwargs):
+        if client is not None:
+            kwargs["client"] = client
+        if event is not None:
+            kwargs["shipping_query"] = event
+        return super().handle(*args, **kwargs)

PySPlusthon/event_handlers/shutdown_handler.py

@@ -0,0 +1,18 @@
+from datetime import datetime
+
+from .event_handler import EventHandler
+
+
+class ShutdownHandler(EventHandler):
+
+    @property
+    def can_handle(self):
+        return ShutdownHandler
+
+    def __init__(self, callback):
+        super().__init__(callback)
+
+    async def handle(self, *args, client=None, event=None, **kwargs):
+        if client is not None:
+            kwargs["client"] = client
+        await super().handle(*args, **kwargs, time=datetime.now())

PySPlusthon/event_handlers/update_handler.py

@@ -0,0 +1,16 @@
+from .event_handler import EventHandler
+from ..objects import Object
+
+
+class UpdateHandler(EventHandler):
+    can_handle = Object
+
+    def __init__(self, callback, condition=None):
+        super().__init__(callback, condition)
+
+    async def handle(self, *args, client=None, event=None, **kwargs):
+        if client is not None:
+            kwargs["client"] = client
+        if event is not None:
+            kwargs["update"] = event
+        await super().handle(*args, **kwargs)

PySPlusthon/network/__init__.py

@@ -0,0 +1 @@
+from .httpconnection import HTTPConnection

PySPlusthon/network/httpconnection.py

@@ -0,0 +1,74 @@
+from logging import getLogger
+
+from httpx import AsyncClient
+from httpx._types import ProxyTypes
+
+from ..errors import RPCError
+
+log = getLogger(__name__)
+
+
+class HTTPConnection:
+    TIMEOUT = 20
+    BASE_URL = "https://api.splus.ir"
+    SHORT_URL = "https://splus.ir"
+
+    def __init__(
+            self,
+            token: str,
+            time_out: int = None,
+            proxy: ProxyTypes = None,
+            base_url: str = None,
+            short_url: str = None
+    ):
+        self.token = token
+        self.client = None
+        self.is_started = False
+        self.time_out = time_out or self.TIMEOUT
+        self.proxy = proxy
+        self.base_url = base_url or self.BASE_URL
+        self.short_url = short_url or self.SHORT_URL
+
+    async def start(self):
+        if self.is_started:
+            raise ConnectionError("Connection is already started")
+        self.is_started = True
+        self.client = AsyncClient(proxy=self.proxy)
+
+    async def stop(self):
+        if not self.is_started:
+            raise ConnectionError("Connection is already stopped")
+        self.is_started = False
+        await self.client.aclose()
+        self.client = None
+
+    def bot_url(self) -> str:
+        return f"{self.base_url}/bot{self.token}"
+
+    def file_url(self, file_id: str) -> str:
+        return f"{self.base_url}/file/bot{self.token}/{file_id}"
+
+    async def request(self, service: str, data: dict = None, json: dict = None, files: dict = None):
+        if json:
+            log.info(f"[{service}] JSON{json}")
+        if data:
+            log.info(f"[{service}] DATA{data} - FILES{files}")
+        response = await self.client.post(
+            f"{self.bot_url()}/{service}",
+            data=data,
+            files=files,
+            json=json,
+            timeout=self.time_out
+        )
+        response_json = response.json()
+        if response.status_code != 200:
+            code = response.status_code or response_json.get("error_code")
+            raise RPCError.create(code, response_json.get("description"), service, response_json.get("parameters"))
+        return response_json.get("result")
+
+    async def download_file(self, file_id: str):
+        response = await self.client.get(self.file_url(file_id))
+        if response.status_code != 200:
+            response_json = response.json()
+            raise RPCError.create(response.status_code, response_json.get("description"), "downloadFile")
+        return response.read()

PySPlusthon/objects/__init__.py

@@ -0,0 +1,43 @@
+from .object import Object, wrap, unwrap
+from .user import User
+from .date import Date
+from .chat import Chat
+from .update import Update
+from .file import File
+from .chat_member import ChatMember
+from .message import Message
+from .edited_message import EditedMessage
+from .callback_query import CallbackQuery
+from .reply_markup import ReplyMarkup
+from .inline_keyboard_button import InlineKeyboardButton
+from .inline_keyboard import InlineKeyboard
+from .reply_keyboard_button import ReplyKeyboardButton
+from .reply_keyboard import ReplyKeyboard
+from .entity import Entity
+from .shipping_query import ShippingQuery
+from .shipping_address import ShippingAddress
+from .order_info import OrderInfo
+from .audio import Audio
+from .contact import Contact
+from .document import Document
+from .location import Location
+from .photo import Photo
+from .video import Video
+from .voice import Voice
+from .transaction import Transaction
+from .input_media import InputMedia, resolve_media
+from .input_media_photo import InputMediaPhoto
+from .input_media_video import InputMediaVideo
+from .sticker import Sticker
+from .sticker_set import StickerSet
+from .reply_keyboard_remove import ReplyKeyboardRemove
+from .animation import Animation
+from .webhook_info import WebhookInfo
+from .chat_photo import ChatPhoto
+from .invite_link import InviteLink
+from .list import List
+from .poll_option import PollOption
+from .poll import Poll
+from .forward_origin import ForwardOrigin
+from .message_id import MessageId, resolve_message_id
+from .chat_permissions import ChatPermissions

PySPlusthon/objects/animation.py

@@ -0,0 +1,44 @@
+from . import Object
+
+
+class Animation(Object):
+    attribute_names = [
+        ("id", "file_id"),
+        ("unique_id", "file_unique_id"),
+        ("name", "file_name"),
+        ("size", "file_size")
+    ]
+
+    @classmethod
+    def from_protobuf(cls, protobuf_data):
+        return cls(
+            id=protobuf_data.file_id,
+            width=protobuf_data.ext.document_ex_gif.w,
+            height=protobuf_data.ext.document_ex_gif.h,
+            duration=protobuf_data.ext.document_ex_gif.duration,
+            name=protobuf_data.name,
+            mime_type=protobuf_data.mime_type,
+            size=protobuf_data.file_size
+        )
+
+    def __init__(
+            self,
+            id: str = None,
+            unique_id: str = None,
+            width: int = None,
+            height: int = None,
+            duration: int = None,
+            name: str = None,
+            mime_type: str = None,
+            size: int = None,
+            **kwargs
+    ):
+        self.id: str = id
+        self.unique_id: str = unique_id
+        self.width: int = width
+        self.height: int = height
+        self.duration: int = duration
+        self.name: str = name
+        self.mime_type: str = mime_type
+        self.size: int = size
+        super().__init__(**kwargs)

PySPlusthon/objects/audio.py

@@ -0,0 +1,36 @@
+from . import Object
+
+
+class Audio(Object):
+    attribute_names = [
+        ("id", "file_id"),
+        ("size", "file_size")
+    ]
+
+    @classmethod
+    def from_protobuf(cls, protobuf_data):
+        return cls(
+            id=protobuf_data.file_id,
+            duration=protobuf_data.ext.document_ex_audio.duration,
+            title=protobuf_data.ext.document_ex_audio.track,
+            mime_type=protobuf_data.mime_type,
+            size=protobuf_data.file_size
+        )
+
+    def __init__(
+            self,
+            id: str = None,
+            duration: int = None,
+            performer: str = None,
+            title: str = None,
+            mime_type: str = None,
+            size: int = None,
+            **kwargs
+    ):
+        super().__init__(**kwargs)
+        self.id: str = id
+        self.duration: int = duration
+        self.performer: str = performer
+        self.title: str = title
+        self.mime_type: str = mime_type
+        self.size: int = size

PySPlusthon/objects/callback_query.py

@@ -0,0 +1,37 @@
+from . import Object
+from PySPlusthon import objects
+from ..sync_support import add_sync_support_to_object
+
+
+@add_sync_support_to_object
+class CallbackQuery(Object):
+    attribute_names = [
+        ("author", "from")
+    ]
+
+    def __init__(
+            self,
+            id: str = None,
+            author: "objects.User" = None,
+            message: "objects.Message" = None,
+            inline_message_id: str = None,
+            chat_instance: str = None,
+            data: str = None,
+            game_short_name: str = None,
+            **kwargs
+    ):
+        super().__init__(**kwargs)
+        self.id: str = id
+        self.author: "objects.User" = author
+        self.message: "objects.Message" = message
+        self.inline_message_id: str = inline_message_id
+        self.chat_instance: str = chat_instance
+        self.data: str = data
+        self.game_short_name: str = game_short_name
+
+    async def answer(
+            self,
+            text: str,
+            show_alert: bool = False
+    ) -> bool:
+        return await self.client.answer_callback_query(self.id, text, show_alert)