voyolib 0.0.1__tar.gz

voyolib-0.0.1/.github/workflows/release.yml

@@ -0,0 +1,35 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+  workflow_dispatch:
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      contents: write
+      id-token: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+
+      - name: Install build dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish to PyPI
+        if: startsWith(github.ref, 'refs/tags/v')
+        uses: pypa/gh-action-pypi-publish@release/v1

voyolib-0.0.1/.gitignore

@@ -0,0 +1,39 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+venv/
+env/
+
+# Environment variables
+.env
+.env.*
+
+# Test / coverage
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+.tox/
+noxfile.py
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log

voyolib-0.0.1/.python-version

@@ -0,0 +1 @@
+3.13

voyolib-0.0.1/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: voyolib
+Version: 0.0.1
+Summary: Python library for Voyo
+Requires-Python: >=3.13

voyolib-0.0.1/main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from python-lib!")
+
+
+if __name__ == "__main__":
+    main()

voyolib-0.0.1/pyproject.toml

@@ -0,0 +1,14 @@
+[project]
+name = "voyolib"
+version = "0.0.1"
+description = "Python library for Voyo"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = []
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["voyo"]

voyolib-0.0.1/voyo/db/mysql/conn_pool.py

@@ -0,0 +1,146 @@
+from abc import ABC, abstractmethod
+import queue
+import threading
+import time
+from typing import Optional
+
+import pymysql
+
+_default_pool: Optional["YoConnPool"] = None
+
+def set_default_pool(pool: "YoConnPool"):
+    global _default_pool
+    _default_pool = pool
+
+def get_default_pool() -> Optional["YoConnPool"]:
+    return _default_pool
+
+class ConnPool(ABC):
+
+    @abstractmethod
+    def get_conn(self):
+        pass
+
+    @abstractmethod
+    def release_conn(self, conn):
+        pass
+
+class PooledConnection:
+
+    def __init__(self, raw_conn, created_at: float, is_burst: bool = False):
+        self.raw = raw_conn
+        self.created_at = created_at
+        self.is_burst = is_burst
+
+    def is_expired(self, max_timeout: float) -> bool:
+        return (time.time() - self.created_at) > max_timeout
+
+    def close(self):
+        if self.raw:
+            try:
+                self.raw.close()
+            except Exception:
+                pass
+            self.raw = None
+
+class YoConnPool(ConnPool):
+
+    def __init__(
+        self,
+        *,
+        host: str = "localhost",
+        port: int = 3306,
+        user: str = "",
+        password: str = "",
+        database: str = "",
+        charset: str = "utf8mb4",
+        pool_size: int = 5,
+        max_burst: int = 10,
+        max_timeout: float = 600,
+    ):
+        self._config = {
+            "host": host,
+            "port": port,
+            "user": user,
+            "password": password,
+            "database": database,
+            "charset": charset,
+            "autocommit": False,
+        }
+        self._pool_size = pool_size
+        self._max_burst = max_burst
+        self._max_timeout = max_timeout
+        self._pool = queue.Queue(maxsize=pool_size)
+        self._lock = threading.Lock()
+        self._burst_lock = threading.Lock()
+        self._burst_count = 0
+        self._conn_map = {}
+
+        for _ in range(pool_size):
+            pooled = self._create_connection()
+            self._pool.put(pooled)
+
+    def _create_connection(self, is_burst: bool = False) -> PooledConnection:
+        raw = pymysql.connect(**self._config)
+        return PooledConnection(raw, time.time(), is_burst=is_burst)
+
+    def _recycle(self, pooled: PooledConnection) -> PooledConnection:
+        pooled.close()
+        return self._create_connection()
+
+    def get_conn(self):
+        is_burst = False
+        try:
+            pooled = self._pool.get(block=False)
+        except queue.Empty:
+
+            with self._burst_lock:
+                if self._burst_count < self._max_burst:
+                    self._burst_count += 1
+                    is_burst = True
+
+            pooled = self._create_connection(is_burst=True)
+
+        if not pooled.is_burst and pooled.is_expired(self._max_timeout):
+            pooled = self._recycle(pooled)
+
+        try:
+            pooled.raw.ping()
+        except Exception:
+            pooled = self._recycle(pooled)
+
+        with self._lock:
+            self._conn_map[pooled.raw] = pooled
+        return pooled.raw
+
+    def release_conn(self, conn):
+        with self._lock:
+            pooled = self._conn_map.pop(conn, None)
+
+        if pooled is None:
+
+            try:
+                conn.close()
+            except Exception:
+                pass
+            return
+
+        if pooled.is_burst:
+            try:
+                conn.rollback()
+            except Exception:
+                pass
+            pooled.close()
+            with self._burst_lock:
+                self._burst_count = max(0, self._burst_count - 1)
+            return
+
+        try:
+            conn.rollback()
+        except Exception:
+            pass
+
+        try:
+            self._pool.put(pooled, block=False)
+        except queue.Full:
+            pooled.close()

voyolib-0.0.1/voyo/db/mysql/transaction.py

@@ -0,0 +1,59 @@
+import functools
+import inspect
+import threading
+
+from voyo.db.mysql.conn_pool import YoConnPool, get_default_pool
+
+_tx_local = threading.local()
+
+def _get_tx_stack():
+    if not hasattr(_tx_local, "stack"):
+        _tx_local.stack = []
+    return _tx_local.stack
+
+class Transaction:
+
+    def __init__(self, propagation="required", pool=None):
+        if propagation not in ("required", "new"):
+            raise ValueError("propagation must be 'required' or 'new'")
+        self.propagation = propagation
+        self.pool = pool or get_default_pool()
+        if self.pool is None:
+            raise RuntimeError(
+                "No connection pool configured for @Transaction. "
+                "Call yo_mysql.set_default_pool(pool) first."
+            )
+
+    def __call__(self, func):
+        sig = inspect.signature(func)
+        params = list(sig.parameters.values())
+
+        has_conn_param = bool(params) and params[-1].name == 'conn'
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            stack = _get_tx_stack()
+
+            if stack and self.propagation != "new":
+                conn = stack[-1]["conn"]
+
+                if has_conn_param and "conn" not in kwargs:
+                    kwargs["conn"] = conn
+
+                return func(*args, **kwargs)
+
+            conn = self.pool.get_conn()
+            stack.append({"conn": conn})
+
+            if has_conn_param and "conn" not in kwargs:
+                kwargs["conn"] = conn
+            try:
+                result = func(*args, **kwargs)
+                conn.commit()
+                return result
+            finally:
+                conn.rollback()
+                stack.pop()
+                self.pool.release_conn(conn)
+
+        return wrapper