pyapbase 0.0.10__py3-none-any.whl

pyapbase/__init__.py

@@ -0,0 +1,31 @@
+"""Docstring"""
+"""Docstring"""
+from .store import DBCORE, DBCRUD, CACHE, OBJSTORE, REDSTORE
+from .crypt import KEY, JWT
+from .auth import VERIFY, CONTEXT
+from .apps import APPS, SAPS, KAFKA, DRAMATIQ
+
+from .utils import Logging, ConfigUtil, RelDirs, ClientInfo, APIResponse
+
+__all__ = ["DBMS","CAUTH", "APPS", "SAPS", "KAFKA", "DRAMATIQ", "UTILS"]
+
+class DBMS:
+    # Store
+    DBCORE = DBCORE
+    DBCRUD = DBCRUD 
+    CACHE = CACHE
+    OBJSTORE = OBJSTORE
+    REDSTORE = REDSTORE
+
+class CAUTH:
+    KEY = KEY
+    JWT = JWT
+    CONTEXT = CONTEXT
+    VERIFY  = VERIFY
+
+class UTILS:
+    Logging = Logging
+    ConfigUtil = ConfigUtil
+    ClientInfo = ClientInfo
+    RelDirs = RelDirs
+    APIResponse = APIResponse

pyapbase/apps/__init__.py

@@ -0,0 +1,8 @@
+"""Docstring"""
+
+from .hubapp import APPS
+from .subapp import SAPS
+from .kafka  import KAFKA
+from .runner import DRAMATIQ
+
+__all__ = ["APPS", "SAPS", "KAFKA", "DRAMATIQ"]

pyapbase/apps/hubapp.py

@@ -0,0 +1,136 @@
+"""Docstring"""
+from sqlmodel import MetaData, Session
+from pydantic_settings import BaseSettings
+from fastapi import FastAPI, Request, Depends, WebSocket
+from contextlib import asynccontextmanager, AsyncExitStack
+from typing import Dict, Any, Annotated, Optional, List, Callable, Awaitable
+
+__all__ = ["APPS"]
+
+class DeployBase(BaseSettings):
+    srv_env:            str             = ".env.server"
+    dbc_env:            str             = ".env.dbapi"
+    oau_env:            str             = ".env.oauth"
+    key_env:            str             = ".env.secret"
+    sap_env:            str             = ".env.sapps"
+    env_secrets:        Optional[str]   = None           
+
+class ServerBase(BaseSettings):
+    host:               str                 = "0.0.0.0"
+    port:               int                 = 8000
+    reload:             bool                = False
+    workers:            int                 = 1
+    https_redir:        bool                = False
+    session_secret:     Optional[str]       = None
+    allowed_hosts:      Optional[List[str]] = None
+    allowed_origins:    Optional[List[str]] = None
+    deploy_env:         Optional[str]       = None
+    eager_dispatch:     bool                = False
+    secure_cookie:      Optional[bool]      = None
+    global_cookie:      Optional[bool]      = None
+    cookie_methods:     Optional[List[str]] = None
+    kongopa_schema:     Optional[str]       = None
+    supvcfg_dir:        Optional[str]       = None
+
+class AppMeta:
+    def __init__(self, metas: Dict[str, MetaData]):
+        self.metalist = list(metas.values())
+        self.schmlist = list(metas.keys())
+        self.metadict = metas
+
+class AppSpan:
+        def __init__(
+                self,
+                amigs: Optional[List[Any]] = None,
+                spans: Optional[Dict[FastAPI, Any]] = None,
+                startup: Optional[List[Callable[[], Awaitable[None]]]] = None,
+                shutdown: Optional[List[Callable[[], Awaitable[None]]]] = None,
+            ):
+            self.amig_list = amigs or []
+            self.span_dict = spans or {} 
+            self.startup = startup or []
+            self.shutdown = shutdown or []
+
+        @asynccontextmanager
+        async def lifespan(self, app: FastAPI):
+            async with AsyncExitStack() as stack:
+                # Manage the lifecycle of sub_app
+                for subamig in self.amig_list:
+                    await stack.enter_async_context(subamig())
+                for subapp, subspan in self.span_dict.items():
+                    await stack.enter_async_context(subspan(subapp))
+                for fn in self.startup:
+                    await fn()
+                yield
+                for fn in self.shutdown:
+                    await fn()
+
+class AppMsvc:
+    def __init__(
+            self, 
+            apps: Dict[str, FastAPI], 
+            lifespan, 
+            sessdep: Optional[Any] = None,
+            deploy_env: Optional[str] = None,
+        ):
+        depends = [
+            Depends(self.session_http(sessdep)), 
+            Depends(self.session_ws(sessdep))
+        ] if sessdep is not None else None
+        deploy_env = deploy_env or "production"
+        is_production = deploy_env == "production"
+        if is_production:
+            self.app = FastAPI(
+                dependencies= depends,
+                redirect_slashes=False,  
+                lifespan=lifespan, 
+                docs_url=None,
+                redoc_url=None,
+                openapi_url=None
+            )
+        else:
+            self.app = FastAPI(
+                dependencies= depends,
+                redirect_slashes=False,  
+                lifespan=lifespan
+            )
+        app_msg = {"message": "Hello Multi Micro Services API!"}
+        for key, subapp in apps.items():
+            self.app.mount(f"/{key}", subapp)
+            app_msg[key] = f"{key.capitalize()} Service at '/{key}'"
+
+        @self.app.get("/welcome")
+        async def welcome():
+            return app_msg
+        
+        @self.app.get("/health", tags=["Health"])
+        async def health():
+            return {"status": "ok"}
+        
+        
+    @staticmethod
+    def session_ws(sessdep):
+        def _session(
+            websocket: WebSocket, 
+            sess_pgs: Annotated[Session, Depends(sessdep)]
+        ):
+            """Injects session into request scope."""
+            websocket.scope["db"] = {"pgsql": sess_pgs}
+        return _session
+    
+    @staticmethod
+    def session_http(sessdep):
+        def _session(
+            request: Request, 
+            sess_pgs: Annotated[Session, Depends(sessdep)]
+        ):
+            """Injects session into request scope."""
+            request.scope["db"] = {"pgsql": sess_pgs}
+        return _session
+    
+class APPS:
+    AppMeta = AppMeta
+    AppSpan = AppSpan
+    AppMsvc = AppMsvc
+    DeployBase = DeployBase
+    ServerBase = ServerBase

pyapbase/apps/kafka.py

@@ -0,0 +1,166 @@
+
+import json, ssl, hashlib, logging, asyncio
+from typing import Dict, Optional, Union, List, Callable
+
+from aiokafka import AIOKafkaConsumer, AIOKafkaProducer
+from pydantic_settings import BaseSettings
+from ..store import DBCORE, DBCRUD
+
+__all__ = ["GlobalConsumer", ]
+
+log = logging.getLogger(__name__)
+
+PgsCore = DBCORE.PgsCore
+OdbMsvc = DBCRUD.OdbMsvc
+DbsMsvc = DBCRUD.DbsMsvc
+
+class ConfigBase(BaseSettings):
+    kafka_bootstrap_servers: str = "kafka-service:9092"
+    security_protocol: str = "PLAINTEXT"
+    sasl_plain_username: Optional[str] = None
+    sasl_plain_password: Optional[str] = None
+    kafka_topic: str = "audit_logs"
+    consumer_group: str = "audit_logger"
+
+class GlobalConsumer:
+    def __init__(
+            self, 
+            config:ConfigBase,
+            kafka_topics: Optional[Union[str, List[str]]] = None
+        ):
+        kafka_topics = kafka_topics or config.kafka_topic
+        self.config = config
+        self.topics = [kafka_topics] if isinstance(kafka_topics, str) else kafka_topics
+        self.handlers: Dict[str, Callable] = {}
+        self.default_handler: Optional[Callable] = None
+
+    # ---------------- DECORATOR API ----------------
+
+    def register(self, topic: Optional[str] = None):
+        def decorator(fn) -> Callable:
+            if topic:
+                self.handlers[topic] = fn
+            else:
+                self.default_handler = fn
+            return fn
+        return decorator
+
+    # ---------------- EXECUTION ----------------
+
+    async def _execute(self, handler, data):
+        try:
+            result = handler(data)   # keep simple contract
+            if asyncio.iscoroutine(result):
+                await result
+        except Exception:
+            log.exception("Handler execution failed")
+
+    async def _process(self, msg):
+
+        if not msg.key or not msg.value:
+            return
+
+        if msg.key != hashlib.sha256(msg.value).hexdigest().encode():
+            return
+
+        handler = self.handlers.get(msg.topic, self.default_handler)
+        if not handler:
+            return
+
+        try:
+            data = json.loads(msg.value)
+            await self._execute(handler, data)
+        except Exception:
+            log.exception("Message processing failed offset=%s", msg.offset)
+
+    # ---------------- RUN ----------------
+
+    async def run(self):
+        bootstrap_servers=self.config.kafka_bootstrap_servers
+        ssl_context = None
+        sasl_mechanism= "PLAIN"
+        security_protocol = "PLAINTEXT"
+        sasl_plain_username = None
+        sasl_plain_password = None
+        if self.config.security_protocol == "SASL_SSL":
+            ssl_context = ssl.create_default_context()
+            security_protocol = self.config.security_protocol
+            sasl_plain_username=self.config.sasl_plain_username
+            sasl_plain_password=self.config.sasl_plain_password
+
+        consumer = AIOKafkaConsumer(
+            *self.topics,
+            bootstrap_servers=bootstrap_servers,
+            ssl_context=ssl_context,
+            sasl_mechanism=sasl_mechanism,
+            security_protocol=security_protocol,
+            sasl_plain_username=sasl_plain_username,
+            sasl_plain_password=sasl_plain_password,
+            group_id=self.config.consumer_group,
+        )
+
+        await consumer.start()
+        log.info("Global consumer started")
+
+        try:
+            async for msg in consumer:
+                await self._process(msg)
+        finally:
+            await consumer.stop()
+            log.info("Kafka consumer stopped")
+
+class GlobalProducer:
+    def __init__(self, config:ConfigBase):
+        self.config = config
+        self.producer: AIOKafkaProducer | None = None
+
+    async def start(self):
+        bootstrap_servers = self.config.kafka_bootstrap_servers
+        ssl_context = None
+        security_protocol = "PLAINTEXT"
+        sasl_mechanism= "PLAIN"
+        sasl_plain_username = None
+        sasl_plain_password = None
+        if self.config.security_protocol == "SASL_SSL":
+            ssl_context = ssl.create_default_context()
+            security_protocol = self.config.security_protocol
+            sasl_plain_username=self.config.sasl_plain_username
+            sasl_plain_password=self.config.sasl_plain_password
+        try:
+            self.producer = AIOKafkaProducer(
+                bootstrap_servers=bootstrap_servers,
+                ssl_context=ssl_context,
+                sasl_mechanism=sasl_mechanism,
+                security_protocol=security_protocol,
+                sasl_plain_username=sasl_plain_username,
+                sasl_plain_password=sasl_plain_password,
+            )
+            await self.producer.start()
+            log.info("Kafka producer started")
+        except Exception:
+            log.exception("Kafka producer start failed")
+            raise RuntimeError("Producer initialization failed")
+
+    async def stop(self):
+        if self.producer:
+            await self.producer.stop()
+            log.info("Kafka producer stopped")
+
+    async def send_event(self, event: dict, topic: Optional[str] = None):
+        if not self.producer:
+            raise Exception("GlobalProducer: producer not started")
+        try:
+            topic = topic or self.config.kafka_topic
+            payload = json.dumps(event).encode("utf-8")
+            await self.producer.send_and_wait(
+                topic = topic,
+                value = payload,
+                key = hashlib.sha256(payload).hexdigest().encode("utf-8")
+            )
+        except Exception:
+            raise Exception("GlobalProducer: Kafka send failed")
+
+class KAFKA:
+    ConfigBase = ConfigBase
+    GlobalConsumer = GlobalConsumer
+    GlobalProducer = GlobalProducer

pyapbase/apps/runner.py

@@ -0,0 +1,69 @@
+"""
+broker.py
+"""
+
+from __future__ import annotations
+
+import platform, sys, logging
+from typing import Optional
+import dramatiq
+import dramatiq.cli as cli
+
+__all__ = ["setup_broker"]
+
+log = logging.getLogger(__name__)
+
+_broker_configured = False
+
+def setup_broker(
+        redis_url: Optional[str] = None
+    ) -> dramatiq.Broker:
+    global _broker_configured
+    if _broker_configured:
+        return dramatiq.get_broker()
+
+    if redis_url:
+        from dramatiq.brokers.redis import RedisBroker
+        broker = RedisBroker(url=redis_url)
+        log.info("Dramatiq broker: Redis at %s", redis_url)
+    else:
+        from dramatiq.brokers.stub import StubBroker
+        broker = StubBroker()
+        broker.emit_after("process_boot")
+        log.info("Dramatiq broker: StubBroker (in-memory, no redis_url)")
+
+    old_broker = dramatiq.get_broker()
+    for actor in old_broker.actors.values():
+        actor.broker = broker
+        broker.declare_actor(actor)
+
+    dramatiq.set_broker(broker)
+    _broker_configured = True
+    return broker
+
+class DramatiqRunner:
+    """Launches a Dramatiq CLI worker process for a configurable set of actor modules."""
+
+    def __init__(self, *modules, redis_url: Optional[str] = None,):
+        self.modules = []
+        for module in modules:
+            self.add_module(module)
+        setup_broker(redis_url)
+
+    def add_module(self, module):
+        self.modules.append(module.__name__ if hasattr(module, "__name__") else module)
+        return self
+
+    def run(self, concurrency=1, threads=8):
+        processes = 1 if platform.system() == "Windows" else concurrency
+        argv = [
+            *self.modules,
+            "--threads", str(threads),
+            "--processes", str(processes),
+        ]
+        args = cli.make_argument_parser().parse_args(argv)
+        sys.exit(cli.main(args))
+
+class DRAMATIQ:
+    DramatiqRunner = DramatiqRunner
+    setup_broker = staticmethod(setup_broker)