maxapi-python 1.2.4__py3-none-any.whl → 2.0.0__py3-none-any.whl

pymax/crud.py

@@ -1,96 +0,0 @@
-from typing import cast
-from uuid import UUID
-
-from sqlalchemy.engine.base import Engine
-from sqlmodel import Session, SQLModel, create_engine, select
-
-from .models import Auth
-from .static.enum import DeviceType
-
-
-class Database:
-    def __init__(self, workdir: str) -> None:
-        self.workdir = workdir
-        self.engine = self.get_engine(workdir)
-        self.create_all()
-        self._ensure_single_auth()
-
-    def create_all(self) -> None:
-        SQLModel.metadata.create_all(self.engine)
-
-    def get_engine(self, workdir: str) -> Engine:
-        return create_engine(f"sqlite:///{workdir}/session.db")
-
-    def get_session(self) -> Session:
-        return Session(bind=self.engine)
-
-    def get_auth_token(self) -> str | None:
-        with self.get_session() as session:
-            token = cast(str | None, session.exec(select(Auth.token)).first())
-            return token
-
-    def get_device_id(self) -> UUID:
-        with self.get_session() as session:
-            device_id = session.exec(select(Auth.device_id)).first()
-
-            if device_id is None:
-                auth = Auth()
-                session.add(auth)
-                session.commit()
-                session.refresh(auth)
-                return auth.device_id
-            return device_id
-
-    def insert_auth(self, auth: Auth) -> Auth:
-        with self.get_session() as session:
-            session.add(auth)
-            session.commit()
-            session.refresh(auth)
-            return auth
-
-    def update_auth_token(self, device_id: UUID, token: str) -> None:
-        with self.get_session() as session:
-            auth = session.exec(select(Auth).where(Auth.device_id == device_id)).first()
-            if auth:
-                auth.token = token
-                session.add(auth)
-                session.commit()
-                session.refresh(auth)
-                return
-
-            existing = session.exec(select(Auth)).first()
-            if existing:
-                existing.device_id = device_id
-                existing.token = token
-                session.add(existing)
-                session.commit()
-                session.refresh(existing)
-                return
-
-            new_auth = Auth(device_id=device_id, token=token)
-            session.add(new_auth)
-            session.commit()
-            session.refresh(new_auth)
-
-    def update(self, auth: Auth) -> Auth:
-        with self.get_session() as session:
-            session.add(auth)
-            session.commit()
-            session.refresh(auth)
-            return auth
-
-    def _ensure_single_auth(self) -> None:
-        with self.get_session() as session:
-            rows = session.exec(select(Auth)).all()
-            if not rows:
-                auth = Auth(device_type=DeviceType.WEB.value)
-                session.add(auth)
-                session.commit()
-                session.refresh(auth)
-                return
-
-            if len(rows) > 1:
-                _ = rows[0]
-                for extra in rows[1:]:
-                    session.delete(extra)
-                session.commit()

pymax/files.py

@@ -1,138 +0,0 @@
-import mimetypes
-from abc import ABC, abstractmethod
-from pathlib import Path
-from typing import ClassVar
-
-from aiofiles import open as aio_open
-from aiohttp import ClientSession
-from typing_extensions import override
-
-
-class BaseFile(ABC):
-    def __init__(
-        self, raw: bytes | None = None, *, url: str | None = None, path: str | None = None
-    ) -> None:
-        self.raw = raw
-        self.url = url
-        self.path = path
-
-        if self.url is None and self.path is None:
-            raise ValueError("Either url or path must be provided.")
-
-        if self.url and self.path:
-            raise ValueError("Only one of url or path must be provided.")
-
-    @abstractmethod
-    async def read(self) -> bytes:
-        if self.raw is not None:
-            return self.raw
-
-        if self.url:
-            async with (
-                ClientSession() as session,
-                session.get(self.url) as response,
-            ):
-                response.raise_for_status()
-                return await response.read()
-        elif self.path:
-            async with aio_open(self.path, "rb") as f:
-                return await f.read()
-        else:
-            raise ValueError("Either url or path must be provided.")
-
-
-class Photo(BaseFile):
-    ALLOWED_EXTENSIONS: ClassVar[set[str]] = {
-        ".jpg",
-        ".jpeg",
-        ".png",
-        ".gif",
-        ".webp",
-        ".bmp",
-    }  # FIXME: костыль ✅
-
-    def __init__(
-        self,
-        raw: bytes | None = None,
-        *,
-        url: str | None = None,
-        path: str | None = None,
-        name: str | None = None,
-    ) -> None:
-        if path:
-            self.file_name = Path(path).name
-        elif url:
-            self.file_name = Path(url).name
-        elif name:
-            self.file_name = name
-        else:
-            self.file_name = ""
-
-        super().__init__(raw=raw, url=url, path=path)
-
-    def validate_photo(self) -> tuple[str, str] | None:
-        if self.path:
-            extension = Path(self.path).suffix.lower()
-            if extension not in self.ALLOWED_EXTENSIONS:
-                raise ValueError(
-                    f"Invalid photo extension: {extension}. Allowed: {self.ALLOWED_EXTENSIONS}"
-                )
-
-            return (extension[1:], ("image/" + extension[1:]).lower())
-        elif self.url:
-            extension = Path(self.url).suffix.lower()
-            if extension not in self.ALLOWED_EXTENSIONS:
-                raise ValueError(
-                    f"Invalid photo extension in URL: {extension}. Allowed: {self.ALLOWED_EXTENSIONS}"
-                )
-
-            mime_type = mimetypes.guess_type(self.url)[0]
-
-            if not mime_type or not mime_type.startswith("image/"):
-                raise ValueError(f"URL does not appear to be an image: {self.url}")
-
-            return (extension[1:], mime_type)
-        return None
-
-    @override
-    async def read(self) -> bytes:
-        return await super().read()
-
-
-class Video(BaseFile):
-    def __init__(
-        self, raw: bytes | None = None, *, url: str | None = None, path: str | None = None
-    ) -> None:
-        self.file_name: str = ""
-        if path:
-            self.file_name = Path(path).name
-        elif url:
-            self.file_name = Path(url).name
-
-        if not self.file_name:
-            raise ValueError("Either url or path must be provided.")
-        super().__init__(raw=raw, url=url, path=path)
-
-    @override
-    async def read(self) -> bytes:
-        return await super().read()
-
-
-class File(BaseFile):
-    def __init__(
-        self, raw: bytes | None = None, *, url: str | None = None, path: str | None = None
-    ) -> None:
-        self.file_name: str = ""
-        if path:
-            self.file_name = Path(path).name
-        elif url:
-            self.file_name = Path(url).name
-
-        if not self.file_name:
-            raise ValueError("Either url or path must be provided.")
-
-        super().__init__(raw=raw, url=url, path=path)
-
-    @override
-    async def read(self) -> bytes:
-        return await super().read()

pymax/filters.py

@@ -1,164 +0,0 @@
-from __future__ import annotations
-
-import re
-from abc import ABC, abstractmethod
-from typing import Generic, TypeVar
-
-from pymax.static.enum import AttachType, ChatType, MessageStatus
-from pymax.types import Message
-
-T_co = TypeVar("T_co")
-
-
-class BaseFilter(ABC, Generic[T_co]):
-    event_type: type[T_co]
-
-    @abstractmethod
-    def __call__(self, event: T_co) -> bool: ...
-
-    def __and__(self, other: BaseFilter[T_co]) -> BaseFilter[T_co]:
-        return AndFilter(self, other)
-
-    def __or__(self, other: BaseFilter[T_co]) -> BaseFilter[T_co]:
-        return OrFilter(self, other)
-
-    def __invert__(self) -> BaseFilter[T_co]:
-        return NotFilter(self)
-
-
-class AndFilter(BaseFilter[T_co]):
-    def __init__(self, *filters: BaseFilter[T_co]) -> None:
-        self.filters = filters
-        self.event_type = filters[0].event_type
-
-    def __call__(self, event: T_co) -> bool:
-        return all(f(event) for f in self.filters)
-
-
-class OrFilter(BaseFilter[T_co]):
-    def __init__(self, *filters: BaseFilter[T_co]) -> None:
-        self.filters = filters
-        self.event_type = filters[0].event_type
-
-    def __call__(self, event: T_co) -> bool:
-        return any(f(event) for f in self.filters)
-
-
-class NotFilter(BaseFilter[T_co]):
-    def __init__(self, base_filter: BaseFilter[T_co]) -> None:
-        self.base_filter = base_filter
-        self.event_type = base_filter.event_type
-
-    def __call__(self, event: T_co) -> bool:
-        return not self.base_filter(event)
-
-
-class ChatFilter(BaseFilter[Message]):
-    event_type = Message
-
-    def __init__(self, chat_id: int) -> None:
-        self.chat_id = chat_id
-
-    def __call__(self, message: Message) -> bool:
-        return message.chat_id == self.chat_id
-
-
-class TextFilter(BaseFilter[Message]):
-    event_type = Message
-
-    def __init__(self, text: str) -> None:
-        self.text = text
-
-    def __call__(self, message: Message) -> bool:
-        return self.text in message.text
-
-
-class SenderFilter(BaseFilter[Message]):
-    event_type = Message
-
-    def __init__(self, user_id: int) -> None:
-        self.user_id = user_id
-
-    def __call__(self, message: Message) -> bool:
-        return message.sender == self.user_id
-
-
-class StatusFilter(BaseFilter[Message]):
-    event_type = Message
-
-    def __init__(self, status: MessageStatus) -> None:
-        self.status = status
-
-    def __call__(self, message: Message) -> bool:
-        return message.status == self.status
-
-
-class TextContainsFilter(BaseFilter[Message]):
-    event_type = Message
-
-    def __init__(self, substring: str) -> None:
-        self.substring = substring
-
-    def __call__(self, message: Message) -> bool:
-        return self.substring in message.text
-
-
-class RegexTextFilter(BaseFilter[Message]):
-    event_type = Message
-
-    def __init__(self, pattern: str) -> None:
-        self.pattern = pattern
-        self.regex = re.compile(pattern)
-
-    def __call__(self, message: Message) -> bool:
-        return bool(self.regex.search(message.text))
-
-
-class MediaFilter(BaseFilter[Message]):
-    event_type = Message
-
-    def __call__(self, message: Message) -> bool:
-        return message.attaches is not None and len(message.attaches) > 0
-
-
-class FileFilter(BaseFilter[Message]):
-    event_type = Message
-
-    def __call__(self, message: Message) -> bool:
-        if message.attaches is None:
-            return False
-        return any(attach.type == AttachType.FILE for attach in message.attaches)
-
-
-class Filters:
-    @staticmethod
-    def chat(chat_id: int) -> BaseFilter[Message]:
-        return ChatFilter(chat_id)
-
-    @staticmethod
-    def text(text: str) -> BaseFilter[Message]:
-        return TextFilter(text)
-
-    @staticmethod
-    def sender(user_id: int) -> BaseFilter[Message]:
-        return SenderFilter(user_id)
-
-    @staticmethod
-    def status(status: MessageStatus) -> BaseFilter[Message]:
-        return StatusFilter(status)
-
-    @staticmethod
-    def text_contains(substring: str) -> BaseFilter[Message]:
-        return TextContainsFilter(substring)
-
-    @staticmethod
-    def text_matches(pattern: str) -> BaseFilter[Message]:
-        return RegexTextFilter(pattern)
-
-    @staticmethod
-    def has_media() -> BaseFilter[Message]:
-        return MediaFilter()
-
-    @staticmethod
-    def has_file() -> BaseFilter[Message]:
-        return FileFilter()

pymax/formatter.py

@@ -1,31 +0,0 @@
-import logging
-from typing import ClassVar
-
-
-class ColoredFormatter(logging.Formatter):
-    COLORS: ClassVar = {
-        "DEBUG": "\033[37m",
-        "INFO": "\033[36m",
-        "WARNING": "\033[33m",
-        "ERROR": "\033[31m",
-        "CRITICAL": "\033[41m",
-    }
-
-    RESET = "\033[0m"
-    DIM = "\033[2m"
-    BOLD = "\033[1m"
-
-    def format(self, record: logging.LogRecord) -> str:
-        level_color = self.COLORS.get(record.levelname, self.RESET)
-        time_color = self.DIM
-        name_color = "\033[35m"
-        message_color = self.RESET
-
-        log = (
-            f"{time_color}{self.formatTime(record, '%H:%M:%S')}{self.RESET} "
-            f"[{level_color}{record.levelname}{self.RESET}] "
-            f"{name_color}{record.name}{self.RESET}: "
-            f"{message_color}{record.getMessage()}{self.RESET}"
-        )
-
-        return log

pymax/formatting.py

@@ -1,74 +0,0 @@
-import re
-
-from pymax.static.enum import FormattingType
-from pymax.types import Element
-
-
-class Formatting:
-    MARKUP_BLOCK_PATTERN = re.compile(
-        (
-            r"\*\*(?P<strong>.+?)\*\*|"
-            r"\*(?P<italic>.+?)\*|"
-            r"__(?P<underline>.+?)__|"
-            r"~~(?P<strike>.+?)~~"
-        ),
-        re.DOTALL,
-    )
-
-    @staticmethod
-    def get_elements_from_markdown(text: str) -> tuple[list[Element], str]:
-        text = text.strip("\n")
-        elements: list[Element] = []
-        clean_parts: list[str] = []
-        current_pos = 0
-
-        last_end = 0
-        for match in Formatting.MARKUP_BLOCK_PATTERN.finditer(text):
-            between = text[last_end : match.start()]
-            if between:
-                clean_parts.append(between)
-                current_pos += len(between)
-
-            inner_text = None
-            fmt_type = None
-            if match.group("strong") is not None:
-                inner_text = match.group("strong")
-                fmt_type = FormattingType.STRONG
-            elif match.group("italic") is not None:
-                inner_text = match.group("italic")
-                fmt_type = FormattingType.EMPHASIZED
-            elif match.group("underline") is not None:
-                inner_text = match.group("underline")
-                fmt_type = FormattingType.UNDERLINE
-            elif match.group("strike") is not None:
-                inner_text = match.group("strike")
-                fmt_type = FormattingType.STRIKETHROUGH
-
-            if inner_text is not None and fmt_type is not None:
-                next_pos = match.end()
-                has_newline = (next_pos < len(text) and text[next_pos] == "\n") or (
-                    next_pos == len(text)
-                )
-
-                length = len(inner_text) + (1 if has_newline else 0)
-                elements.append(Element(type=fmt_type, from_=current_pos, length=length))
-
-                clean_parts.append(inner_text)
-                if has_newline:
-                    clean_parts.append("\n")
-
-                current_pos += length
-
-                if next_pos < len(text) and text[next_pos] == "\n":
-                    last_end = match.end() + 1
-                else:
-                    last_end = match.end()
-            else:
-                last_end = match.end()
-
-        tail = text[last_end:]
-        if tail:
-            clean_parts.append(tail)
-
-        clean_text = "".join(clean_parts)
-        return elements, clean_text