db-sdk 1.1.0__tar.gz

db_sdk-1.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,157 @@
+# 🗄️ 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/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-1.1.0/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-1.1.0/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-1.1.0/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-1.1.0/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-1.1.0/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-1.1.0/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-1.1.0/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-1.1.0/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-1.1.0/db_sdk/query/__init__.py

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

db_sdk-1.1.0/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)