db-sdk 1.1.0__py3-none-any.whl

db_sdk/__init__.py

@@ -0,0 +1,19 @@
+from .core.factory import ConnectionFactory
+from .core.exceptions import (
+    UniversalDBException,
+    UnsupportedDatabaseError,
+    DatabaseConnectionError,
+    ConfigurationError,
+)
+
+__version__ = "1.0.0"
+__author__  = "Neha"
+
+
+__all__ = [
+    "ConnectionFactory",
+    "UniversalDBException",
+    "UnsupportedDatabaseError",
+    "DatabaseConnectionError",
+    "ConfigurationError",
+]

db_sdk/config/__init__.py

@@ -0,0 +1,19 @@
+import os
+from db_sdk.core.exceptions import ConfigurationError
+
+
+def load_config_from_env():
+    db_type = os.getenv("DB_TYPE")
+
+    if not db_type:
+        raise ConfigurationError("DB_TYPE environment variable not set.")
+
+    return {
+        "db_type": db_type,
+        "host": os.getenv("DB_HOST"),
+        "user": os.getenv("DB_USER"),
+        "password": os.getenv("DB_PASSWORD"),
+        "database": os.getenv("DB_NAME"),
+        "port": os.getenv("DB_PORT"),
+        "uri": os.getenv("DB_URI"),
+    }

db_sdk/connectors/mongodb.py

@@ -0,0 +1,15 @@
+from pymongo import MongoClient
+from ..core.base_connector import BaseConnector
+from ..core.exceptions import DatabaseConnectionError
+
+
+class MongoConnector(BaseConnector):
+
+    def connect(self):
+        try:
+            uri = self.config.get("uri")
+            client = MongoClient(uri)
+            return client
+
+        except Exception as e:
+            raise DatabaseConnectionError(f"MongoDB connection failed: {e}")

db_sdk/connectors/mysql.py

@@ -0,0 +1,20 @@
+import mysql.connector
+from ..core.base_connector import BaseConnector
+from ..core.exceptions import DatabaseConnectionError
+
+
+class MySQLConnector(BaseConnector):
+
+    def connect(self):
+        try:
+            connection = mysql.connector.connect(
+                host=self.config.get("host"),
+                user=self.config.get("user"),
+                password=self.config.get("password"),
+                database=self.config.get("database"),
+                port=self.config.get("port", 3306),
+            )
+            return connection
+
+        except mysql.connector.Error as e:
+            raise DatabaseConnectionError(f"MySQL connection failed: {e}")

db_sdk/connectors/postgres.py

@@ -0,0 +1,20 @@
+import psycopg2
+from ..core.base_connector import BaseConnector
+from ..core.exceptions import DatabaseConnectionError
+
+
+class PostgresConnector(BaseConnector):
+
+    def connect(self):
+        try:
+            connection = psycopg2.connect(
+                host=self.config.get("host"),
+                user=self.config.get("user"),
+                password=self.config.get("password"),
+                dbname=self.config.get("database"),
+                port=self.config.get("port", 5432),
+            )
+            return connection
+
+        except psycopg2.Error as e:
+            raise DatabaseConnectionError(f"PostgreSQL connection failed: {e}")

db_sdk/connectors/redis.py

@@ -0,0 +1,20 @@
+import redis
+from ..core.base_connector import BaseConnector
+from ..core.exceptions import DatabaseConnectionError
+
+
+class RedisConnector(BaseConnector):
+
+    def connect(self):
+        try:
+            connection = redis.Redis(
+                host=self.config.get("host"),
+                port=self.config.get("port", 6379),
+                password=self.config.get("password"),
+                decode_responses=True,
+            )
+            connection.ping()  # Test connection
+            return connection
+
+        except redis.RedisError as e:
+            raise DatabaseConnectionError(f"Redis connection failed: {e}")

db_sdk/core/base_connector.py

@@ -0,0 +1,11 @@
+class BaseConnector:
+    """
+    Base connector class.
+    All database connectors must inherit from this.
+    """
+
+    def __init__(self, config: dict):
+        self.config = config
+
+    def connect(self):
+        raise NotImplementedError("Connect method must be implemented by subclass.")

db_sdk/core/exceptions.py

@@ -0,0 +1,18 @@
+class UniversalDBException(Exception):
+    """Base exception for Universal DB SDK."""
+    pass
+
+
+class UnsupportedDatabaseError(UniversalDBException):
+    """Raised when unsupported database type is provided."""
+    pass
+
+
+class DatabaseConnectionError(UniversalDBException):
+    """Raised when connection fails."""
+    pass
+
+
+class ConfigurationError(UniversalDBException):
+    """Raised when configuration is invalid."""
+    pass

db_sdk/core/factory.py

@@ -0,0 +1,30 @@
+from db_sdk.connectors.mysql import MySQLConnector
+from db_sdk.connectors.postgres import PostgresConnector
+from db_sdk.connectors.mongodb import MongoConnector
+from db_sdk.connectors.redis import RedisConnector
+# from db_sdk.core.exceptions import UnsupportedDatabaseError
+from .exceptions import UnsupportedDatabaseError
+
+
+class ConnectionFactory:
+
+    CONNECTOR_MAPPING = {
+        "mysql": MySQLConnector,
+        "postgres": PostgresConnector,
+        "mongodb": MongoConnector,
+        "redis": RedisConnector,
+    }
+
+    @staticmethod
+    def create_connection(db_type: str, config: dict):
+        db_type = db_type.lower()
+
+        if db_type not in ConnectionFactory.CONNECTOR_MAPPING:
+            raise UnsupportedDatabaseError(
+                f"Unsupported database type: {db_type}"
+            )
+
+        connector_class = ConnectionFactory.CONNECTOR_MAPPING[db_type]
+        connector = connector_class(config)
+
+        return connector.connect()

db_sdk/query/__init__.py

@@ -0,0 +1,3 @@
+from .builder import QueryBuilder
+
+__all__ = ["QueryBuilder"]

db_sdk/query/builder.py

@@ -0,0 +1,55 @@
+# db_sdk/query/builder.py
+
+class QueryBuilder:
+
+    def __init__(self, conn, db_type: str = "mysql"):
+        self._conn    = conn
+        self._db_type = db_type    # ← pass this to executor
+        self._table   = None
+        self._fields  = ["*"]
+        self._filters = []
+        self._values  = []
+        self._limit   = None
+        self._order   = None
+        self._action  = "select"
+        self._data    = {}
+
+    def table(self, name: str) -> "QueryBuilder":
+        self._table = name
+        return self
+
+    def select(self, *fields) -> "QueryBuilder":
+        self._fields = list(fields) if fields else ["*"]
+        self._action = "select"
+        return self
+
+    def where(self, column: str, value) -> "QueryBuilder":
+        self._filters.append(f"{column} = %s")
+        self._values.append(value)
+        return self
+
+    def order_by(self, column: str, direction: str = "ASC") -> "QueryBuilder":
+        self._order = f"{column} {direction.upper()}"
+        return self
+
+    def limit(self, n: int) -> "QueryBuilder":
+        self._limit = n
+        return self
+
+    def insert(self, data: dict) -> "QueryBuilder":
+        self._action = "insert"
+        self._data   = data
+        return self
+
+    def update(self, data: dict) -> "QueryBuilder":
+        self._action = "update"
+        self._data   = data
+        return self
+
+    def delete(self) -> "QueryBuilder":
+        self._action = "delete"
+        return self
+
+    def execute(self):
+        from db_sdk.query.executor import Executor
+        return Executor(self._conn, self._db_type).run(self)

db_sdk/query/executor.py

@@ -0,0 +1,127 @@
+# db_sdk/query/executor.py
+
+from db_sdk.core.exceptions import DatabaseConnectionError
+
+
+class Executor:
+    """
+    Common executor for all databases — MySQL, PostgreSQL.
+    Works by receiving a ready cursor from the builder.
+    No database-specific logic lives here.
+    """
+
+    def __init__(self, conn, db_type: str = "mysql"):
+        self._conn    = conn
+        self._db_type = db_type.lower()
+
+    def _get_cursor(self):
+        """
+        Returns a dictionary cursor based on the database type.
+        This is the only place database-specific logic lives.
+        """
+        if self._db_type == "mysql":
+            return self._conn.cursor(dictionary=True)
+
+        elif self._db_type == "postgres":
+            from psycopg2.extras import RealDictCursor
+            return self._conn.cursor(cursor_factory=RealDictCursor)
+
+        else:
+            raise ValueError(f"Unsupported db_type for executor: {self._db_type}")
+
+    def _fetch_insert_id(self, cur, table: str):
+        """
+        Gets the new row ID after INSERT.
+        MySQL uses lastrowid, PostgreSQL uses RETURNING id.
+        """
+        if self._db_type == "mysql":
+            return cur.lastrowid
+        elif self._db_type == "postgres":
+            result = cur.fetchone()
+            return result["id"]
+
+    def run(self, q):
+        """Route to the correct method based on action."""
+        actions = {
+            "select": self._select,
+            "insert": self._insert,
+            "update": self._update,
+            "delete": self._delete,
+        }
+        handler = actions.get(q._action)
+        if not handler:
+            raise ValueError(f"Unknown query action: {q._action}")
+        return handler(q)
+
+    # ── SELECT ───────────────────────────────────────────────
+
+    def _select(self, q):
+        fields = ", ".join(q._fields)
+        sql    = f"SELECT {fields} FROM {q._table}"
+
+        if q._filters:
+            sql += " WHERE " + " AND ".join(q._filters)
+        if q._order:
+            sql += f" ORDER BY {q._order}"
+        if q._limit:
+            sql += f" LIMIT {q._limit}"
+
+        try:
+            cur = self._get_cursor()
+            cur.execute(sql, q._values)
+            return [dict(row) for row in cur.fetchall()]
+        except Exception as e:
+            raise DatabaseConnectionError(f"SELECT failed: {e}")
+
+    # ── INSERT ───────────────────────────────────────────────
+
+    def _insert(self, q):
+        keys         = ", ".join(q._data.keys())
+        placeholders = ", ".join(["%s"] * len(q._data))
+        sql          = f"INSERT INTO {q._table} ({keys}) VALUES ({placeholders})"
+
+        # PostgreSQL needs RETURNING id to get the new row id
+        if self._db_type == "postgres":
+            sql += " RETURNING id"
+
+        try:
+            cur = self._get_cursor()
+            cur.execute(sql, list(q._data.values()))
+            self._conn.commit()
+            return self._fetch_insert_id(cur, q._table)
+        except Exception as e:
+            raise DatabaseConnectionError(f"INSERT failed: {e}")
+
+    # ── UPDATE ───────────────────────────────────────────────
+
+    def _update(self, q):
+        set_clause = ", ".join(f"{k} = %s" for k in q._data.keys())
+        values     = list(q._data.values()) + q._values
+        sql        = f"UPDATE {q._table} SET {set_clause}"
+
+        if q._filters:
+            sql += " WHERE " + " AND ".join(q._filters)
+
+        try:
+            cur = self._get_cursor()
+            cur.execute(sql, values)
+            self._conn.commit()
+            return cur.rowcount
+        except Exception as e:
+            raise DatabaseConnectionError(f"UPDATE failed: {e}")
+
+    # ── DELETE ───────────────────────────────────────────────
+
+    def _delete(self, q):
+        sql = f"DELETE FROM {q._table}"
+
+        if q._filters:
+            sql += " WHERE " + " AND ".join(q._filters)
+
+        try:
+            cur = self._get_cursor()
+            cur.execute(sql, q._values)
+            self._conn.commit()
+            return cur.rowcount
+        except Exception as e:
+            raise DatabaseConnectionError(f"DELETE failed: {e}")

db_sdk/test_connection.py

@@ -0,0 +1,15 @@
+from db_sdk.core.factory import ConnectionFactory
+
+config = {
+    "host": "192.168.137.9",
+    "user": "pwf",
+    "password": "JqYVmy5uPTzG",
+    "database": "pwf",
+    "port": 3306
+}
+
+try:
+    connection = ConnectionFactory.create_connection("mysql", config)
+    print("✅ Database connected successfully!")
+except Exception as e:
+    print("❌ Connection failed:", e)

db_sdk-1.1.0.dist-info/METADATA

@@ -0,0 +1,175 @@
+Metadata-Version: 2.4
+Name: db_sdk
+Version: 1.1.0
+Summary: A unified database connector SDK for Python
+Author: Neha
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: mysql-connector-python>=8.3.0
+Requires-Dist: psycopg2-binary>=2.9.0
+Requires-Dist: pymongo>=4.0.0
+Requires-Dist: redis>=4.0.0
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# 🗄️ Universal DB SDK
+
+A lightweight, plug-and-play Python SDK for connecting to multiple databases
+(MySQL, PostgreSQL, MongoDB, Redis) through a single unified interface.
+
+---
+
+## 📦 Installation
+```bash
+pip install db-sdk
+```
+
+Install only the drivers you need:
+```bash
+pip install mysql-connector-python   # MySQL
+pip install psycopg2-binary          # PostgreSQL
+pip install pymongo                  # MongoDB
+pip install redis                    # Redis
+```
+
+---
+
+## ✨ Features
+
+- **One interface** for MySQL, PostgreSQL, MongoDB, and Redis
+- **No boilerplate** — one function call returns a live connection
+- **Easy to extend** — add a new database in minutes
+- **Clean error handling** — typed exceptions for every failure mode
+- **Zero framework dependency** — works with FastAPI, Django, Flask, or plain Python
+
+---
+
+## 🚀 Quick Start
+```python
+from db_sdk.core.factory import ConnectionFactory
+
+conn = ConnectionFactory.create_connection("mysql", {
+    "host": "localhost",
+    "user": "root",
+    "password": "yourpassword",
+    "database": "mydb",
+    "port": 3306
+})
+```
+
+That's it. `conn` is a live, ready-to-use connection object.
+
+---
+
+## 🔌 Supported Databases
+
+| Database   | Type string  | Driver used                  |
+|------------|--------------|------------------------------|
+| MySQL      | `"mysql"`    | `mysql-connector-python`     |
+| PostgreSQL | `"postgres"` | `psycopg2`                   |
+| MongoDB    | `"mongodb"`  | `pymongo`                    |
+| Redis      | `"redis"`    | `redis`                      |
+
+---
+
+## ⚙️ Configuration Reference
+
+### MySQL
+```python
+conn = ConnectionFactory.create_connection("mysql", {
+    "host":     "localhost",
+    "user":     "root",
+    "password": "yourpassword",
+    "database": "mydb",
+    "port":     3306          # optional, defaults to 3306
+})
+```
+
+### PostgreSQL
+```python
+conn = ConnectionFactory.create_connection("postgres", {
+    "host":     "localhost",
+    "user":     "postgres",
+    "password": "yourpassword",
+    "database": "mydb",
+    "port":     5432          # optional, defaults to 5432
+})
+```
+
+### MongoDB
+```python
+conn = ConnectionFactory.create_connection("mongodb", {
+    "uri": "mongodb://user:password@localhost:27017/mydb"
+})
+```
+
+> MongoDB uses a URI string instead of separate fields.
+> Format: `mongodb://user:password@host:port/database`
+
+### Redis
+```python
+conn = ConnectionFactory.create_connection("redis", {
+    "host": "localhost",
+    "port": 6379             # optional, defaults to 6379
+})
+```
+
+---
+
+## 🏗️ Project Structure
+```
+db_sdk/
+├── __init__.py
+├── settings.py
+├── core/
+│   ├── base_connector.py    # Abstract base all connectors inherit from
+│   ├── exceptions.py        # All SDK exception types
+│   └── factory.py           # ConnectionFactory — the main entry point
+└── connectors/
+    ├── mysql.py             # MySQL connector
+    ├── postgres.py          # PostgreSQL connector
+    ├── mongodb.py           # MongoDB connector
+    └── redis.py             # Redis connector
+```
+
+---
+
+## ⚠️ Error Handling
+
+The SDK raises typed exceptions so you can handle failures precisely:
+```python
+from db_sdk.core.factory import ConnectionFactory
+from db_sdk.core.exceptions import (
+    DatabaseConnectionError,
+    UnsupportedDatabaseError,
+    ConfigurationError,
+)
+
+try:
+    conn = ConnectionFactory.create_connection("mysql", config)
+
+except DatabaseConnectionError as e:
+    # Connection failed — wrong password, DB offline, network issue
+    print(f"Could not connect: {e}")
+
+except UnsupportedDatabaseError as e:
+    # db_type string not recognised
+    print(f"Unknown database type: {e}")
+
+except ConfigurationError as e:
+    # Missing or invalid keys in the config dict
+    print(f"Bad config: {e}")
+```
+
+### Exception Hierarchy
+```
+UniversalDBException          ← catch this for any SDK error
+    ├── DatabaseConnectionError
+    ├── UnsupportedDatabaseError
+    └── ConfigurationError
+```
+

db_sdk-1.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+db_sdk/__init__.py,sha256=wrz2jB0CIfzDtzSkLqNyclG1xzIB7xzBzFLlPkrm0V8,387
+db_sdk/test_connection.py,sha256=iEnbWKy5JE9PQx_Ltyrd-B46295uGzzCH-EyDRhqEDc,371
+db_sdk/config/__init__.py,sha256=8oYWCzSeU8jAHKIdO03T92VMmBHjgjLc7UZENoxrJR4,509
+db_sdk/config/settings.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+db_sdk/connectors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+db_sdk/connectors/mongodb.py,sha256=0qp1pZme06h3U0NNzt_Q8ffBV1v6aLxuY2SFzTjUW3Y,423
+db_sdk/connectors/mysql.py,sha256=M8UkfrfIbCW4PwytQYuisi4QvxHx49BrfbOHYyOuQx8,665
+db_sdk/connectors/postgres.py,sha256=0XXKbHdQJWPX95pfaU14Jn7eEnJVjOeovYA55w0alb0,650
+db_sdk/connectors/redis.py,sha256=WwVqKvJkk9DPwQg0dPy5SJmQh4T23_fELGy0uApsyoE,626
+db_sdk/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+db_sdk/core/base_connector.py,sha256=IoOpxqUPgNDsOK2om755qF0Mz-zrQIplXBngGeMQsLk,291
+db_sdk/core/exceptions.py,sha256=R9q4_FkxaZhyf24Cwmg8pfs0dh5sFoXf_Ih88bdr2kA,431
+db_sdk/core/factory.py,sha256=hrydt3J3S2YrYgoGo1iBjG_E8dFvvbX_QwhkbdSrFpo,960
+db_sdk/query/__init__.py,sha256=65_3tvrhYPlEHOCza3phXVZvOUwSnTgB_p7hGbvo8Kc,61
+db_sdk/query/builder.py,sha256=zl2LZ4om7rjDySncySp4XXuA-Jnw9_1XEurxYRTgGkg,1584
+db_sdk/query/executor.py,sha256=EpM1TbA_5fU95RqKeI4XkSgq4Btzhdetm1SovbzRfIQ,4501
+db_sdk-1.1.0.dist-info/METADATA,sha256=rUOvk9C48lCIhRPhlm4_FmrsFZf9ocV44a2TwhKn0pQ,4512
+db_sdk-1.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+db_sdk-1.1.0.dist-info/top_level.txt,sha256=sWeCT6R-hslk8L6onXix41smZ45S8k6LmYDErKvC8xA,7
+db_sdk-1.1.0.dist-info/RECORD,,

db_sdk-1.1.0.dist-info/WHEEL

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

db_sdk-1.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+db_sdk