vasyan-core 0.1.0__tar.gz

vasyan_core-0.1.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.3
+Name: vasyan-core
+Version: 0.1.0
+Summary: TODO
+Author: Roman Karzhavin
+Author-email: Roman Karzhavin <karzhavin.rd@ya.ru>
+Requires-Dist: fire>=0.7.1
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: nats-py>=2.14.0
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: pyyaml>=6.0.3
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+

vasyan_core-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "vasyan_core"
+version = "0.1.0"
+description = "TODO"
+readme = "README.md"
+authors = [
+    { name = "Roman Karzhavin", email = "karzhavin.rd@ya.ru" }
+]
+requires-python = ">=3.13"
+dependencies = [
+    "fire>=0.7.1",
+    "loguru>=0.7.3",
+    "nats-py>=2.14.0",
+    "pydantic>=2.12.5",
+    "pyyaml>=6.0.3",
+]
+
+[build-system]
+requires = ["uv_build>=0.8.22,<0.9.0"]
+build-backend = "uv_build"

vasyan_core-0.1.0/src/vasyan_core/__init__.py

@@ -0,0 +1,18 @@
+__all__ = [
+    'logger',
+    'configure_logger',
+    'brokers',
+    'protocols',
+    'utils',
+    'Cli',
+    'Config',
+    'ProtoService',
+    'SystemdWrapper',
+]
+
+from . import brokers, protocols, utils
+from .cli import Cli
+from .config import Config
+from .logger import configure_logger, logger
+from .service import ProtoService
+from .systemd import SystemdWrapper

vasyan_core-0.1.0/src/vasyan_core/brokers/__init__.py

@@ -0,0 +1,11 @@
+from ..protocols import Broker
+
+
+__all__ = [
+    'broker_nats',
+]
+
+
+def broker_nats() -> Broker:
+    from ._nats import BrokerNats
+    return BrokerNats()

vasyan_core-0.1.0/src/vasyan_core/brokers/_nats.py

@@ -0,0 +1,39 @@
+import nats
+from nats.aio.client import Client
+from nats.aio.subscription import Subscription
+
+from ..protocols import SubscribeCallback
+
+
+class BrokerNats:
+    def __init__(self) -> None:
+        self._connection: Client | None = None
+        self._subscribes: list[Subscription] = []
+
+    @property
+    def connection(self) -> Client:
+        if self._connection is None:
+            raise Exception('TODO')
+        return self._connection
+
+    async def connect(self) -> None:
+        self._connection = await nats.connect()
+
+    async def disconnect(self) -> None:
+        for sub in self._subscribes:
+            await sub.unsubscribe()
+        await self.connection.drain()
+        self._connection = None
+
+    async def send(self, subject: str, payload: bytes) -> None:
+        await self.connection.publish(
+            subject=subject,
+            payload=payload
+        )
+
+    async def subscribe(self, subject: str, callback: SubscribeCallback) -> None:
+        subscribe = await self.connection.subscribe(
+            subject=subject,
+            cb=callback
+        )
+        self._subscribes.append(subscribe)

vasyan_core-0.1.0/src/vasyan_core/cli.py

@@ -0,0 +1,14 @@
+import asyncio
+import pathlib
+
+from .service import ProtoService
+
+
+class Cli:
+    def __init__(self, service: type[ProtoService]) -> None:
+        self._service_class = service
+
+    def run(self, *, config: str, name: str | None = None) -> None:
+        config_path = pathlib.Path(config)
+        service = self._service_class(config_path, name)
+        asyncio.run(service.run())

vasyan_core-0.1.0/src/vasyan_core/config.py

@@ -0,0 +1,30 @@
+import pathlib
+import typing
+
+import pydantic
+import yaml
+
+LoggerLevel = typing.Annotated[
+    typing.Literal['TRACE', 'DEBUG', 'INFO', 'SUCCESS', 'WARNING', 'ERROR', 'CRITICAL'],
+    pydantic.BeforeValidator(lambda x: x.upper())
+]
+GenericConfig = typing.TypeVar('GenericConfig', bound='Config')
+
+
+class LoggerConfig(pydantic.BaseModel):
+    level: LoggerLevel = 'INFO'
+
+
+class Config(pydantic.BaseModel):
+    logger: LoggerConfig = pydantic.Field(default_factory=LoggerConfig)
+
+    @classmethod
+    def _read_config_file(cls, config_path: pathlib.Path, service_name: str) -> dict:
+        with open(config_path, 'r') as f:
+            data = yaml.safe_load(f)
+            return data.get(service_name, {})
+
+    @classmethod
+    def load(cls, config_path: pathlib.Path, service_name: str) -> typing.Self:
+        raw_data = cls._read_config_file(config_path, service_name)
+        return cls.model_validate(raw_data)

vasyan_core-0.1.0/src/vasyan_core/logger.py

@@ -0,0 +1,17 @@
+import sys
+
+from loguru import logger
+
+from .config import LoggerConfig
+
+logger.remove()
+
+
+def configure_logger(config: LoggerConfig | None = None) -> None:
+    logger_level = config.level if config else 'DEBUG'
+    logger.add(
+        sys.stdout,
+        colorize=True,
+        format='<level>{message}</level>',
+        level=logger_level
+    )

vasyan_core-0.1.0/src/vasyan_core/protocols.py

@@ -0,0 +1,19 @@
+import typing
+
+
+class BrokerMessage(typing.Protocol):
+    subject: str
+    data: bytes
+
+
+SubscribeCallback = typing.Callable[[BrokerMessage], typing.Awaitable[None]]
+
+
+class Broker(typing.Protocol):
+    async def connect(self) -> None: ...
+
+    async def disconnect(self) -> None: ...
+
+    async def send(self, subject: str, payload: bytes) -> None: ...
+
+    async def subscribe(self, subject: str, callback: SubscribeCallback) -> None: ...

vasyan_core-0.1.0/src/vasyan_core/service.py

@@ -0,0 +1,47 @@
+import abc
+import asyncio
+import pathlib
+import signal
+import typing
+
+from .config import GenericConfig
+from .logger import configure_logger
+
+
+class ProtoService(abc.ABC, typing.Generic[GenericConfig]):
+    __service_name__: str
+    __class_config__: type[GenericConfig]
+
+    def __init__(self, config_path: pathlib.Path, service_name: str | None = None) -> None:
+        self._service_name = service_name or self.__service_name__
+        self._config = self.__class_config__.load(config_path, self._service_name)
+        configure_logger(self._config.logger)
+        self.__post_init__()
+
+    def __post_init__(self) -> None:
+        return
+
+    @abc.abstractmethod
+    async def _run_service(self) -> None:
+        ...
+
+    @abc.abstractmethod
+    def _stop_service(self) -> None:
+        ...
+
+    def _bind_stop_signals(self) -> None:
+        loop = asyncio.get_event_loop()
+        loop.add_signal_handler(signal.SIGINT, self._stop_service)
+        loop.add_signal_handler(signal.SIGTERM, self._stop_service)
+
+    async def _prepare_service(self) -> None:
+        return
+
+    async def _cleanup_service(self) -> None:
+        return
+
+    async def run(self) -> None:
+        self._bind_stop_signals()
+        await self._prepare_service()
+        await self._run_service()
+        await self._cleanup_service()

vasyan_core-0.1.0/src/vasyan_core/systemd.py

@@ -0,0 +1,59 @@
+import os
+import pathlib
+
+from .utils import CommandResult, run_command
+
+
+class SystemdWrapperError(Exception):
+    pass
+
+
+class SystemdWrapper:
+    def __init__(self, user: bool = True) -> None:
+        self._user = user
+
+    def run_command(self, command: str) -> CommandResult:
+        systemctl = 'systemctl --user' if self._user else 'systemctl'
+        return run_command(f'{systemctl} {command}')
+
+    def _get_units_folder_path(self) -> pathlib.Path:
+        if not self._user:
+            raise SystemdWrapperError('Global systemd units not support')
+
+        home_path = pathlib.Path(os.environ['HOME'])
+        return home_path / '.config/systemd/user'
+
+    def check_exists(self, unit_name: str) -> bool:
+        result = self.run_command(f'systemctl --user cat {unit_name} > /dev/null 2>&1')
+        return bool(result)
+
+    def daemon_reload(self) -> None:
+        if self.run_command('daemon-reload'):
+            return
+        raise SystemdWrapperError('Unable to reload systemd daemons')
+
+    def start(self, unit_name: str) -> None:
+        if self.run_command(f'start {unit_name}'):
+            return
+        raise SystemdWrapperError(f'Unable to start {unit_name} systemd unit')
+
+    def stop(self, unit_name: str, missing_ok: bool = False) -> None:
+        exists = self.check_exists(unit_name)
+        if not exists and missing_ok:
+            return
+
+        if self.run_command(f'stop {unit_name}'):
+            return
+        raise SystemdWrapperError(f'Unable to stop {unit_name} systemd unit')
+
+    def enable(self, unit_name: str) -> None:
+        if self.run_command(f'enable {unit_name}'):
+            return
+        raise SystemdWrapperError(f'Unable to enable {unit_name} systemd unit')
+
+    def create(self, unit_name: str, unit_data: str) -> None:
+        units_folder_path = self._get_units_folder_path()
+        units_folder_path.mkdir(parents=True, exist_ok=True)
+
+        unit_path = units_folder_path.joinpath(unit_name)
+        unit_path.write_text(unit_data)

vasyan_core-0.1.0/src/vasyan_core/utils.py

@@ -0,0 +1,88 @@
+import asyncio
+import dataclasses
+import functools
+import re
+import subprocess
+import sys
+import time
+import typing
+
+from loguru import logger
+
+T = typing.TypeVar('T')
+
+
+def asynchronous[T, **P](func: typing.Callable[P, T]) -> typing.Callable[P, typing.Awaitable[T]]:
+    @functools.wraps(func)
+    async def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+        return await asyncio.to_thread(func, *args, **kwargs)
+    return wrapper
+
+
+@dataclasses.dataclass(frozen=True)
+class CommandResult:
+    stdout: str = ''
+    stderr: str = ''
+    return_code: int | None = None
+
+    def __bool__(self) -> bool:
+        return self.return_code == 0
+
+
+def run_command(command: str, wait: bool = True) -> CommandResult:
+    proc = subprocess.Popen(
+        [command],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        shell=True,
+    )
+    if not wait:
+        return CommandResult()
+
+    stdout, stderr = proc.communicate()
+    return CommandResult(
+        stdout=stdout.decode().strip(),
+        stderr=stderr.decode().strip(),
+        return_code=proc.returncode
+    )
+
+
+async def balanced_loop(
+    stop_event: asyncio.Event,
+    interval: float,
+    tick: float = 1.0
+) -> typing.AsyncGenerator[float, None]:
+    interval = max(interval, 0)
+    start_time = last_yield = time.time()
+    yield last_yield
+
+    while not stop_event.is_set():
+        try:
+            time_to_yield = interval - (time.time() - start_time) % interval
+        except ZeroDivisionError:
+            time_to_yield = 0
+
+        if time_to_yield > tick:
+            await asyncio.sleep(tick)
+            continue
+
+        await asyncio.sleep(time_to_yield)
+        last_yield = time.time()
+        yield last_yield
+
+
+def extract_by_regex(lines: typing.Iterable[str],
+                     regex: re.Pattern,
+                     *,
+                     group: int = 0
+                     ) -> typing.Generator[str, None, None]:
+    for line in lines:
+        if (regex_match := regex.search(line)) is None:
+            continue
+        yield regex_match.group(group)
+
+
+def terminate(message: str, exit_code: int = 1) -> typing.NoReturn:
+    log_func = logger.info if exit_code == 0 else logger.error
+    log_func(message)
+    sys.exit(exit_code)