pyinternet 0.1.0__py3-none-any.whl

cache/__init__.py

@@ -0,0 +1,173 @@
+"""Python port of github.com/celsiainternet/elvis/cache.
+
+Function names and parameter lists mirror the Go package one-to-one so
+that code translated from Go reads the same in Python:
+
+    import cache
+
+    cache.Load()
+    cache.Set("greeting", "hello", 60)
+    cache.Get("greeting", "")
+
+See the package README for the full Go -> Python mapping and the
+handful of deliberate deviations (error handling via exceptions instead
+of (value, error) tuples; HTTP handlers take a plain query dict instead
+of http.ResponseWriter/*http.Request).
+"""
+
+from . import cache as _cache_mod
+from ._et import Item, Items, Json, List
+from .cache import Close, Conn, HealthCheck, IsLoad, Load
+from .connect import ConnectTo
+from .ctx import (
+    DecrCtx,
+    DecrKeepTTLScript,
+    DeleteCtx,
+    ExistsCtx,
+    ExpireCtx,
+    GetCtx,
+    HDeleteCtx,
+    HGetCtx,
+    HSetCtx,
+    IncrCtx,
+    IncrSetTTLScript,
+    LPushCtx,
+    LRangeCtx,
+    LRemCtx,
+    LTrimCtx,
+    SetCtx,
+)
+from .handler import (
+    AllCache,
+    Decr,
+    Delete,
+    DeleteVerify,
+    Empty,
+    Exists,
+    Expire,
+    GenId,
+    GenKey,
+    Get,
+    GetBool,
+    GetFloat,
+    GetInt,
+    GetInt64,
+    GetItem,
+    GetItems,
+    GetJson,
+    GetVerify,
+    HandlerAll,
+    HandlerDelete,
+    HandlerGet,
+    HDelete,
+    HGet,
+    HGetAtrib,
+    HSet,
+    HSetAtrib,
+    Incr,
+    IsNil,
+    LPush,
+    LRange,
+    LRem,
+    LTrim,
+    More,
+    Set,
+    SetD,
+    SetH,
+    SetM,
+    SetVerify,
+    SetW,
+    SetY,
+)
+from .pubsub import Message
+
+
+def __getattr__(name: str):
+    # `FromId` mirrors a package-level Go var that is reassigned inside
+    # Load(). A plain `from .cache import FromId` would freeze it at its
+    # import-time value (""), since Python import bindings are snapshots,
+    # not live references like Go's package-qualified access. Module-level
+    # __getattr__ (PEP 562) resolves it against the live value on every
+    # access instead, so `cache.FromId` stays a plain attribute (no
+    # parens) just like in Go.
+    if name == "FromId":
+        return _cache_mod.FromId
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = [
+    # cache.py
+    "Load",
+    "Close",
+    "IsLoad",
+    "HealthCheck",
+    "Conn",
+    "FromId",
+    # connect.py
+    "ConnectTo",
+    # ctx.py
+    "SetCtx",
+    "ExpireCtx",
+    "GetCtx",
+    "ExistsCtx",
+    "DeleteCtx",
+    "IncrCtx",
+    "DecrCtx",
+    "LPushCtx",
+    "LRemCtx",
+    "LRangeCtx",
+    "LTrimCtx",
+    "HSetCtx",
+    "HGetCtx",
+    "HDeleteCtx",
+    "IncrSetTTLScript",
+    "DecrKeepTTLScript",
+    # handler.py
+    "IsNil",
+    "GenId",
+    "GenKey",
+    "Set",
+    "Get",
+    "Exists",
+    "Delete",
+    "Expire",
+    "Incr",
+    "Decr",
+    "LPush",
+    "LRem",
+    "LRange",
+    "LTrim",
+    "SetH",
+    "SetD",
+    "SetW",
+    "SetM",
+    "SetY",
+    "Empty",
+    "More",
+    "HSet",
+    "HGet",
+    "HSetAtrib",
+    "HGetAtrib",
+    "HDelete",
+    "SetVerify",
+    "GetVerify",
+    "DeleteVerify",
+    "AllCache",
+    "GetInt",
+    "GetInt64",
+    "GetFloat",
+    "GetBool",
+    "GetJson",
+    "GetItem",
+    "GetItems",
+    "HandlerAll",
+    "HandlerGet",
+    "HandlerDelete",
+    # pubsub.py
+    "Message",
+    # _et.py
+    "Json",
+    "Item",
+    "Items",
+    "List",
+]

cache/_et.py

@@ -0,0 +1,143 @@
+"""Minimal port of github.com/celsiainternet/elvis/et types.
+
+Only the pieces consumed by the `cache` package are ported: Json, Item,
+Items and List.
+"""
+
+import json as _json
+from typing import Any, Dict, List as _List
+
+
+class Json(dict):
+    """Mirrors et.Json (a map[string]interface{} with helpers)."""
+
+    def ToString(self) -> str:
+        """
+        * ToString
+        * @return str
+        """
+        return _json.dumps(self, default=str, ensure_ascii=False)
+
+    def Scan(self, src: str) -> None:
+        """
+        * Scan
+        * @params src str
+        * @return None
+        """
+        self.clear()
+        self.update(_json.loads(src) if src else {})
+
+
+class Item:
+    """Mirrors et.Item — a single result with Ok bool and Result Json."""
+
+    def __init__(self, Ok: bool = False, Result: Json = None):
+        self.Ok = Ok
+        self.Result: Json = Result if Result is not None else Json()
+
+    def ToJson(self) -> Json:
+        return Json({"ok": self.Ok, "result": dict(self.Result)})
+
+    def ToString(self) -> str:
+        """
+        * ToString
+        * @return str
+        """
+        return self.ToJson().ToString()
+
+    @staticmethod
+    def FromString(src: str) -> "Item":
+        data = _json.loads(src) if src else {}
+        return Item(Ok=bool(data.get("ok", False)), Result=Json(data.get("result") or {}))
+
+
+class Items:
+    """Mirrors et.Items — a paginated result set."""
+
+    def __init__(self, Ok: bool = False, Count: int = 0, Result: _List[Json] = None):
+        self.Ok = Ok
+        self.Count = Count
+        self.Result: _List[Json] = Result if Result is not None else []
+
+    def ToJson(self) -> Json:
+        return Json({"ok": self.Ok, "count": self.Count, "result": [dict(r) for r in self.Result]})
+
+    def ToString(self) -> str:
+        """
+        * ToString
+        * @return str
+        """
+        return self.ToJson().ToString()
+
+    @staticmethod
+    def FromString(src: str) -> "Items":
+        data = _json.loads(src) if src else {}
+        result = [Json(r) for r in data.get("result") or []]
+        return Items(Ok=bool(data.get("ok", False)), Count=int(data.get("count", 0)), Result=result)
+
+    def ToList(self, all: int, page: int, rows: int) -> "List":
+        """
+        * ToList
+        * @params all int, page int, rows int
+        * @return List
+        """
+        count = self.Count
+        if count <= 0:
+            start = 0
+            end = 0
+        else:
+            offset = (page - 1) * rows
+            if offset > 0:
+                start = offset + 1
+                end = offset + count
+            else:
+                start = 1
+                end = count
+
+        return List(Rows=rows, All=all, Count=count, Page=page, Start=start, End=end, Result=self.Result)
+
+
+class List:
+    """Mirrors et.List — a list with pagination metadata."""
+
+    def __init__(
+        self,
+        Rows: int = 0,
+        All: int = 0,
+        Count: int = 0,
+        Page: int = 0,
+        Start: int = 0,
+        End: int = 0,
+        Result: _List[Json] = None,
+    ):
+        self.Rows = Rows
+        self.All = All
+        self.Count = Count
+        self.Page = Page
+        self.Start = Start
+        self.End = End
+        self.Result: _List[Json] = Result if Result is not None else []
+
+    def ToJson(self) -> Json:
+        """
+        * ToJson
+        * @return Json
+        """
+        return Json(
+            {
+                "rows": self.Rows,
+                "all": self.All,
+                "count": self.Count,
+                "page": self.Page,
+                "start": self.Start,
+                "end": self.End,
+                "result": [dict(r) for r in self.Result],
+            }
+        )
+
+    def ToString(self) -> str:
+        """
+        * ToString
+        * @return str
+        """
+        return self.ToJson().ToString()

cache/_logs.py

@@ -0,0 +1,63 @@
+"""Minimal structured logging.
+
+Mirrors the subset of github.com/celsiainternet/elvis/logs consumed by
+the Go `cache` package: Log, Logf, Alert, Alertm, Alertf.
+"""
+
+import sys
+from typing import Optional
+
+
+def _print_ln(kind: str, *args: object) -> None:
+    message = " ".join(str(a) for a in args)
+    print(f"[{kind}] {message}", file=sys.stderr)
+
+
+def Log(kind: str, *args: object) -> None:
+    """
+    * Log
+    * @params kind str, *args
+    * @return None
+    """
+    _print_ln(kind, *args)
+
+
+def Logf(kind: str, format: str, *args: object) -> None:
+    """
+    * Logf
+    * @params kind str, format str, *args
+    * @return None
+    """
+    _print_ln(kind, format % args if args else format)
+
+
+def Alert(err: Optional[BaseException]) -> Optional[BaseException]:
+    """
+    * Alert
+    * @params err Exception | None
+    * @return Exception | None
+    """
+    if err is not None:
+        _print_ln("Alert", str(err))
+    return err
+
+
+def Alertm(message: str) -> Exception:
+    """
+    * Alertm
+    * @params message str
+    * @return Exception
+    """
+    err = Exception(message)
+    _print_ln("Alert", str(err))
+    return err
+
+
+def Alertf(format: str, *args: object) -> Exception:
+    """
+    * Alertf
+    * @params format str, *args
+    * @return Exception
+    """
+    message = format % args if args else format
+    return Alertm(message)

cache/_msg.py

@@ -0,0 +1,9 @@
+"""Message constants used by the cache package.
+
+Mirrors the subset of github.com/celsiainternet/elvis/msg consumed by
+the Go `cache` package.
+"""
+
+MSG_ATRIB_REQUIRED = "atributo requerido (%s)"
+ERR_ENV_REQUIRED = "variables de entorno requerida (%s)"
+ERR_NOT_CACHE_SERVICE = "no hay servicio de caching"

cache/cache.py

@@ -0,0 +1,101 @@
+"""Core connection handling.
+
+Mirrors github.com/celsiainternet/elvis/cache/cache.go: the package
+level `conn` singleton, `FromId`, `Load`, `Close`, `IsLoad` and
+`HealthCheck`.
+"""
+
+import threading
+import uuid
+from typing import Dict, Optional
+
+import redis
+
+from . import _logs as logs
+from .pubsub import PubSubMixin
+
+conn: Optional["Conn"] = None
+FromId: str = ""
+
+
+class Conn(PubSubMixin):
+    """Mirrors cache.Conn (embeds *redis.Client)."""
+
+    def __init__(self, client: "redis.Redis", _id: str, host: str, dbname: int):
+        self.client = client
+        self._id = _id
+        # Unused: kept only so callers can mirror Go's `conn.ctx` access
+        # pattern when invoking the *Ctx functions in ctx.py.
+        self.ctx = None
+        self.host = host
+        self.dbname = dbname
+        self.channels: Dict[str, bool] = {}
+        self.mutex = threading.RLock()
+
+    def __getattr__(self, name: str):
+        # Mirrors Go embedding: promote *redis.Client methods onto Conn.
+        return getattr(self.client, name)
+
+    def Close(self) -> None:
+        self.client.close()
+
+
+def Load() -> "Conn":
+    """
+    * Load
+    * @return Conn
+    """
+    global conn, FromId
+
+    if conn is not None:
+        return conn
+
+    from .connect import connect
+
+    conn = connect()
+    FromId = conn._id
+
+    return conn
+
+
+def Close() -> None:
+    """
+    * Close
+    * @return None
+    """
+    global conn
+
+    if conn is None:
+        return
+
+    conn.Close()
+
+    logs.Log("Cache", "Disconnect...")
+
+
+def IsLoad() -> bool:
+    """
+    * IsLoad
+    * @return bool
+    """
+    return conn is not None
+
+
+def HealthCheck() -> bool:
+    """
+    * HealthCheck
+    * @return bool
+    """
+    if conn is None:
+        return False
+
+    try:
+        conn.client.ping()
+    except Exception:
+        return False
+
+    return True
+
+
+def _new_id() -> str:
+    return str(uuid.uuid4())

cache/connect.py

@@ -0,0 +1,62 @@
+"""Connection helpers.
+
+Mirrors github.com/celsiainternet/elvis/cache/connect.go: `ConnectTo`
+and the internal `connect`.
+"""
+
+import redis
+
+import envar
+
+from . import _logs as logs
+from ._msg import ERR_ENV_REQUIRED, MSG_ATRIB_REQUIRED
+
+
+def ConnectTo(host: str, password: str, dbname: int) -> "Conn":
+    """
+    * ConnectTo
+    * @param host str, password str, dbname int
+    * @return Conn
+    """
+    from .cache import Conn, _new_id
+
+    if not host:
+        raise ValueError(MSG_ATRIB_REQUIRED % "redist_host")
+
+    pool_size = envar.GetInt(10, "REDIS_POOL_SIZE")
+    # REDIS_MIN_IDLE_CONNS is read for env-var parity with Go, but redis-py's
+    # connection pool has no equivalent min-idle-connections setting.
+    envar.GetInt(2, "REDIS_MIN_IDLE_CONNS")
+
+    client = redis.Redis(
+        host=host.split(":")[0],
+        port=int(host.split(":")[1]) if ":" in host else 6379,
+        password=password or None,
+        db=dbname,
+        max_connections=pool_size,
+        decode_responses=True,
+    )
+
+    client.ping()
+
+    logs.Logf("Redis", "Connected host:%s", host)
+
+    return Conn(client=client, _id=_new_id(), host=host, dbname=dbname)
+
+
+def connect() -> "Conn":
+    """
+    * connect
+    * @return Conn
+    """
+    host = envar.GetStr("", "REDIS_HOST")
+    password = envar.GetStr("", "REDIS_PASSWORD")
+    dbname = envar.GetInt(0, "REDIS_DB")
+
+    if not host:
+        raise logs.Alertf(ERR_ENV_REQUIRED, "REDIS_HOST")
+
+    if not password:
+        raise logs.Alertf(ERR_ENV_REQUIRED, "REDIS_PASSWORD")
+
+    return ConnectTo(host, password, dbname)