PyMkDB 0.1.0__py3-none-any.whl

src/objects/__init__.py

@@ -0,0 +1,190 @@
+from copy import deepcopy
+import datetime
+import os
+import sys
+from typing import Any, Dict, List, Optional, Union
+
+
+def formatItems(input:Union[dict, list]) -> Union[dict, list]:
+    if type(input) == list:
+        data = []
+        for item in input:
+            if isinstance(item, base_object):
+                data.append(item.json)
+            elif type(item) in [list, dict]:
+                data.append(formatItems(item))
+            elif type(item) in [tuple, int, float, str, bool]:
+                data.append(item)
+            elif callable(item):
+                continue
+    elif type(input) == dict:
+        data = {}
+        for key in input:
+            if "__" in str(key):
+                continue
+            item = input[key]
+            if isinstance(item, base_object):
+                data[key] = item.json
+            elif type(item) in [list, dict]:
+                data[key] = formatItems(item)
+            elif type(item) in [tuple, int, float, str, bool]:
+                data[key] = item
+            elif callable(item):
+                continue
+    return data
+    
+    
+
+class base_object:
+    def __init__(self, data:dict={}):
+        self.update(data)
+
+    def get(self, name, default=None):
+        return self.__dict__.get(name, default)
+
+    @property
+    def json(self) -> dict:
+        data = {}
+        for name in self.__dict__:
+            try:
+                if "__" not in name:
+                    item = self.__dict__[name]
+                    if isinstance(item, base_object):
+                        data[name] = item.json
+                    elif type(item) in [list, dict]:
+                        try:
+                            data[name] = formatItems(item)
+                        except Exception as e:
+                            print("error", e)
+                            print("Is dual ommited", name, type(item), item)
+                            raise e
+                    elif type(item) in [tuple, int, float, str, bool, None]:
+                        data[name] = item
+                    elif callable(item):
+                        continue
+                    else:
+                        pass
+                        #print("Is ommited", name, type(item), item)
+                        #print(data)
+            except Exception as e:
+                print("base_object EXCEPTION!", name)
+                print(e)
+                raise e
+        return data
+
+    def update(self, data:dict):
+        if type(data) not in [type(None), dict]:
+            return
+            #raise TypeError(f"base_object requires type 'Dict' on function update, Got: [{type(data)}: {data}]")
+        if data is not None and type(data) == dict:
+            for name in data:
+                item = data[name]
+                if name in self.__dict__:
+                    if isinstance(self.__dict__[name], base_object):
+                        self.__dict__[name].update(item)
+                    elif type(item) in [list, int, float, str, dict, bool]:
+                        self.__setattr__(name, item)
+                
+
+    def __repr__(self) -> str:
+        return str(self.json) # "base_object: " + json.dumps(self.json)
+
+def partition_object(data:Dict[str, str], seperator="."):
+    new = {}
+    for key in data:
+        if seperator in key:
+            lv = key.split(seperator)
+            i = 0
+            gate = new
+            for part in lv:
+                if i < len(lv)-1:
+                    if part not in gate:
+                        gate[part] = {}
+                    gate = gate[part]
+                else:
+                    gate[part] = data[key]
+                i += 1
+        else:
+            new[key] = data[key]
+    return new
+
+def compact_object(data:dict, seperator=".", prev=None):
+    new = {}
+    for key in data:
+        if type(data[key]) == dict:
+            new.update(compact_object(data[key], seperator, (prev + "." if prev is not None else "") + key))
+        else:
+            new[(prev + "." if prev is not None else "") + key] = data[key]
+    return new
+
+
+class runtime_options(base_object):
+    def __init__(self, data: dict = {}, parse=True):
+        self.args:Union[base_object, dict]
+        self.parse_error_exit:bool
+        self.parse_types:bool
+        self.parse_error_keep:bool
+        self.partition_seperator:str
+        self.__sys_argv__ = {}
+        self.__arg_types__ = {}
+        super().__init__(data)
+
+        for pack in [
+                ['args', {}],
+                ['parse_error_exit', False],
+                ['parse_types', True],
+                ['parse_error_keep', False],
+                ['partition_seperator', '.']
+            ]:
+            n, d = pack
+            try:
+                v = self.__getattribute__(n)
+            except:
+                v = None
+            if v is None:
+                self.__setattr__(n, d)
+        
+        if parse:
+            self.parse()
+
+    def __get_types__(self) -> dict[str, type]:
+        types = self.args.json if isinstance(self.args, base_object) else self.args
+        types = compact_object(types, self.partition_seperator)
+        types = {x: type(types[x]) for x in types}
+        return types
+    
+    def parse(self):
+        import re
+        data = {}
+        types = self.__get_types__()
+        self.__arg_types__ = types
+        
+        # Regex pattern to match key=value pairs
+        # Handles: key=value, key="value", key='value', key="value with spaces"
+        pattern = r'(\w+[\w\.]*)\s*=\s*(?:"([^"]*)"|\'([^\']*)\'|([^\s]*))'
+        
+        matches = re.findall(pattern, ' '.join(sys.argv[1:]))  # Skip script name (sys.argv[0])
+        for match in matches:
+            if match:
+                key = match[0]
+                # Get the value from whichever group matched (groups 1, 2, or 3)
+                value = match[1] or match[2] or match[3] or ""
+                data[key] = value
+            
+        self.__sys_argv__ = deepcopy(data)
+
+        for key in list(data.keys()):
+            value = data[key]
+            try:
+                data[key] = types.get(key)(value) # type: ignore
+            except:
+                if self.parse_error_exit:
+                    raise ValueError(f"Could not set param[{key}] to Type of [{types.get(key)}], value: [{value}]")
+                else:
+                    if self.parse_error_keep == False:
+                        print("Warning:", f"Could not set param[{key}] to Type of [{types.get(key)}], value: [{value}]")
+                        del data[key]
+
+        data = partition_object(data, self.partition_seperator)
+        if type(self.args) == dict or isinstance(self.args, base_object):
+            self.args.update(data)

src/runtime/__init__.py

@@ -0,0 +1,15 @@
+from src.objects import runtime_options as __runtime_options__
+from src.objects import base_object
+
+class runtime_args(base_object):
+    def __init__(self, data: dict = {}):
+        self.config = "./config.json"
+        super().__init__(data)
+
+class runtime_options(__runtime_options__):
+    def __init__(self, data:dict={}):
+        self.args:runtime_args = runtime_args()
+        super().__init__(data)
+
+
+runtime_settings = runtime_options()

src/server/coms/actions.py

@@ -0,0 +1,209 @@
+"""
+actions.py — Shared data-plane action executor for MkDB.
+
+Both the HTTP and socket transports delegate here for the actual
+read / write / delete / query logic so nothing is duplicated.
+
+Usage
+-----
+from src.server.coms.actions import execute, ActionResult
+
+result = execute(database, "read", store_name, {"record_id": rid},
+                 client_key="alice", transport="http")
+if result.ok:
+    send_response(result.data)
+else:
+    send_error(result.error, result.http_code)
+"""
+
+import json
+import logging
+import time
+from dataclasses import dataclass
+from typing import Any, Callable, Optional
+
+from src.server.coms import metrics as _metrics
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ActionResult:
+    """Return value from execute()."""
+    ok:        bool
+    data:      Any  = None   # payload on success
+    error:     str  = ""     # human-readable message on failure
+    http_code: int  = 400    # suggested HTTP status code on failure (socket ignores this)
+
+
+def execute(
+    database,
+    action:     str,
+    store_name: str,
+    params:     dict,
+    client_key: str,
+    transport:  str,
+    *,
+    on_broadcast: Optional[Callable[[str, dict], None]] = None,
+) -> ActionResult:
+    """
+    Execute a data-plane action and return an ActionResult.
+
+    Parameters
+    ----------
+    database      : active mkdb database instance
+    action        : "ping" | "read" | "write" | "delete" | "query"
+    store_name    : target store name (empty string valid only for "ping")
+    params        : action-specific values —
+                      read   → record_id (str)
+                      write  → record_id (str, optional), delta (dict), bytes_in (int, optional)
+                      delete → record_id (str)
+                      query  → filter (dict), hydrate (bool)
+    client_key    : username or IP, forwarded to metrics
+    transport     : "http" | "socket", forwarded to metrics
+    on_broadcast  : optional callback(store_name, event_dict) for pub-sub (used by socket)
+    """
+    if database is None:
+        return ActionResult(ok=False, error="Database not available", http_code=503)
+
+    if action == "ping":
+        return ActionResult(ok=True, data="pong")
+
+    # All non-ping actions require a named store.
+    if not store_name:
+        return ActionResult(ok=False, error="'store' is required", http_code=400)
+    store_obj = database.stores.get(store_name)
+    if store_obj is None:
+        return ActionResult(ok=False, error=f"Store '{store_name}' not found", http_code=404)
+
+    try:
+        if action == "read":
+            return _do_read(store_obj, store_name, params, client_key, transport)
+        elif action == "write":
+            return _do_write(store_obj, store_name, params, client_key, transport, on_broadcast)
+        elif action == "delete":
+            return _do_delete(store_obj, store_name, params, client_key, transport, on_broadcast)
+        elif action == "query":
+            return _do_query(store_obj, store_name, params, client_key, transport)
+        else:
+            return ActionResult(ok=False, error=f"Unknown action: {action!r}", http_code=400)
+    except Exception as exc:
+        logger.error("Action %r on store %r failed: %s", action, store_name, exc, exc_info=True)
+        _metrics.record(store_name, "error", client_key, transport=transport,
+                        error_msg=f"{type(exc).__name__}: {exc}")
+        return ActionResult(ok=False, error=str(exc), http_code=500)
+
+
+# ---------------------------------------------------------------------------
+# Per-action implementations
+# ---------------------------------------------------------------------------
+
+def _do_read(store_obj, store_name: str, params: dict, client_key: str, transport: str) -> ActionResult:
+    record_id = params.get("record_id", "")
+    if not record_id:
+        return ActionResult(ok=False, error="Missing 'record_id'", http_code=400)
+
+    result = store_obj.read(record_id)
+    if result is None:
+        _metrics.record(store_name, "error", client_key, transport=transport,
+                        error_msg=f"Record '{record_id}' not found in store '{store_name}'")
+        return ActionResult(
+            ok=False,
+            error=f"Record '{record_id}' not found in store '{store_name}'",
+            http_code=404,
+        )
+    bytes_out = len(json.dumps(result).encode())
+    _metrics.record(store_name, "read", client_key, bytes_out=bytes_out, transport=transport)
+    return ActionResult(ok=True, data=result)
+
+
+def _do_write(store_obj, store_name: str, params: dict, client_key: str, transport: str,
+              on_broadcast) -> ActionResult:
+    record_id = str(params.get("record_id", "")).strip()
+    delta     = params.get("delta", {})
+    bytes_in  = int(params.get("bytes_in", 0))
+
+    if not isinstance(delta, dict):
+        return ActionResult(ok=False, error="'delta' must be a JSON object", http_code=400)
+
+    if not record_id:
+        try:
+            record_id = store_obj.generate_id()
+        except RuntimeError as exc:
+            return ActionResult(ok=False, error=str(exc), http_code=503)
+
+    # Fall back to measuring the delta when the transport didn't supply a byte count.
+    if not bytes_in:
+        bytes_in = len(json.dumps(delta).encode())
+
+    store_obj.write(record_id, delta)
+    _metrics.record(store_name, "write", client_key, bytes_in=bytes_in, transport=transport)
+
+    if on_broadcast:
+        on_broadcast(store_name, {
+            "type": "update", "store": store_name,
+            "record_id": record_id, "op": "write",
+        })
+    return ActionResult(ok=True, data={"record_id": record_id})
+
+
+def _do_delete(store_obj, store_name: str, params: dict, client_key: str, transport: str,
+               on_broadcast) -> ActionResult:
+    record_id = params.get("record_id", "")
+    if not record_id:
+        return ActionResult(ok=False, error="Missing 'record_id'", http_code=400)
+
+    store_obj.delete(record_id)
+    _metrics.record(store_name, "delete", client_key, transport=transport)
+
+    if on_broadcast:
+        on_broadcast(store_name, {
+            "type": "update", "store": store_name,
+            "record_id": record_id, "op": "delete",
+        })
+    return ActionResult(ok=True, data={"record_id": record_id})
+
+
+def _do_query(store_obj, store_name: str, params: dict, client_key: str, transport: str) -> ActionResult:
+    filter_dict = params.get("filter", {})
+    hydrate     = bool(params.get("hydrate", False))
+
+    if not isinstance(filter_dict, dict):
+        return ActionResult(ok=False, error="'filter' must be a JSON object", http_code=400)
+
+    qe = getattr(store_obj, "query_engine", None)
+    if qe is None:
+        return ActionResult(ok=False, error=f"Store '{store_name}' has no query engine", http_code=500)
+
+    t0 = time.monotonic()
+    ids = qe.query(filter_dict)
+    duration_ms = (time.monotonic() - t0) * 1000.0
+
+    if hydrate:
+        records = [store_obj.read(rid) for rid in ids]
+        result  = {"count": len(records), "records": records}
+    else:
+        result  = {"count": len(ids), "ids": ids}
+
+    bytes_out = len(json.dumps(result).encode())
+    _metrics.record(store_name, "query", client_key, bytes_out=bytes_out, transport=transport)
+
+    # Slow query detection
+    threshold_ms = getattr(getattr(store_obj, "config", None), "slow_query_threshold_ms", 0.0)
+    if threshold_ms > 0 and duration_ms >= threshold_ms:
+        _metrics.record_slow_query(
+            store_name, duration_ms, filter_dict,
+            result.get("count", 0), client_key, transport,
+        )
+        try:
+            from src.server.event_log import emit as _emit
+            _emit(
+                "warning", f"store:{store_name}",
+                f"Slow query ({duration_ms:.1f} ms ≥ {threshold_ms:.0f} ms threshold): "
+                f"filter={json.dumps(filter_dict)}",
+            )
+        except Exception:
+            pass
+
+    result["duration_ms"] = round(duration_ms, 2)
+    return ActionResult(ok=True, data=result)

src/server/coms/http.py

@@ -0,0 +1,46 @@
+import asyncio
+import logging
+import threading
+from typing import Callable, Optional
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer as _HTTPServer
+from urllib.parse import urlparse
+
+
+
+class HTTPServer(_HTTPServer):
+    """Production-ready HTTP server with multi-threaded request handling."""
+
+    def __init__(self, name:str, host:str, port:int, responder:BaseHTTPRequestHandler):
+        """Initialize HTTP server.
+        
+        Args:
+            name: Server name
+            host: Server host address
+            port: Server port
+        """
+        self.host = host
+        self.port = port
+        self.name = name
+        self.logger = logging.getLogger(f"HTTPServer-{name}")
+        super().__init__((host, port), responder) #type: ignore
+        self.logger.info(f"HTTP Server initialized on {host}:{port}")
+        threading.Thread(target=self.run, daemon=True).start()
+
+    def run(self) -> None:
+        """Start the HTTP server."""
+        print(f"Starting {self.name} HTTP Server on {self.host}:{self.port}")
+        self.logger.info(f"Starting HTTP Server on {self.host}:{self.port}")
+        try:
+            self.serve_forever()
+        except KeyboardInterrupt:
+            self.logger.info("Server interrupted by user")
+            self.shutdown()
+        except Exception as e:
+            self.logger.error(f"Server error: {e}", exc_info=True)
+            self.shutdown()
+
+    def shutdown(self) -> None:
+        """Gracefully shutdown the server."""
+        self.logger.info("Shutting down HTTP Server")
+        super().shutdown()   # signals serve_forever() to stop
+        self.server_close()  # closes the server socket