aiober 0.0.1__tar.gz

aiober-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Quaron Software
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aiober-0.0.1/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: aiober
+Version: 0.0.1
+Summary: The AioBer library AsyncIO viBER (Aiober) is a python library for creating Viber bots easily, professionally and in a structured way!
+Author: Gucul
+License: MIT
+Project-URL: Homepage, https://github.com/QuaronSoftware/aiober
+Project-URL: Issues, https://github.com/QuaronSoftware/aiober/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: redis==7.1.1
+Requires-Dist: pydantic==2.12.5
+Requires-Dist: aiohttp==3.13.3
+Requires-Dist: certifi==2026.1.4
+Dynamic: license-file
+
+# Аiober
+
+**A**sync**IO**
+      vi**BER** – Python library for easy creation of Viber bots
+*Currently, Viber bots can only be works using webhooks.*
+
+
+### Introduction
+...
+
+## Let's get started !
+
+### Installing
+Creating a viber bot is easy !
+1. Install the library with `pip install git+https://github.com/QuaronSoftware/aiober.git` or using git
+2. From aiober import Bot and Dispatcher to your projects
+3. Build a simple script like in **Example**
+4. Make viber bot [here](https://partners.viber.com/account/create-bot-account)
+5. Using ngrok make your address global (for webhooks)
+6. Run your script
+7. Open Postman and make post request to https://chatapi.viber.com/pa/set_webhook with data `{"url":"https://your-domain/update, "auth_token": "auth-token"}` for set webhook to viber bot
+**Good, webhook is registred !**
+
+## Example
+
+### Simple echo bot
+```python
+import asyncio
+
+from aiober import Bot, Dispatcher
+from aiober.types import Message
+
+bot = Bot('auth-token')
+dp = Dispatcher(bot=bot)
+
+# router
+@dp.messages()
+async def echo(message: Message):
+    await message.copy_to(message.sender.id)
+
+
+async def main():
+
+    # start webhook
+    await dp.start_webhook(
+        host='127.0.0.1',
+        port=8000,
+        path='/update'
+    )
+
+asyncio.run(main())
+```

aiober-0.0.1/README.md

@@ -0,0 +1,52 @@
+# Аiober
+
+**A**sync**IO**
+      vi**BER** – Python library for easy creation of Viber bots
+*Currently, Viber bots can only be works using webhooks.*
+
+
+### Introduction
+...
+
+## Let's get started !
+
+### Installing
+Creating a viber bot is easy !
+1. Install the library with `pip install git+https://github.com/QuaronSoftware/aiober.git` or using git
+2. From aiober import Bot and Dispatcher to your projects
+3. Build a simple script like in **Example**
+4. Make viber bot [here](https://partners.viber.com/account/create-bot-account)
+5. Using ngrok make your address global (for webhooks)
+6. Run your script
+7. Open Postman and make post request to https://chatapi.viber.com/pa/set_webhook with data `{"url":"https://your-domain/update, "auth_token": "auth-token"}` for set webhook to viber bot
+**Good, webhook is registred !**
+
+## Example
+
+### Simple echo bot
+```python
+import asyncio
+
+from aiober import Bot, Dispatcher
+from aiober.types import Message
+
+bot = Bot('auth-token')
+dp = Dispatcher(bot=bot)
+
+# router
+@dp.messages()
+async def echo(message: Message):
+    await message.copy_to(message.sender.id)
+
+
+async def main():
+
+    # start webhook
+    await dp.start_webhook(
+        host='127.0.0.1',
+        port=8000,
+        path='/update'
+    )
+
+asyncio.run(main())
+```

aiober-0.0.1/aiober/__init__.py

@@ -0,0 +1,6 @@
+from .router import (
+    Router,
+    Dispatcher
+)
+
+from aiober.client import Bot

aiober-0.0.1/aiober/client/__init__.py

@@ -0,0 +1,5 @@
+from .bot import Bot
+
+from .session.base import BaseSession
+from .session.request import AiohttpSession
+from .session.viber import ViberAPIServer

aiober-0.0.1/aiober/client/bot.py

@@ -0,0 +1,42 @@
+
+from .session.base import BaseSession
+from aiober.types import Keyboard, RichMediaKeyboard
+from aiober.methods.base import ViberMethod
+from aiober.client.session.request import AiohttpSession
+
+
+class Bot:
+    def __init__(
+            self,
+            token: str,
+            session: BaseSession = None
+    ):
+        self._token = token
+        self.session = session if isinstance(session, BaseSession) else AiohttpSession()
+    
+    @property
+    def token(self):
+        return self._token
+
+    async def __call__(self, method: ViberMethod, request_runtime: int = None):
+        return await self.session(self, method, timeout=request_runtime)
+    
+    def send_message(self, chat_id: str, text: str, keyboard: Keyboard = None):
+        from aiober.methods import SendMessage
+
+        return SendMessage(
+            chat_id,
+            type='text',
+            text=text,
+            keyboard=keyboard
+        ).as_(self)
+    
+    def send_rich_media(self, chat_id: str, rich_media: RichMediaKeyboard):
+        from aiober.methods import SendMessage
+
+        return SendMessage(
+            chat_id,
+            type='rich_media',
+            text=None,
+            rich_media=rich_media
+        ).as_(self)

aiober-0.0.1/aiober/client/context_controller.py

@@ -0,0 +1,21 @@
+from typing import Any, Optional, TYPE_CHECKING
+
+from pydantic import BaseModel, PrivateAttr
+from typing_extensions import Self
+
+if TYPE_CHECKING:
+    from aiober.client.bot import Bot
+
+
+class BotContextController(BaseModel):
+    _bot: Optional["Bot"] = PrivateAttr()
+
+
+    def as_(self, bot: Optional["Bot"]) -> Self:
+        self._bot = bot
+        return self
+
+    @property
+    def bot(self) -> Optional['Bot']:
+
+        return self._bot

aiober-0.0.1/aiober/client/session/base.py

@@ -0,0 +1,34 @@
+import json
+from pydantic import parse_obj_as
+from abc import ABC, abstractmethod
+from typing import Any
+
+from aiober.methods.base import Response
+from .viber import ViberAPIServer, PRODUCTION
+
+DEFAULT_TIMEOUT: float = 60.0
+
+
+class BaseSession(ABC):
+
+    def __init__(self):
+        self.api: ViberAPIServer = PRODUCTION
+        self.timeout = DEFAULT_TIMEOUT
+    
+    @abstractmethod
+    async def make_request(self, bot, timeout: int = None):
+        
+        pass
+
+    def check_response(self, bot, status_code: int, content: str) -> Response:
+        try:
+            json_data = json.loads(content)
+        except Exception as E:
+            raise UnicodeDecodeError("failed to decode object")
+
+        response = parse_obj_as(Response, json_data)
+
+        if 200 <= status_code <= 220 and response.status==0:
+            return response
+        
+        raise RuntimeError(f'status code {status_code}; response: {response.dict()}')

aiober-0.0.1/aiober/client/session/request.py

@@ -0,0 +1,68 @@
+import logging
+import ssl
+import certifi
+import json
+
+from aiohttp import ClientSession, TCPConnector, FormData
+from typing import TypeVar
+
+from aiober.methods.base import ViberMethod
+
+from .base import BaseSession
+
+T = TypeVar('T')
+
+
+class AiohttpSession(BaseSession):
+    def __init__(self):
+        self._session: ClientSession = None
+        super().__init__()
+    
+    async def create_session(self, token: str) -> ClientSession:
+        if self._session is None:
+            self._session = ClientSession(
+                connector=TCPConnector(ssl=ssl.create_default_context(cafile=certifi.where())),
+                headers={
+                    "X-Viber-Auth-Token": token
+                }
+            )
+        
+        return self._session
+
+    def build_form_data(self, data: dict) -> dict:
+        result = {
+            'min_api_version': 2
+        }
+
+        for key, value in data.items():
+            if value:
+                result[key] = value
+
+        return result
+
+    async def make_request(self, bot, method: ViberMethod, timeout: int = None):
+        session = await self.create_session(bot.token)
+
+        url = self.api.get_api_url(method.__api_method__)
+        form_data = self.build_form_data(method.dict(exclude_none=True))
+        logging.debug(form_data)
+
+        try:
+            async with session.post(
+                url, data=json.dumps(form_data), timeout=self.timeout if timeout is None else timeout
+            ) as resp:
+                raw_result = await resp.text()
+                logging.debug(raw_result)
+        except RuntimeError:
+            raise RuntimeError()
+        except Exception as E:
+            raise E
+
+        response = self.check_response(bot, resp.status, raw_result)
+
+        return response.status
+
+    async def __call__(self, bot, method: ViberMethod[T], timeout: int = None):
+
+        await self.make_request(bot, method, timeout)
+

aiober-0.0.1/aiober/client/session/viber.py

@@ -0,0 +1,12 @@
+
+class ViberAPIServer:
+    def __init__(self, *, base: str):
+        self.base = base
+
+    def get_api_url(self, method: str):
+        return self.base.format(method=method)
+
+
+PRODUCTION = ViberAPIServer(
+    base='https://chatapi.viber.com/pa/{method}'
+)

aiober-0.0.1/aiober/filters/__init__.py

@@ -0,0 +1,3 @@
+from .base import BaseFilter
+from .text import TextFilter, StartsWithFilter
+from .state import StateFilter

aiober-0.0.1/aiober/filters/base.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+
+
+class BaseFilter(ABC):
+    
+    def __init__(self):
+        ...
+    
+    @abstractmethod
+    async def __call__(self, *args, **kwargs):
+        pass
+    
+    

aiober-0.0.1/aiober/filters/state.py

@@ -0,0 +1,30 @@
+from typing import Any, cast
+from inspect import isclass
+from collections.abc import Sequence
+from aiober.fsm.state import State, StatesGroup
+from aiober.fsm.context import FSMcontext, StateType
+
+from .base import BaseFilter
+
+
+class StateFilter(BaseFilter):
+    def __init__(self, *state: StateType):
+        if not state:
+            msg = "At list one state is required"
+            raise ValueError(msg)
+
+        self.states = state
+    
+    async def __call__(self, event: Any, state: FSMcontext) -> bool | dict[str, Any]:
+        raw_state = await state.get_state()
+        allowed_states = cast(Sequence[StateType], self.states)
+        for state in allowed_states:
+            if isinstance(state, str) or state is None:
+                if state in {'*', raw_state}:
+                    return True
+            elif isinstance(state, (State, StatesGroup)):
+                if state(event, raw_state):
+                    return True
+            elif isclass(state) and issubclass(state, StatesGroup) and state()(event=event, raw_state=raw_state):
+                return True
+        return False

aiober-0.0.1/aiober/filters/text.py

@@ -0,0 +1,22 @@
+from aiober.types import Message
+
+from .base import BaseFilter
+
+class TextFilter(BaseFilter):
+    def __init__(self, text: str = None):
+        self.text = text
+    
+    async def __call__(self, message: Message):
+        return message.text == self.text
+
+class StartsWithFilter(BaseFilter):
+    def __init__(self, text: str = None):
+        self.text = text
+    
+    async def __call__(self, message: Message):
+        if message.text and message.text.startswith(self.text):
+            lens = len(self.text)
+            return {
+                'text_ends': message.text[lens::]
+            }
+        return False

aiober-0.0.1/aiober/fsm/context.py

@@ -0,0 +1,27 @@
+from typing import Any
+from .storage.base import BaseStorage, StorageKey, StateType
+
+class FSMcontext:
+    
+    def __init__(self, key: StorageKey, storage: BaseStorage):
+        self._storage_key = key
+        self._storage = storage
+    
+    async def get_state(self) -> str:
+        return await self._storage.get_state(self._storage_key)
+
+    async def set_state(self, state: StateType) -> None:
+        return await self._storage.set_state(self._storage_key, state=state)
+    
+    async def get_data(self) -> dict[str, Any]:
+        return await self._storage.get_data(self._storage_key)
+    
+    async def set_data(self, data: dict[str, Any] = {}, **kwargs):
+        return await self._storage.set_data(self._storage_key, data | kwargs)
+
+    async def update_data(self, data: dict[str, Any] = {}, **kwargs):
+        return await self._storage.update_data(self._storage_key, data | kwargs)
+    
+    async def clear(self):
+        await self.set_state(None)
+        await self.set_data({})

aiober-0.0.1/aiober/fsm/state.py

@@ -0,0 +1,162 @@
+import inspect
+from collections.abc import Iterator
+from typing import Any, no_type_check
+
+from aiober.types import ViberObject
+
+
+class State:
+
+    def __init__(self, state: str | None = None, group_name: str | None = None):
+        self._state = state
+        self._group_name = group_name
+        self._group: type["StatesGroup"] | None = None
+    
+    @property
+    def group(self) -> type["StatesGroup"]:
+        if self._group is None:
+            msg = "This state is not in any group"
+            raise RuntimeError(msg)
+        return self._group
+    
+    @property
+    def state(self) -> str | None:
+        if self._state is None or self._state == '*':
+            return self._state
+        
+        if self._group_name is None and self._group:
+            group = self._group.__full_group_name__
+        elif self._group_name:
+            group = self._group
+        else:
+            group = "@"
+        
+        return f"{group}:{self._state}"
+    
+    def set_parent(self, group: type["StatesGroup"]) -> None:
+        if not issubclass(group, StatesGroup):
+            msg = "Group must be subclass of StatesGroup"
+            raise ValueError(msg)
+        self._group = group
+    
+    def __set_name__(self, owner: type["StatesGroup"], name: str) -> None:
+        if self._state is None:
+            self._state = name
+        self.set_parent(owner)
+
+    
+    def __str__(self):
+        return f"<State '{self.state or ''}'>"
+
+    __repr__ = __str__
+
+    def __call__(self, event: ViberObject, raw_state: str | None = None):
+        if self.state=='*':
+            return True
+        return raw_state == self.state
+   
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, self.__class__):
+            return self.state == other.state
+        if isinstance(other, str):
+            return self.state == other
+        return NotImplemented
+    
+    def __hash__(self) -> int:
+        return hash(self.state)
+
+
+
+class StatesGroupMeta(type):
+    __parent__: type["StatesGroup"] | None
+    __childs__: tuple[type["StatesGroup"]]
+    __states__: tuple[State, ...]
+    __state_names__: tuple[str, ...]
+    __all_childs__: tuple[type["StatesGroup"], ...]
+    __all_states__: tuple[State, ...]
+    __all_states_names__: tuple[str, ...]
+
+    @no_type_check
+    def __new__(mcs, name, bases, namespace, **kwargs):
+        cls = super().__new__(mcs, name, bases, namespace)
+        
+        states = []
+        childs = []
+
+        for arg in namespace.values():
+            if isinstance(arg, State):
+                states.append(arg)
+            if inspect.isclass(arg) and issubclass(arg, StatesGroup):
+                child = cls._preprare_child(arg)
+                childs.append(child)
+        
+        cls.__parent__ = None
+        cls.__childs__ = tuple(childs)
+        cls.__states__ = tuple(states)
+        cls.__state_names__ = tuple(state.state for state in states)
+
+        cls.__all_childs__ = cls._get_all_childs()
+        cls.__all_states__ = cls._get_all_states()
+
+        cls.__all_states_names__ = cls._get_all_states_names()
+
+        return cls
+    
+    @property
+    def __full_group_name__(cls) -> str:
+        if cls.__parent__:
+            return f"{cls.__parent__.__full_group_name__}.{cls.__name__}"
+        return cls.__name__
+
+    def _preprare_child(cls, child: type["StatesGroup"]) -> type["StatesGroup"]:
+        child.__parent__ = cls
+        child.__all_states_names__ = child._all_states_names()
+        return child
+    
+    def _get_all_childs(cls) -> tuple[type["StatesGroup"], ...]:
+        result = cls.__childs__
+        for child in cls.__childs__:
+            result += child.__childs__
+        return result
+    
+    def _get_all_states(cls) -> tuple[State, ...]:
+        states = cls.__states__
+        for group in cls.__childs__:
+            states += group.__all_states__
+        return states
+    
+    def _get_all_states_names(cls) -> tuple[str, ...]:
+        return tuple(state.state for state in cls.__all_states__ if state.state)
+    
+    def __contains__(cls, item: Any) -> bool:
+        if isinstance(item, str):
+            return item in cls.__all_states_names__
+        if isinstance(item, State):
+            return item in cls.__all_states__
+        if isinstance(item, StatesGroupMeta):
+            return item in cls.__all_childs__
+        return False
+
+    def __str__(self) -> str:
+        return f"<StatesGroup '{self.__full_group_name__}'>"
+    
+    def __iter__(self) -> Iterator[State]:
+        return iter(self.__all_states__)
+
+
+class StatesGroup(metaclass=StatesGroupMeta):
+    @classmethod
+    def get_root(cls):
+        if cls.__parent__ is None:
+            return cls
+        return cls.__parent__.get_root()
+    
+    def __call__(self, event: ViberObject, state_raw: str | None = None) -> bool:
+        return state_raw in type(self).__all_states_names__
+    
+    def __str__(self) -> str:
+        return f"<StatesGroup '{type(self).__full_group_name__}'>"
+
+
+default_state = State(None)
+any_state = State(state='*')

aiober-0.0.1/aiober/fsm/storage/__init__.py

@@ -0,0 +1,3 @@
+from .base import BaseStorage, StorageKey
+from .memory import MemoryStorage
+from .redis import RedisStorage

aiober-0.0.1/aiober/fsm/storage/base.py

@@ -0,0 +1,73 @@
+
+from typing import Any, Literal
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+from aiober.fsm.state import State
+
+StateType = str | State | None
+StorageKeyBuildType = Literal['state', 'data']
+
+
+@dataclass(frozen=True)
+class StorageKey:
+    user_id: str
+    chat_id: str
+
+    def build(self, type: StorageKeyBuildType):
+        return f"{self.chat_id}:{self.user_id}:{type}"
+
+
+class BaseStorage(ABC):
+    
+
+    @abstractmethod
+    async def set_state(self, key: StorageKey, state: StateType) -> None:
+        """
+        Set state for key
+
+        :key: storage key
+        :state: new state
+        """
+        pass
+    
+    @abstractmethod
+    async def get_state(self, key: StorageKey) -> str:
+        """
+        Get state by storage key
+        """
+
+        pass
+
+    @abstractmethod
+    async def set_data(self, key: StorageKey, data: dict[str, Any]):
+        """
+        Set data to storage key
+        """
+
+        pass
+
+    @abstractmethod
+    async def get_data(self, key: StorageKey) -> dict[str, Any]:
+        """
+        Get data by key
+        """
+
+        pass
+
+    async def update_data(self, key: StorageKey, data: dict[str, Any]):
+        """
+        Update data by key
+        """
+
+        current_data = await self.get_data(key=key)
+        current_data.update(data)
+        await self.set_data(key=key, data=current_data)
+        return current_data.copy()
+
+    @abstractmethod
+    async def close(self) -> None:
+        """
+        Close storage
+        """
+        pass