pymydb-client 0.1.0__py3-none-any.whl

pymydb_client/__init__.py

@@ -0,0 +1,25 @@
+"""pymydb_client — pure-Python client for the MyDB database engine's mydbd
+daemon. Speaks the same wire protocol as the C `mydb` CLI; no third-party
+dependencies. Compatible with Python 2.7 and Python 3.
+"""
+
+from pymydb_client.connection import MyDBConnection, MyDBError, DEFAULT_PORT
+
+__version__ = "0.1.0"
+
+__all__ = ["connect", "MyDBConnection", "MyDBError", "DEFAULT_PORT"]
+
+
+def connect(host=None, port=DEFAULT_PORT, unix_path=None,
+            user=None, password=None):
+    """Connect and authenticate to mydbd.
+
+    Either `host` (+ optional `port`, TCP) or `unix_path` (Unix socket) must
+    be given, but not both. `password` is prompted for interactively
+    (getpass) if omitted.
+
+    Returns an open, authenticated MyDBConnection. Raises MyDBError on
+    connect/auth failure.
+    """
+    return MyDBConnection(host=host, port=port, unix_path=unix_path,
+                          user=user, password=password)

pymydb_client/_compat.py

@@ -0,0 +1,24 @@
+"""Python 2.7 / 3.x compatibility shims. No external dependency (no `six`)."""
+
+import sys
+
+PY2 = sys.version_info[0] == 2
+
+
+def to_bytes(s):
+    """Return `s` as bytes, encoding str->utf-8 on py3. On py2, str is
+    already bytes, so only unicode gets encoded."""
+    if isinstance(s, bytes):
+        return s
+    return s.encode("utf-8")
+
+
+def to_text(b):
+    """Return `b` as a text string, decoding utf-8 on both py2 and py3."""
+    if PY2:
+        if isinstance(b, unicode):  # noqa: F821 (py2-only builtin)
+            return b
+        return b.decode("utf-8", "replace")
+    if isinstance(b, str):
+        return b
+    return b.decode("utf-8", "replace")

pymydb_client/connection.py

@@ -0,0 +1,132 @@
+"""MyDBConnection — Python counterpart of client/src/client_conn.c.
+
+Speaks the same wire protocol (server/include/protocol.h) and the same
+challenge-response auth (crypto/include/crypto.h) as the C `mydb` client, so
+it can talk to mydbd over either the Unix socket or TCP.
+"""
+
+import getpass
+import socket as _socket
+
+from pymydb_client import crypto
+from pymydb_client import protocol
+from pymydb_client._compat import to_bytes, to_text
+
+DEFAULT_PORT = 4442
+
+
+class MyDBError(Exception):
+    """Raised for connect / auth / protocol failures."""
+    pass
+
+
+class MyDBConnection(object):
+    def __init__(self, host=None, port=DEFAULT_PORT, unix_path=None,
+                 user=None, password=None):
+        if not user:
+            raise MyDBError("user is required")
+        if host and unix_path:
+            raise MyDBError("host and unix_path are mutually exclusive")
+        if not host and not unix_path:
+            raise MyDBError("one of host or unix_path is required")
+
+        self._sock = None
+        self._send_seq = 0
+        self._recv_seq = 0
+
+        try:
+            if unix_path:
+                sock = _socket.socket(_socket.AF_UNIX, _socket.SOCK_STREAM)
+                sock.connect(unix_path)
+            else:
+                sock = _socket.create_connection((host, port))
+        except _socket.error as e:
+            raise MyDBError("cannot connect to MyDB server: {0}".format(e))
+
+        self._sock = sock
+        self._handshake(user, password)
+
+    def _send(self, ptype, payload):
+        try:
+            self._send_seq = protocol.send_packet(
+                self._sock, ptype, payload, self._send_seq)
+        except (protocol.ProtocolError, _socket.error) as e:
+            self.close()
+            raise MyDBError(str(e))
+
+    def _recv(self):
+        try:
+            ptype, payload, self._recv_seq = protocol.recv_packet(
+                self._sock, self._recv_seq)
+            return ptype, payload
+        except (protocol.ProtocolError, _socket.error) as e:
+            self.close()
+            raise MyDBError(str(e))
+
+    def _handshake(self, user, password):
+        user_bytes = to_bytes(user)
+
+        # 1. HANDSHAKE (server version) — read and ignore.
+        ptype, _payload = self._recv()
+        if ptype != protocol.PKT_HANDSHAKE:
+            self.close()
+            raise MyDBError("unexpected packet during handshake")
+
+        # 2. AUTH_INIT (username).
+        self._send(protocol.PKT_AUTH_INIT, user_bytes)
+
+        # 3. AUTH_CHALLENGE (salt || nonce).
+        ptype, payload = self._recv()
+        if (ptype != protocol.PKT_AUTH_CHALLENGE or
+                len(payload) != crypto.SALT_LEN + crypto.NONCE_LEN):
+            self.close()
+            raise MyDBError("authentication failed")
+        salt = payload[:crypto.SALT_LEN]
+        nonce = payload[crypto.SALT_LEN:]
+
+        # 4. response = SHA-256(nonce || SHA-256(salt || password)).
+        if password is None:
+            password = getpass.getpass("Password: ")
+        h1 = crypto.hash_password(password, salt)
+        response = crypto.compute_response(nonce, h1)
+
+        # 5. AUTH_RESPONSE = username '\0' response.
+        self._send(protocol.PKT_AUTH_RESPONSE, user_bytes + b"\x00" + response)
+
+        # 6. AUTH_OK / AUTH_ERR.
+        ptype, _payload = self._recv()
+        if ptype != protocol.PKT_AUTH_OK:
+            self.close()
+            raise MyDBError("authentication failed")
+
+    def query(self, sql):
+        """Send one SQL statement, return the server's formatted result
+        text (same opaque string the C REPL prints — there is no
+        structured row/column protocol to parse)."""
+        if self._sock is None:
+            raise MyDBError("connection is closed")
+        self._send(protocol.PKT_QUERY, sql)
+        ptype, payload = self._recv()
+        if ptype != protocol.PKT_RESPONSE:
+            raise MyDBError("unexpected response packet")
+        return to_text(payload)
+
+    def close(self):
+        if self._sock is None:
+            return
+        try:
+            self._send_seq = protocol.send_packet(
+                self._sock, protocol.PKT_QUIT, b"", self._send_seq)
+        except Exception:
+            pass  # best effort, matches client_conn_close
+        try:
+            self._sock.close()
+        finally:
+            self._sock = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+        return False

pymydb_client/crypto.py

@@ -0,0 +1,23 @@
+"""Challenge-response auth hashing — mirrors crypto/include/crypto.h.
+
+response = SHA-256(nonce || SHA-256(salt || password))
+"""
+
+import hashlib
+
+from pymydb_client._compat import to_bytes
+
+SALT_LEN = 16
+NONCE_LEN = 32
+SHA256_DIGEST_LEN = 32
+
+
+def hash_password(password, salt):
+    """SHA-256(salt || password). `password` is treated as raw text (no NUL
+    terminator, matching crypto_hash_password)."""
+    return hashlib.sha256(salt + to_bytes(password)).digest()
+
+
+def compute_response(nonce, h1):
+    """SHA-256(nonce || h1)."""
+    return hashlib.sha256(nonce + h1).digest()

pymydb_client/protocol.py

@@ -0,0 +1,67 @@
+"""Wire protocol framing — mirrors server/include/protocol.h exactly.
+
+Every packet is a 9-byte header (length, type, seq_no; length and seq_no in
+network byte order) followed by `length` payload bytes. Each direction
+(send/recv) keeps its own sequence counter starting at 0.
+"""
+
+import struct
+
+from pymydb_client._compat import to_bytes
+
+HEADER_SIZE = 9
+MAX_PAYLOAD = 65536
+
+PKT_HANDSHAKE = 1
+PKT_AUTH_INIT = 2
+PKT_AUTH_CHALLENGE = 3
+PKT_AUTH_RESPONSE = 4
+PKT_AUTH_OK = 5
+PKT_AUTH_ERR = 6
+PKT_QUERY = 7
+PKT_RESPONSE = 8
+PKT_QUIT = 9
+
+_HEADER_FMT = "!IBI"  # network-order: uint32 length, uint8 type, uint32 seq_no
+
+
+class ProtocolError(Exception):
+    pass
+
+
+def _recv_exact(sock, n):
+    chunks = []
+    remaining = n
+    while remaining > 0:
+        chunk = sock.recv(remaining)
+        if not chunk:
+            raise ProtocolError("connection closed")
+        chunks.append(chunk)
+        remaining -= len(chunk)
+    return b"".join(chunks)
+
+
+def send_packet(sock, ptype, payload, seq):
+    """Send one packet. `seq` is the current send counter; returns the next
+    value (mirrors proto_send's seq post-increment)."""
+    payload = to_bytes(payload) if payload else b""
+    if len(payload) > MAX_PAYLOAD:
+        raise ProtocolError("payload too large")
+    header = struct.pack(_HEADER_FMT, len(payload), ptype, seq)
+    sock.sendall(header + payload)
+    return seq + 1
+
+
+def recv_packet(sock, expected_seq):
+    """Receive one packet, validating the sequence number. Returns
+    (ptype, payload, next_expected_seq)."""
+    header = _recv_exact(sock, HEADER_SIZE)
+    length, ptype, seq_no = struct.unpack(_HEADER_FMT, header)
+
+    if seq_no != expected_seq:
+        raise ProtocolError("sequence mismatch (connection dropped)")
+    if length > MAX_PAYLOAD:
+        raise ProtocolError("oversized packet")
+
+    payload = _recv_exact(sock, length) if length > 0 else b""
+    return ptype, payload, expected_seq + 1

pymydb_client-0.1.0.dist-info/METADATA

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: pymydb-client
+Version: 0.1.0
+Summary: Pure-Python client for the MyDB database engine (mydbd)
+Home-page: https://github.com/Hasnat056/pymydb-client
+Author: Hasnat Akram
+License: MIT
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Database
+Requires-Python: >=2.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# pymydb-client
+
+Pure-Python client for [MyDB](https://github.com/Hasnat056/MyDB-Database-Engine),
+a relational database engine with a custom binary wire protocol served by its
+`mydbd` daemon. No third-party dependencies (just `socket`, `hashlib`,
+`struct`, `getpass` from the standard library); compatible with Python 2.7
+through 3.x.
+
+It reimplements the same challenge-response auth and framing the C `mydb` CLI
+uses, so it can talk to `mydbd` over either a Unix domain socket or TCP.
+
+## Install
+
+```bash
+pip install pymydb-client
+```
+
+## Usage
+
+```python
+from pymydb_client import connect
+
+# Over TCP (mydbd's default TCP listener, 0.0.0.0:4442)
+conn = connect(host="127.0.0.1", port=4442, user="root", password="yourpass")
+
+
+print(conn.query("SHOW DATABASES;"))
+conn.close()
+```
+
+Context manager form:
+
+```python
+with connect(host="127.0.0.1", port=4442, user="root", password="yourpass") as conn:
+    print(conn.query("SELECT id, name FROM users;"))
+```
+
+`query(sql)` returns the same formatted text a SQL client would print (a
+table for `SELECT`, or an OK/error message) — the wire protocol carries plain
+text, not structured rows.
+
+Omit `password` to be prompted interactively via `getpass`. Connect/auth/query
+failures raise `pymydb_client.MyDBError`.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

pymydb_client-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+pymydb_client/__init__.py,sha256=44GZaFZSEHDaTXvrt9hsYUAhv2ZdpuGgkFKLv8Aolr0,926
+pymydb_client/_compat.py,sha256=jkYyss-Db2ZmJx12_EEoEubgL7AEt4DQqAWDl3BK_bY,662
+pymydb_client/connection.py,sha256=Zl40Cc6UUQcQgB0ztYHhgDepP6cM9GhtOoewUPmW7RA,4458
+pymydb_client/crypto.py,sha256=aNNHW53QCLaCxG_so8HMQBMTQtt5XWi7fNZwlNdcj5g,585
+pymydb_client/protocol.py,sha256=sPIL5qUJj3AoBBjNKHTKLQU2PGmNuUSVWUuNnxZE4Ho,1925
+pymydb_client-0.1.0.dist-info/licenses/LICENSE,sha256=m65Xv-_hUHTZnY-WN0bEGPqohfi96c6kR7PPds8bz4s,1068
+pymydb_client-0.1.0.dist-info/METADATA,sha256=hm5ZOA__Lxq-lcHoUSpHO_gs6fhLDlftxA2m93pOnKk,1853
+pymydb_client-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+pymydb_client-0.1.0.dist-info/top_level.txt,sha256=Bg97aM4UKHOC6sb6uSeV8Uw-K183Hgv9N1GxGvnkYU8,14
+pymydb_client-0.1.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+pymydb_client-0.1.0.dist-info/RECORD,,

pymydb_client-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pymydb_client-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 Hasnat Akram
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pymydb_client-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pymydb_client

pymydb_client-0.1.0.dist-info/zip-safe

@@ -0,0 +1 @@
+