PyMkDB 0.1.0__tar.gz → 0.1.2__tar.gz

{pymkdb-0.1.0 → pymkdb-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyMkDB
-Version: 0.1.0
+Version: 0.1.2
 Summary: A log-structured, partitioned NoSQL database engine with full-text search, numeric indexes, and dual TCP/HTTP protocols.
 Author: MNG
 License: MIT
@@ -53,7 +53,7 @@ MkDB is a Custom Log-Structured Merge & Partitioned Redundant Storage Engine bui
 ### Starting the Server
 MkDB operates as a CLI tool. Launch the engine by pointing it to your desired database directory (which must contain a `config.json` file configuring your stores and network bindings):
 ```bash
-mkdb /path/to/your/db
+python mkdb.py /path/to/your/db
 ```
 Once running, the database will host both TCP socket and HTTP interfaces as specified in your `config.json`. The web control panel is accessible via your browser (check server output for the bound port, normally `http://localhost:<port>`).
 

{pymkdb-0.1.0 → pymkdb-0.1.2}/PyMkDB.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyMkDB
-Version: 0.1.0
+Version: 0.1.2
 Summary: A log-structured, partitioned NoSQL database engine with full-text search, numeric indexes, and dual TCP/HTTP protocols.
 Author: MNG
 License: MIT
@@ -53,7 +53,7 @@ MkDB is a Custom Log-Structured Merge & Partitioned Redundant Storage Engine bui
 ### Starting the Server
 MkDB operates as a CLI tool. Launch the engine by pointing it to your desired database directory (which must contain a `config.json` file configuring your stores and network bindings):
 ```bash
-mkdb /path/to/your/db
+python mkdb.py /path/to/your/db
 ```
 Once running, the database will host both TCP socket and HTTP interfaces as specified in your `config.json`. The web control panel is accessible via your browser (check server output for the bound port, normally `http://localhost:<port>`).
 

pymkdb-0.1.2/PyMkDB.egg-info/SOURCES.txt

@@ -0,0 +1,57 @@
+README.md
+pyproject.toml
+PyMkDB.egg-info/PKG-INFO
+PyMkDB.egg-info/SOURCES.txt
+PyMkDB.egg-info/dependency_links.txt
+PyMkDB.egg-info/entry_points.txt
+PyMkDB.egg-info/requires.txt
+PyMkDB.egg-info/top_level.txt
+mkdb/__init__.py
+mkdb/cli.py
+mkdb/config/db.py
+mkdb/config/server.py
+mkdb/db/__init__.py
+mkdb/db/cache/__init__.py
+mkdb/db/cache/ram_cache.py
+mkdb/db/cache/write_queue.py
+mkdb/db/maintenance/__init__.py
+mkdb/db/maintenance/compactor.py
+mkdb/db/maintenance/task_scheduler.py
+mkdb/db/objects/store.py
+mkdb/db/parity/__init__.py
+mkdb/db/parity/parity_manager.py
+mkdb/db/query/__init__.py
+mkdb/db/query/full_text_index.py
+mkdb/db/query/numeric_index.py
+mkdb/db/query/query_engine.py
+mkdb/db/query/tokenizer.py
+mkdb/db/query_workers/__init__.py
+mkdb/db/query_workers/dispatcher.py
+mkdb/db/query_workers/task.py
+mkdb/db/query_workers/worker.py
+mkdb/db/requesting/main.py
+mkdb/db/storage/__init__.py
+mkdb/db/storage/blob_store.py
+mkdb/db/storage/index_manager.py
+mkdb/db/storage/log_manager.py
+mkdb/db/storage/serializer.py
+mkdb/filing/__init__.py
+mkdb/objects/__init__.py
+mkdb/runtime/__init__.py
+mkdb/server/__init__.py
+mkdb/server/event_log.py
+mkdb/server/coms/actions.py
+mkdb/server/coms/http.py
+mkdb/server/coms/http_handlers.py
+mkdb/server/coms/metrics.py
+mkdb/server/coms/socket.py
+mkdb/server/coms/socket_protocol.py
+mkdb/server/control/server.py
+mkdb/server/control/api/actions.py
+mkdb/server/control/files/config.html
+mkdb/server/control/files/home.html
+mkdb/server/control/files/login.html
+mkdb/server/control/files/query.html
+mkdb/server/control/files/security.html
+mkdb/server/control/files/store-config.html
+mkdb/server/control/files/stores.html

pymkdb-0.1.2/PyMkDB.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mkdb = mkdb.cli:main

pymkdb-0.1.2/PyMkDB.egg-info/top_level.txt

@@ -0,0 +1 @@
+mkdb

{pymkdb-0.1.0 → pymkdb-0.1.2}/README.md

@@ -30,7 +30,7 @@ MkDB is a Custom Log-Structured Merge & Partitioned Redundant Storage Engine bui
 ### Starting the Server
 MkDB operates as a CLI tool. Launch the engine by pointing it to your desired database directory (which must contain a `config.json` file configuring your stores and network bindings):
 ```bash
-mkdb /path/to/your/db
+python mkdb.py /path/to/your/db
 ```
 Once running, the database will host both TCP socket and HTTP interfaces as specified in your `config.json`. The web control panel is accessible via your browser (check server output for the bound port, normally `http://localhost:<port>`).
 

{pymkdb-0.1.0/pymkdb → pymkdb-0.1.2/mkdb}/cli.py

@@ -12,10 +12,10 @@ import sys
 
 def main():
     from colorama import Fore
-    from src.db import mkdb
-    from src.config.db import mkdb_config
-    from src.filing import read_json, write_json
-    from src.runtime import runtime_settings
+    from mkdb.db import mkdb
+    from mkdb.config.db import mkdb_config
+    from mkdb.filing import read_json, write_json
+    from mkdb.runtime import runtime_settings
 
     print(f"""{Fore.CYAN}
     ╔═══════════════════════════════════════╗

{pymkdb-0.1.0/src → pymkdb-0.1.2/mkdb}/config/db.py

@@ -1,8 +1,8 @@
 import os
 
-from src.filing import write_json
-from src.config.server import control_server, socket_server, http_server
-from src.objects import base_object
+from mkdb.filing import write_json
+from mkdb.config.server import control_server, socket_server, http_server
+from mkdb.objects import base_object
 
 class query_worker_config(base_object):
     def __init__(self, data:dict={}):

{pymkdb-0.1.0/src → pymkdb-0.1.2/mkdb}/config/server.py

@@ -1,4 +1,4 @@
-from src.objects import base_object
+from mkdb.objects import base_object
 
 class server_address_config(base_object):
     def __init__(self, data:dict={}):

{pymkdb-0.1.0/src → pymkdb-0.1.2/mkdb}/db/__init__.py

@@ -3,13 +3,13 @@ import time
 from typing import Union
 
 from colorama import Fore
-from src.config.db import mkdb_config
-from src.server.coms.http import HTTPServer
+from mkdb.config.db import mkdb_config
+from mkdb.server.coms.http import HTTPServer
 
 
 class mkdb:
     def __init__(self, config:Union[dict, mkdb_config]):
-        from src.db.objects.store import store
+        from mkdb.db.objects.store import store
 
         if type(config) == dict:
             config = mkdb_config(config)
@@ -56,7 +56,7 @@ class mkdb:
         
         os.makedirs(os.path.join(self.file_path, "stores"), exist_ok=True)
         for store_name, store_config in self.config.stores.items():
-            from src.db.objects.store import store
+            from mkdb.db.objects.store import store
             if store_name not in self.stores:
                 s = store(self, store_config)
                 self.stores[store_name] = s
@@ -71,8 +71,8 @@ class mkdb:
         print("Starting servers...")
         self._started_at = time.time()
         if self.config.servers.http_server.enabled:
-            from src.server.coms.http import HTTPServer
-            from src.server.coms.http_handlers import HTTPDataHandler
+            from mkdb.server.coms.http import HTTPServer
+            from mkdb.server.coms.http_handlers import HTTPDataHandler
             HTTPDataHandler.database = self
             self._servers["http"] = HTTPServer(
                 name="Communication-HTTP",
@@ -82,7 +82,7 @@ class mkdb:
             )
 
         if self.config.servers.socket_server.enabled:
-            from src.server.coms.socket import SocketServer
+            from mkdb.server.coms.socket import SocketServer
             _sock_srv = SocketServer(
                 host=self.config.servers.socket_server.address.host,
                 port=self.config.servers.socket_server.address.port,
@@ -95,7 +95,7 @@ class mkdb:
             self._servers["socket"] = _sock_srv
 
         if self.config.servers.control_server.enabled:
-            from src.server.control.server import start_control_server
+            from mkdb.server.control.server import start_control_server
             self._servers["control"] = start_control_server(
                 host=self.config.servers.control_server.address.host,
                 port=self.config.servers.control_server.address.port,
@@ -143,8 +143,8 @@ class mkdb:
         if name == "http":
             if not cfg.http_server.enabled:
                 return
-            from src.server.coms.http import HTTPServer
-            from src.server.coms.http_handlers import HTTPDataHandler
+            from mkdb.server.coms.http import HTTPServer
+            from mkdb.server.coms.http_handlers import HTTPDataHandler
             HTTPDataHandler.database = self
             self._servers["http"] = HTTPServer(
                 name="Communication-HTTP",
@@ -155,7 +155,7 @@ class mkdb:
         elif name == "socket":
             if not cfg.socket_server.enabled:
                 return
-            from src.server.coms.socket import SocketServer
+            from mkdb.server.coms.socket import SocketServer
             srv = SocketServer(
                 host=cfg.socket_server.address.host,
                 port=cfg.socket_server.address.port,
@@ -169,7 +169,7 @@ class mkdb:
         elif name == "control":
             if not cfg.control_server.enabled:
                 return
-            from src.server.control.server import start_control_server
+            from mkdb.server.control.server import start_control_server
             self._servers["control"] = start_control_server(
                 host=cfg.control_server.address.host,
                 port=cfg.control_server.address.port,

{pymkdb-0.1.0/src → pymkdb-0.1.2/mkdb}/db/maintenance/task_scheduler.py

@@ -49,7 +49,7 @@ class TaskScheduler:
         store = self._store
         if store.log_manager is None or store._write_queue is None:
             return
-        from src.db.maintenance.compactor import Compactor
+        from mkdb.db.maintenance.compactor import Compactor
         compactor = Compactor(store)
 
         segments = store.log_manager.list_segments()

{pymkdb-0.1.0/src → pymkdb-0.1.2/mkdb}/db/objects/store.py

@@ -1,18 +1,18 @@
 import os
 
-from src.db import mkdb
-from src.config.db import store_config as _store_config
-from src.db.query_workers import QueryDispatcher
-from src.db.storage.log_manager import LogManager
-from src.db.storage.index_manager import IndexManager
-from src.db.storage import blob_store
-from src.db.storage import serializer as _serializer
-from src.db.cache.ram_cache import RamCache
-from src.db.cache.write_queue import WriteQueue
-from src.db.query.query_engine import QueryEngine, QuerySyntaxError
-from src.db.maintenance.compactor import Compactor
-from src.db.maintenance.task_scheduler import TaskScheduler
-from src.db.parity.parity_manager import ParityManager
+from mkdb.db import mkdb
+from mkdb.config.db import store_config as _store_config
+from mkdb.db.query_workers import QueryDispatcher
+from mkdb.db.storage.log_manager import LogManager
+from mkdb.db.storage.index_manager import IndexManager
+from mkdb.db.storage import blob_store
+from mkdb.db.storage import serializer as _serializer
+from mkdb.db.cache.ram_cache import RamCache
+from mkdb.db.cache.write_queue import WriteQueue
+from mkdb.db.query.query_engine import QueryEngine, QuerySyntaxError
+from mkdb.db.maintenance.compactor import Compactor
+from mkdb.db.maintenance.task_scheduler import TaskScheduler
+from mkdb.db.parity.parity_manager import ParityManager
 
 
 class store:
@@ -60,7 +60,7 @@ class store:
             service=self.config.name,
         )
         print(f"Store '{self.config.name}' initialized at {self.store_path}")
-        from src.server.event_log import emit as _emit
+        from mkdb.server.event_log import emit as _emit
         _emit("info", f"store:{self.config.name}", f"Store loaded from {self.store_path}")
 
         # Parity manager — boot verification runs at startup
@@ -218,8 +218,8 @@ class store:
         if self.log_manager is None or self.index_manager is None:
             raise RuntimeError("Store is not set up. Call setup() first.")
         blob_threshold = getattr(self.config.file_config, "blob_threshold", 5 * 1024 * 1024)
-        from src.db.storage import serializer as _serializer
-        from src.db.storage import blob_store
+        from mkdb.db.storage import serializer as _serializer
+        from mkdb.db.storage import blob_store
         line_str = _serializer.serialize_record(record_id, flat_dict)
         if len(line_str.encode("utf-8")) > blob_threshold:
             seg, offset, size = blob_store.write_blob(self.store_path, record_id, line_str)
@@ -241,7 +241,7 @@ class store:
         seg, offset, size = entry
         if self.log_manager is None:
             raise RuntimeError("Store is not set up. Call setup() first.")
-        from src.db.storage import serializer as _serializer
+        from mkdb.db.storage import serializer as _serializer
         line_str = self.log_manager.read(seg, offset, size)
         _, flat_dict = _serializer.deserialize_record(line_str)
         if self._ram_cache is not None:
@@ -264,7 +264,7 @@ class store:
 
     def teardown(self) -> None:
         """Flush and close storage handles. Called during server shutdown."""
-        from src.server.event_log import emit as _emit
+        from mkdb.server.event_log import emit as _emit
         _emit("info", f"store:{self.config.name}", "Store shutting down — flushing writes")
         if self._task_scheduler is not None:
             self._task_scheduler.stop()

{pymkdb-0.1.0/src → pymkdb-0.1.2/mkdb}/db/parity/parity_manager.py

@@ -142,7 +142,7 @@ class ParityManager:
                 "verify_and_repair: segment %03d had corruption — repaired and rewritten",
                 seq_int,
             )
-            from src.server.event_log import emit as _emit
+            from mkdb.server.event_log import emit as _emit
             _emit("recovery", f"store:{self.service}",
                   f"Segment {self.service}_{seq_int:03d}.log had corruption — repaired via Reed-Solomon")
             tmp_path = log_path + ".tmp"
@@ -160,7 +160,7 @@ class ParityManager:
         because it is still being appended to — its parity is always regenerated
         fresh instead so subsequent rollover-based parity generation is correct.
         """
-        from src.server.event_log import emit as _emit
+        from mkdb.server.event_log import emit as _emit
         all_segs = log_manager.list_segments()
         active   = log_manager.active_segment
         for seq_int in all_segs:

{pymkdb-0.1.0/src → pymkdb-0.1.2/mkdb}/db/query/full_text_index.py

@@ -12,7 +12,7 @@ to disk before each query and at each explicit save() call.
 """
 
 import os
-from src.db.query.tokenizer import tokenize
+from mkdb.db.query.tokenizer import tokenize
 
 
 class FullTextIndex:

{pymkdb-0.1.0/src → pymkdb-0.1.2/mkdb}/db/query/query_engine.py

@@ -53,8 +53,8 @@ class QueryEngine:
         kept on disk only — queries read from the file; mutations are buffered
         and flushed before each query.
         """
-        from src.db.query.full_text_index import FullTextIndex
-        from src.db.query.numeric_index import NumericIndex
+        from mkdb.db.query.full_text_index import FullTextIndex
+        from mkdb.db.query.numeric_index import NumericIndex
 
         schema = getattr(self._store.config, "schema_config", None)
         if schema is None:
@@ -142,9 +142,9 @@ class QueryEngine:
         Backfill the index for a single field by scanning all log segments.
         Safe to call from a background thread — reads only, no writes to log.
         """
-        from src.db.query.full_text_index import FullTextIndex
-        from src.db.query.numeric_index import NumericIndex
-        from src.db.storage import serializer as _ser
+        from mkdb.db.query.full_text_index import FullTextIndex
+        from mkdb.db.query.numeric_index import NumericIndex
+        from mkdb.db.storage import serializer as _ser
 
         store = self._store
         if store.log_manager is None or store.index_manager is None:

{pymkdb-0.1.0/src → pymkdb-0.1.2/mkdb}/db/query_workers/__init__.py

@@ -10,7 +10,7 @@ QueryTask        — the picklable unit of work; mostly internal
 OPERATIONS       — frozenset of valid operation strings
 """
 
-from src.db.query_workers.dispatcher import QueryDispatcher
-from src.db.query_workers.task import QueryTask, OPERATIONS
+from mkdb.db.query_workers.dispatcher import QueryDispatcher
+from mkdb.db.query_workers.task import QueryTask, OPERATIONS
 
 __all__ = ["QueryDispatcher", "QueryTask", "OPERATIONS"]

{pymkdb-0.1.0/src → pymkdb-0.1.2/mkdb}/db/query_workers/dispatcher.py

@@ -32,8 +32,8 @@ import threading
 import uuid
 from typing import Any
 
-from src.db.query_workers.task import QueryTask
-from src.db.query_workers.worker import (
+from mkdb.db.query_workers.task import QueryTask
+from mkdb.db.query_workers.worker import (
     WORKER_SENTINEL,
     worker_process_main,
     worker_thread_main,

{pymkdb-0.1.0/src → pymkdb-0.1.2/mkdb}/db/query_workers/worker.py

@@ -139,8 +139,8 @@ def _read(store_name: str, params: dict, cache: _WorkerCache, base_path: str) ->
         return cached
 
     # TODO(WS-1): seek by byte offset from IndexManager / LogManager
-    # from src.db.storage.index_manager import IndexManager
-    # from src.db.storage.log_manager import LogManager
+    # from mkdb.db.storage.index_manager import IndexManager
+    # from mkdb.db.storage.log_manager import LogManager
     # idx  = IndexManager(base_path, store_name); idx.load()
     # lmgr = LogManager(base_path, store_name)
     # seg, offset, size = idx.get(record_id)

{pymkdb-0.1.0/src → pymkdb-0.1.2/mkdb}/runtime/__init__.py

@@ -1,5 +1,5 @@
-from src.objects import runtime_options as __runtime_options__
-from src.objects import base_object
+from mkdb.objects import runtime_options as __runtime_options__
+from mkdb.objects import base_object
 
 class runtime_args(base_object):
     def __init__(self, data: dict = {}):

{pymkdb-0.1.0/src → pymkdb-0.1.2/mkdb}/server/coms/actions.py

@@ -6,7 +6,7 @@ read / write / delete / query logic so nothing is duplicated.
 
 Usage
 -----
-from src.server.coms.actions import execute, ActionResult
+from mkdb.server.coms.actions import execute, ActionResult
 
 result = execute(database, "read", store_name, {"record_id": rid},
                  client_key="alice", transport="http")
@@ -22,7 +22,7 @@ import time
 from dataclasses import dataclass
 from typing import Any, Callable, Optional
 
-from src.server.coms import metrics as _metrics
+from mkdb.server.coms import metrics as _metrics
 
 logger = logging.getLogger(__name__)
 
@@ -196,7 +196,7 @@ def _do_query(store_obj, store_name: str, params: dict, client_key: str, transpo
             result.get("count", 0), client_key, transport,
         )
         try:
-            from src.server.event_log import emit as _emit
+            from mkdb.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): "

{pymkdb-0.1.0/src → pymkdb-0.1.2/mkdb}/server/coms/http_handlers.py

@@ -20,8 +20,8 @@ import time
 from http.server import BaseHTTPRequestHandler
 from urllib.parse import urlparse
 
-from src.server.coms import metrics as _metrics
-from src.server.coms.actions import execute as _execute
+from mkdb.server.coms import metrics as _metrics
+from mkdb.server.coms.actions import execute as _execute
 
 logger = logging.getLogger(__name__)
 
@@ -240,7 +240,7 @@ class HTTPDataHandler(BaseHTTPRequestHandler):
             self._json(401, {"status": "error", "message": "Invalid credentials format", "code": 401})
             return True
 
-        from src.server.control.server import verify_password
+        from mkdb.server.control.server import verify_password
         user = db.config.users.get(username)
         if user is None or not verify_password(password, user.password_hash):
             self._json(403, {"status": "error", "message": "Invalid username or password", "code": 403})

{pymkdb-0.1.0/src → pymkdb-0.1.2/mkdb}/server/coms/socket.py

@@ -39,8 +39,8 @@ import uuid
 from dataclasses import dataclass
 from typing import Optional
 
-from src.server.coms.socket_protocol import read_frame, write_frame
-from src.server.coms.actions import execute as _execute
+from mkdb.server.coms.socket_protocol import read_frame, write_frame
+from mkdb.server.coms.actions import execute as _execute
 
 logger = logging.getLogger(__name__)
 
@@ -246,7 +246,7 @@ class SocketServer:
                 password = str(auth_msg.get("password", ""))
 
                 if has_users:
-                    from src.server.control.server import verify_password
+                    from mkdb.server.control.server import verify_password
                     user = db.config.users.get(username)
                     if user is None or not verify_password(password, user.password_hash):
                         write_frame(conn, {"type": "error", "error": "Invalid credentials"})