mpratyush54-sdk 0.6.0__tar.gz

mpratyush54_sdk-0.6.0/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: mpratyush54-sdk
+Version: 0.6.0
+Summary: Platform Python SDK
+Home-page: https://github.com/Mpratyush54/server-automation
+Author: Platform Team
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: psycopg2-binary>=2.9.0
+Requires-Dist: pymongo>=4.5.0
+Requires-Dist: redis>=5.0.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# mpratyush54-sdk
+
+The official Python SDK for the Platform.
+
+This SDK provides core backend integrations for your Python microservices, including auto-registration with the platform, metrics aggregation, structured logging, and standardized database connections.
+
+## Installation
+
+```bash
+pip install mpratyush54-sdk
+```
+
+## Features
+
+- **Service Registration:** Automatically registers your microservice with the Platform API on startup.
+- **Metrics Aggregation:** Utility decorators and middleware to record route metrics, execution times, and memory deltas.
+- **Database Connections:** Pre-configured Psycopg2 (PostgreSQL), PyMongo (MongoDB), and Redis connection utilities.
+- **Logging:** Structured logging that automatically ships to the platform.
+
+## Usage
+
+```python
+from platform_sdk import PlatformSDK
+
+sdk = PlatformSDK(
+    project_id="your-project-id",
+    environment="production",
+    api_url="https://api.your-platform.com"
+)
+
+# Initialize connections and register service
+sdk.initialize()
+
+# Use database connections safely
+db = sdk.connections.get_postgres()
+cursor = db.cursor()
+cursor.execute("SELECT version();")
+print(cursor.fetchone())
+```

mpratyush54_sdk-0.6.0/README.md

@@ -0,0 +1,39 @@
+# mpratyush54-sdk
+
+The official Python SDK for the Platform.
+
+This SDK provides core backend integrations for your Python microservices, including auto-registration with the platform, metrics aggregation, structured logging, and standardized database connections.
+
+## Installation
+
+```bash
+pip install mpratyush54-sdk
+```
+
+## Features
+
+- **Service Registration:** Automatically registers your microservice with the Platform API on startup.
+- **Metrics Aggregation:** Utility decorators and middleware to record route metrics, execution times, and memory deltas.
+- **Database Connections:** Pre-configured Psycopg2 (PostgreSQL), PyMongo (MongoDB), and Redis connection utilities.
+- **Logging:** Structured logging that automatically ships to the platform.
+
+## Usage
+
+```python
+from platform_sdk import PlatformSDK
+
+sdk = PlatformSDK(
+    project_id="your-project-id",
+    environment="production",
+    api_url="https://api.your-platform.com"
+)
+
+# Initialize connections and register service
+sdk.initialize()
+
+# Use database connections safely
+db = sdk.connections.get_postgres()
+cursor = db.cursor()
+cursor.execute("SELECT version();")
+print(cursor.fetchone())
+```

mpratyush54_sdk-0.6.0/mpratyush54_sdk.egg-info/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: mpratyush54-sdk
+Version: 0.6.0
+Summary: Platform Python SDK
+Home-page: https://github.com/Mpratyush54/server-automation
+Author: Platform Team
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: psycopg2-binary>=2.9.0
+Requires-Dist: pymongo>=4.5.0
+Requires-Dist: redis>=5.0.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# mpratyush54-sdk
+
+The official Python SDK for the Platform.
+
+This SDK provides core backend integrations for your Python microservices, including auto-registration with the platform, metrics aggregation, structured logging, and standardized database connections.
+
+## Installation
+
+```bash
+pip install mpratyush54-sdk
+```
+
+## Features
+
+- **Service Registration:** Automatically registers your microservice with the Platform API on startup.
+- **Metrics Aggregation:** Utility decorators and middleware to record route metrics, execution times, and memory deltas.
+- **Database Connections:** Pre-configured Psycopg2 (PostgreSQL), PyMongo (MongoDB), and Redis connection utilities.
+- **Logging:** Structured logging that automatically ships to the platform.
+
+## Usage
+
+```python
+from platform_sdk import PlatformSDK
+
+sdk = PlatformSDK(
+    project_id="your-project-id",
+    environment="production",
+    api_url="https://api.your-platform.com"
+)
+
+# Initialize connections and register service
+sdk.initialize()
+
+# Use database connections safely
+db = sdk.connections.get_postgres()
+cursor = db.cursor()
+cursor.execute("SELECT version();")
+print(cursor.fetchone())
+```

mpratyush54_sdk-0.6.0/mpratyush54_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+setup.py
+mpratyush54_sdk.egg-info/PKG-INFO
+mpratyush54_sdk.egg-info/SOURCES.txt
+mpratyush54_sdk.egg-info/dependency_links.txt
+mpratyush54_sdk.egg-info/requires.txt
+mpratyush54_sdk.egg-info/top_level.txt
+platform_sdk/__init__.py
+platform_sdk/db/__init__.py
+platform_sdk/db/mongo.py
+platform_sdk/db/postgres.py
+platform_sdk/db/redis.py
+tests/test_caps_client.py
+tests/test_integration.py
+tests/test_mongo.py
+tests/test_postgres.py
+tests/test_redis.py

mpratyush54_sdk-0.6.0/mpratyush54_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mpratyush54_sdk-0.6.0/mpratyush54_sdk.egg-info/requires.txt

@@ -0,0 +1,3 @@
+psycopg2-binary>=2.9.0
+pymongo>=4.5.0
+redis>=5.0.0

mpratyush54_sdk-0.6.0/mpratyush54_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+platform_sdk

mpratyush54_sdk-0.6.0/platform_sdk/__init__.py

@@ -0,0 +1,170 @@
+"""
+Platform Python SDK
+Auto-registration, metrics, logging, config, storage, DB connections
+"""
+import os
+import time
+import json
+import logging
+import threading
+from typing import Optional, List, Dict, Any
+from urllib.request import Request, urlopen
+from urllib.error import URLError
+
+logger = logging.getLogger('platform')
+
+
+class PlatformClient:
+    def __init__(self):
+        self.http = None
+        self.options = {}
+        self.initialized = False
+        self._heartbeat_timer = None
+        self._db_connections = {}
+
+    def init(
+        self,
+        project_name: str,
+        platform_url: str,
+        environment_name: str = "development",
+        version: str = "1.0.0",
+        branch: str = "main",
+        commit_sha: Optional[str] = None,
+        namespace: Optional[str] = None,
+        hostname: Optional[str] = None,
+        databases: Optional[List[str]] = None,
+    ):
+        self.options = {
+            "project_name": project_name,
+            "platform_url": platform_url.rstrip("/"),
+            "environment_name": environment_name,
+            "version": version,
+            "branch": branch,
+            "commit_sha": commit_sha,
+            "namespace": namespace,
+            "hostname": hostname or os.uname().nodename,
+            "databases": databases or [],
+        }
+
+        self._register()
+        self._start_heartbeat()
+
+        if "postgres" in self.options["databases"]:
+            from .db.postgres import PostgresManager
+            self._db_connections["postgres"] = PostgresManager()
+            try:
+                self._db_connections["postgres"].connect()
+            except Exception as e:
+                logger.warning(f"PostgreSQL connection failed (non-blocking): {e}")
+
+        if "mongo" in self.options["databases"]:
+            from .db.mongo import MongoManager
+            self._db_connections["mongo"] = MongoManager()
+            try:
+                self._db_connections["mongo"].connect()
+            except Exception as e:
+                logger.warning(f"MongoDB connection failed (non-blocking): {e}")
+
+        if "redis" in self.options["databases"]:
+            from .db.redis import RedisManager
+            self._db_connections["redis"] = RedisManager()
+            try:
+                self._db_connections["redis"].connect()
+            except Exception as e:
+                logger.warning(f"Redis connection failed (non-blocking): {e}")
+
+        self.initialized = True
+
+    def _request(self, method: str, path: str, data: Optional[Dict] = None,
+                  params: Optional[Dict] = None) -> Optional[Dict]:
+        url = f"{self.options['platform_url']}{path}"
+        if params:
+            qs = "&".join(f"{k}={v}" for k, v in params.items())
+            url = f"{url}?{qs}"
+
+        headers = {"Content-Type": "application/json"}
+        body = json.dumps(data).encode() if data else None
+
+        try:
+            req = Request(url, data=body, headers=headers, method=method)
+            with urlopen(req, timeout=5) as resp:
+                return json.loads(resp.read().decode())
+        except URLError as e:
+            logger.warning(f"[platform] Request failed (silent): {e}")
+            return None
+        except Exception as e:
+            logger.warning(f"[platform] Request error (silent): {e}")
+            return None
+
+    def _register(self):
+        return self._request("POST", "/api/sdk/register", {
+            "projectName": self.options["project_name"],
+            "environmentName": self.options["environment_name"],
+            "serviceName": self.options["project_name"],
+            "version": self.options["version"],
+            "branch": self.options["branch"],
+            "commitSha": self.options["commit_sha"],
+            "namespace": self.options["namespace"],
+            "hostname": self.options["hostname"],
+            "dbTypes": self.options["databases"],
+        })
+
+    def _start_heartbeat(self):
+        def heartbeat():
+            while True:
+                time.sleep(15)
+                self._request("POST", "/api/sdk/heartbeat", {
+                    "projectId": self.options["project_name"],
+                    "serviceName": self.options["project_name"],
+                    "timestamp": time.time(),
+                })
+
+        t = threading.Thread(target=heartbeat, daemon=True)
+        t.start()
+
+    # --- Config ---
+    def config(self, key: str) -> Optional[Any]:
+        data = self._request("GET", "/api/config", params={
+            "projectId": self.options["project_name"],
+        })
+        if data and key in data:
+            return data[key]
+        return None
+
+    # --- Storage ---
+    def storage_upload(self, file_path: str, bucket: str):
+        import os as _os
+        size = _os.path.getsize(file_path)
+        return self._request("POST", "/api/storage/upload-url", {
+            "projectId": self.options["project_name"],
+            "bucket": bucket,
+            "originalName": _os.path.basename(file_path),
+            "mimeType": "application/octet-stream",
+            "size": size,
+        })
+
+    # --- Logging ---
+    def log(self, level: str, message: str, metadata: Optional[Dict] = None):
+        self._request("POST", "/api/logs/ingest", {
+            "projectId": self.options["project_name"],
+            "environmentId": self.options["environment_name"],
+            "serviceName": self.options["project_name"],
+            "level": level,
+            "message": message,
+            "metadata": metadata or {},
+        })
+
+    # --- DB Access ---
+    @property
+    def db(self):
+        return self._db_connections
+
+    def shutdown(self):
+        for name, conn in self._db_connections.items():
+            try:
+                conn.disconnect()
+            except Exception:
+                pass
+
+
+platform = PlatformClient()

mpratyush54_sdk-0.6.0/platform_sdk/db/__init__.py

@@ -0,0 +1,5 @@
+from .postgres import PostgresManager
+from .mongo import MongoManager
+from .redis import RedisManager
+
+__all__ = ["PostgresManager", "MongoManager", "RedisManager"]

mpratyush54_sdk-0.6.0/platform_sdk/db/mongo.py

@@ -0,0 +1,32 @@
+import pymongo
+import logging
+
+logger = logging.getLogger('platform')
+
+
+class MongoManager:
+    def __init__(self, config: dict = None):
+        import os as _os
+        self.uri = (config or {}).get("uri") or _os.environ.get(
+            "PLATFORM_MONGO_URI", "mongodb://localhost:27017/platform"
+        )
+        self.client = None
+        self.connected = False
+
+    def connect(self):
+        self.client = pymongo.MongoClient(self.uri, serverSelectionTimeoutMS=5000)
+        self.client.admin.command("ping")
+        self.connected = True
+        logger.info("[platform] MongoDB connected")
+
+    @property
+    def db(self):
+        if self.client:
+            return self.client.get_default_database()
+        return None
+
+    def disconnect(self):
+        if self.client:
+            self.client.close()
+            self.connected = False
+            logger.info("[platform] MongoDB disconnected")

mpratyush54_sdk-0.6.0/platform_sdk/db/postgres.py

@@ -0,0 +1,49 @@
+import psycopg2
+from psycopg2 import pool
+import logging
+
+logger = logging.getLogger('platform')
+
+
+class PostgresManager:
+    def __init__(self, config: dict = None):
+        self.config = config or {
+            "host": os.environ.get("PLATFORM_PG_HOST", "localhost"),
+            "port": int(os.environ.get("PLATFORM_PG_PORT", "5432")),
+            "user": os.environ.get("PLATFORM_PG_USER", "platform"),
+            "password": os.environ.get("PLATFORM_PG_PASSWORD", "platform"),
+            "database": os.environ.get("PLATFORM_PG_DB", "platform"),
+        }
+        import os as _os
+        self._pool = None
+        self.connected = False
+
+    def connect(self):
+        self._pool = pool.ThreadedConnectionPool(
+            minconn=1, maxconn=self.config.get("pool_size", 10), **self.config
+        )
+        conn = self._pool.getconn()
+        conn.close()
+        self._pool.putconn(conn)
+        self.connected = True
+        logger.info("[platform] PostgreSQL connected")
+
+    def execute(self, query: str, params: tuple = None) -> list:
+        if not self._pool:
+            raise RuntimeError("PostgreSQL not connected")
+        conn = self._pool.getconn()
+        try:
+            with conn.cursor() as cur:
+                cur.execute(query, params)
+                if cur.description:
+                    return cur.fetchall()
+                conn.commit()
+                return []
+        finally:
+            self._pool.putconn(conn)
+
+    def disconnect(self):
+        if self._pool:
+            self._pool.closeall()
+            self.connected = False
+            logger.info("[platform] PostgreSQL disconnected")

mpratyush54_sdk-0.6.0/platform_sdk/db/redis.py

@@ -0,0 +1,40 @@
+import redis
+import logging
+
+logger = logging.getLogger('platform')
+
+
+class RedisManager:
+    def __init__(self, config: dict = None):
+        import os as _os
+        self.config = config or {
+            "host": _os.environ.get("PLATFORM_REDIS_HOST", "localhost"),
+            "port": int(_os.environ.get("PLATFORM_REDIS_PORT", "6379")),
+            "password": _os.environ.get("PLATFORM_REDIS_PASSWORD", None),
+        }
+        self.client = None
+        self.connected = False
+
+    def connect(self):
+        self.client = redis.Redis(**self.config, decode_responses=True)
+        self.client.ping()
+        self.connected = True
+        logger.info("[platform] Redis connected")
+
+    def get(self, key: str) -> str:
+        if self.client:
+            return self.client.get(key)
+        return None
+
+    def set(self, key: str, value: str, ttl: int = None):
+        if self.client:
+            if ttl:
+                self.client.setex(key, ttl, value)
+            else:
+                self.client.set(key, value)
+
+    def disconnect(self):
+        if self.client:
+            self.client.close()
+            self.connected = False
+            logger.info("[platform] Redis disconnected")

mpratyush54_sdk-0.6.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mpratyush54_sdk-0.6.0/setup.py

@@ -0,0 +1,24 @@
+import os
+from setuptools import setup, find_packages
+
+setup(
+    name="mpratyush54-sdk",
+    version="0.6.0",
+    description="Platform Python SDK",
+    packages=find_packages(include=['platform_sdk', 'platform_sdk.*']),
+    install_requires=[
+        "psycopg2-binary>=2.9.0",
+        "pymongo>=4.5.0",
+        "redis>=5.0.0",
+    ],
+    author="Platform Team",
+    url="https://github.com/Mpratyush54/server-automation",
+    long_description=open("README.md").read() if os.path.exists("README.md") else "",
+    long_description_content_type="text/markdown",
+    python_requires=">=3.10",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+)

mpratyush54_sdk-0.6.0/tests/test_caps_client.py

@@ -0,0 +1,170 @@
+import pytest
+from unittest.mock import patch, MagicMock, mock_open
+import json
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from platform_sdk import PlatformClient
+
+
+class TestPlatformClient:
+    def setup_method(self):
+        self.client = PlatformClient()
+
+    def test_init_defaults(self):
+        assert self.client.initialized is False
+        assert self.client.options == {}
+        assert self.client._db_connections == {}
+
+    @patch('platform_sdk.PlatformClient._request')
+    @patch('platform_sdk.PlatformClient._start_heartbeat')
+    def test_init_sets_options(self, mock_heartbeat, mock_request):
+        mock_request.return_value = {"id": "reg-1"}
+
+        self.client.init(
+            project_name="test-project",
+            platform_url="http://localhost:3000",
+        )
+
+        assert self.client.initialized is True
+        assert self.client.options["project_name"] == "test-project"
+        assert self.client.options["platform_url"] == "http://localhost:3000"
+        assert self.client.options["environment_name"] == "development"
+        assert self.client.options["version"] == "1.0.0"
+        assert self.client.options["branch"] == "main"
+
+    @patch('platform_sdk.PlatformClient._request')
+    @patch('platform_sdk.PlatformClient._start_heartbeat')
+    def test_init_custom_options(self, mock_heartbeat, mock_request):
+        mock_request.return_value = {}
+
+        self.client.init(
+            project_name="my-app",
+            platform_url="https://platform.example.com/",
+            environment_name="production",
+            version="2.0.0",
+            branch="develop",
+        )
+
+        assert self.client.options["environment_name"] == "production"
+        assert self.client.options["version"] == "2.0.0"
+        assert self.client.options["branch"] == "develop"
+        assert self.client.options["platform_url"] == "https://platform.example.com"
+
+    @patch('platform_sdk.PlatformClient._request')
+    @patch('platform_sdk.PlatformClient._start_heartbeat')
+    def test_init_calls_register(self, mock_heartbeat, mock_request):
+        mock_request.return_value = {"id": "reg-1"}
+
+        self.client.init(
+            project_name="test-project",
+            platform_url="http://localhost:3000",
+        )
+
+        mock_request.assert_called_with("POST", "/api/sdk/register", {
+            "projectName": "test-project",
+            "environmentName": "development",
+            "serviceName": "test-project",
+            "version": "1.0.0",
+            "branch": "main",
+            "commitSha": None,
+            "namespace": None,
+            "hostname": self.client.options["hostname"],
+            "dbTypes": [],
+        })
+
+    def test_request_returns_response(self):
+        with patch('platform_sdk.urlopen') as mock_urlopen:
+            mock_response = MagicMock()
+            mock_response.read.return_value = json.dumps({"key": "value"}).encode()
+            mock_urlopen.return_value.__enter__ = lambda s: mock_response
+            mock_urlopen.return_value.__exit__ = MagicMock(return_value=False)
+
+            self.client.options = {"platform_url": "http://localhost:3000"}
+            result = self.client._request("GET", "/api/test")
+            assert result == {"key": "value"}
+
+    def test_request_returns_none_on_error(self):
+        from urllib.error import URLError
+        with patch('platform_sdk.urlopen') as mock_urlopen:
+            mock_urlopen.side_effect = URLError("Connection refused")
+
+            self.client.options = {"platform_url": "http://localhost:3000"}
+            result = self.client._request("GET", "/api/test")
+            assert result is None
+
+    def test_config_returns_value(self):
+        self.client.options = {"project_name": "test"}
+        with patch.object(self.client, '_request', return_value={"KEY": "val"}):
+            assert self.client.config("KEY") == "val"
+
+    def test_config_returns_none_for_missing_key(self):
+        self.client.options = {"project_name": "test"}
+        with patch.object(self.client, '_request', return_value={"KEY": "val"}):
+            assert self.client.config("MISSING") is None
+
+    def test_log_calls_request(self):
+        self.client.options = {
+            "project_name": "test",
+            "environment_name": "dev",
+        }
+        with patch.object(self.client, '_request') as mock_request:
+            self.client.log("INFO", "Test message", {"extra": "data"})
+            mock_request.assert_called_once_with("POST", "/api/logs/ingest", {
+                "projectId": "test",
+                "environmentId": "dev",
+                "serviceName": "test",
+                "level": "INFO",
+                "message": "Test message",
+                "metadata": {"extra": "data"},
+            })
+
+    def test_log_without_metadata(self):
+        self.client.options = {
+            "project_name": "test",
+            "environment_name": "dev",
+        }
+        with patch.object(self.client, '_request') as mock_request:
+            self.client.log("ERROR", "Error occurred")
+            mock_request.assert_called_once_with("POST", "/api/logs/ingest", {
+                "projectId": "test",
+                "environmentId": "dev",
+                "serviceName": "test",
+                "level": "ERROR",
+                "message": "Error occurred",
+                "metadata": {},
+            })
+
+    def test_db_property(self):
+        assert self.client.db == {}
+
+    def test_shutdown_disconnects_all_dbs(self):
+        mock_pg = MagicMock()
+        mock_mongo = MagicMock()
+        mock_redis = MagicMock()
+        self.client._db_connections = {
+            "postgres": mock_pg,
+            "mongo": mock_mongo,
+            "redis": mock_redis,
+        }
+
+        self.client.shutdown()
+
+        mock_pg.disconnect.assert_called_once()
+        mock_mongo.disconnect.assert_called_once()
+        mock_redis.disconnect.assert_called_once()
+
+    def test_shutdown_handles_disconnect_errors(self):
+        mock_db = MagicMock()
+        mock_db.disconnect.side_effect = Exception("Disconnect failed")
+        self.client._db_connections = {"postgres": mock_db}
+
+        self.client.shutdown()  # Should not raise
+
+
+class TestPlatformClientSingleton:
+    def test_singleton_exists(self):
+        from platform_sdk import platform
+        assert isinstance(platform, PlatformClient)

mpratyush54_sdk-0.6.0/tests/test_integration.py

@@ -0,0 +1,83 @@
+import pytest
+from unittest.mock import patch, MagicMock
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from platform_sdk import PlatformClient
+
+
+class TestPlatformClientIntegration:
+    """Integration-style tests that test multiple components together."""
+
+    @patch('platform_sdk.PlatformClient._start_heartbeat')
+    @patch('platform_sdk.PlatformClient._request')
+    def test_full_init_and_shutdown_flow(self, mock_request, mock_heartbeat):
+        mock_request.return_value = {"id": "reg-1", "projectName": "test"}
+
+        client = PlatformClient()
+        client.init(
+            project_name="integration-test",
+            platform_url="http://localhost:3000",
+            environment_name="staging",
+            version="1.0.0",
+        )
+
+        assert client.initialized is True
+        assert client.options["project_name"] == "integration-test"
+        assert client.options["environment_name"] == "staging"
+
+        # Verify registration was called
+        mock_request.assert_called_with("POST", "/api/sdk/register", {
+            "projectName": "integration-test",
+            "environmentName": "staging",
+            "serviceName": "integration-test",
+            "version": "1.0.0",
+            "branch": "main",
+            "commitSha": None,
+            "namespace": None,
+            "hostname": client.options["hostname"],
+            "dbTypes": [],
+        })
+
+        client.shutdown()
+
+    @patch('platform_sdk.PlatformClient._start_heartbeat')
+    @patch('platform_sdk.PlatformClient._request')
+    def test_config_after_init(self, mock_request, mock_heartbeat):
+        mock_request.return_value = {}
+
+        client = PlatformClient()
+        client.init(
+            project_name="test",
+            platform_url="http://localhost:3000",
+        )
+
+        # Mock config endpoint
+        with patch.object(client, '_request') as mock_config:
+            mock_config.return_value = {"DB_HOST": "localhost", "FEATURE_X": "true"}
+            result = client.config("DB_HOST")
+            assert result == "localhost"
+
+    @patch('platform_sdk.PlatformClient._start_heartbeat')
+    @patch('platform_sdk.PlatformClient._request')
+    def test_logging_after_init(self, mock_request, mock_heartbeat):
+        mock_request.return_value = {}
+
+        client = PlatformClient()
+        client.init(
+            project_name="test",
+            platform_url="http://localhost:3000",
+        )
+
+        with patch.object(client, '_request') as mock_log:
+            client.log("INFO", "Service started")
+            mock_log.assert_called_with("POST", "/api/logs/ingest", {
+                "projectId": "test",
+                "environmentId": "development",
+                "serviceName": "test",
+                "level": "INFO",
+                "message": "Service started",
+                "metadata": {},
+            })

mpratyush54_sdk-0.6.0/tests/test_mongo.py

@@ -0,0 +1,75 @@
+import pytest
+from unittest.mock import patch, MagicMock
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from platform_sdk.db.mongo import MongoManager
+
+
+class TestMongoManager:
+    def test_init_with_config(self):
+        manager = MongoManager({"uri": "mongodb://localhost:27017/test"})
+        assert manager.uri == "mongodb://localhost:27017/test"
+        assert manager.connected is False
+        assert manager.client is None
+
+    def test_init_without_config(self):
+        manager = MongoManager()
+        assert manager.uri == "mongodb://localhost:27017/platform"
+
+    @patch('platform_sdk.db.mongo.pymongo.MongoClient')
+    def test_connect_success(self, mock_client_class):
+        mock_client = MagicMock()
+        mock_client_class.return_value = mock_client
+
+        manager = MongoManager({"uri": "mongodb://localhost:27017/test"})
+        manager.connect()
+
+        assert manager.connected is True
+        mock_client.admin.command.assert_called_once_with("ping")
+
+    @patch('platform_sdk.db.mongo.pymongo.MongoClient')
+    def test_connect_failure(self, mock_client_class):
+        mock_client = MagicMock()
+        mock_client.admin.command.side_effect = Exception("Connection refused")
+        mock_client_class.return_value = mock_client
+
+        manager = MongoManager({"uri": "mongodb://localhost:27017/test"})
+        with pytest.raises(Exception, match="Connection refused"):
+            manager.connect()
+
+        assert manager.connected is False
+
+    def test_db_property_when_not_connected(self):
+        manager = MongoManager()
+        assert manager.db is None
+
+    @patch('platform_sdk.db.mongo.pymongo.MongoClient')
+    def test_db_property_when_connected(self, mock_client_class):
+        mock_client = MagicMock()
+        mock_db = MagicMock()
+        mock_client.get_default_database.return_value = mock_db
+        mock_client_class.return_value = mock_client
+
+        manager = MongoManager({"uri": "mongodb://localhost:27017/test"})
+        manager.connect()
+
+        assert manager.db == mock_db
+
+    @patch('platform_sdk.db.mongo.pymongo.MongoClient')
+    def test_disconnect(self, mock_client_class):
+        mock_client = MagicMock()
+        mock_client_class.return_value = mock_client
+
+        manager = MongoManager({"uri": "mongodb://localhost:27017/test"})
+        manager.connect()
+        manager.disconnect()
+
+        assert manager.connected is False
+        mock_client.close.assert_called_once()
+
+    def test_disconnect_when_not_connected(self):
+        manager = MongoManager()
+        manager.disconnect()  # Should not raise

mpratyush54_sdk-0.6.0/tests/test_postgres.py

@@ -0,0 +1,114 @@
+import pytest
+from unittest.mock import patch, MagicMock
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from platform_sdk.db.postgres import PostgresManager
+
+
+class TestPostgresManager:
+    def test_init_with_config(self):
+        config = {
+            "host": "localhost",
+            "port": 5432,
+            "user": "test",
+            "password": "test",
+            "database": "test_db",
+        }
+        manager = PostgresManager(config)
+        assert manager.config == config
+        assert manager.connected is False
+
+    def test_init_with_empty_config(self):
+        manager = PostgresManager({})
+        assert manager.connected is False
+
+    @patch('platform_sdk.db.postgres.pool.ThreadedConnectionPool')
+    def test_connect_success(self, mock_pool_class):
+        mock_pool = MagicMock()
+        mock_conn = MagicMock()
+        mock_pool.getconn.return_value = mock_conn
+        mock_pool_class.return_value = mock_pool
+
+        manager = PostgresManager({"host": "localhost", "port": 5432})
+        manager.connect()
+
+        assert manager.connected is True
+        mock_pool.getconn.assert_called_once()
+        mock_conn.close.assert_called_once()
+        mock_pool.putconn.assert_called_once_with(mock_conn)
+
+    @patch('platform_sdk.db.postgres.pool.ThreadedConnectionPool')
+    def test_connect_failure(self, mock_pool_class):
+        mock_pool_class.side_effect = Exception("Connection refused")
+
+        manager = PostgresManager({"host": "localhost"})
+        with pytest.raises(Exception, match="Connection refused"):
+            manager.connect()
+
+        assert manager.connected is False
+
+    def test_execute_without_connection(self):
+        manager = PostgresManager({})
+        with pytest.raises(RuntimeError, match="PostgreSQL not connected"):
+            manager.execute("SELECT 1")
+
+    @patch('platform_sdk.db.postgres.pool.ThreadedConnectionPool')
+    def test_execute_query(self, mock_pool_class):
+        mock_pool = MagicMock()
+        mock_conn = MagicMock()
+        mock_cursor = MagicMock()
+        mock_cursor.__enter__ = MagicMock(return_value=mock_cursor)
+        mock_cursor.__exit__ = MagicMock(return_value=False)
+        mock_cursor.description = [("id",)]
+        mock_cursor.fetchall.return_value = [(1,), (2,)]
+        mock_conn.cursor.return_value = mock_cursor
+        mock_pool.getconn.return_value = mock_conn
+        mock_pool_class.return_value = mock_pool
+
+        manager = PostgresManager({})
+        manager._pool = mock_pool
+        manager.connected = True
+
+        result = manager.execute("SELECT id FROM users")
+        assert result == [(1,), (2,)]
+
+    @patch('platform_sdk.db.postgres.pool.ThreadedConnectionPool')
+    def test_execute_mutation(self, mock_pool_class):
+        mock_pool = MagicMock()
+        mock_conn = MagicMock()
+        mock_cursor = MagicMock()
+        mock_cursor.__enter__ = MagicMock(return_value=mock_cursor)
+        mock_cursor.__exit__ = MagicMock(return_value=False)
+        mock_cursor.description = None
+        mock_conn.cursor.return_value = mock_cursor
+        mock_pool.getconn.return_value = mock_conn
+        mock_pool_class.return_value = mock_pool
+
+        manager = PostgresManager({})
+        manager._pool = mock_pool
+        manager.connected = True
+
+        result = manager.execute("INSERT INTO users (name) VALUES (%s)", ("test",))
+        assert result == []
+        mock_conn.commit.assert_called_once()
+
+    @patch('platform_sdk.db.postgres.pool.ThreadedConnectionPool')
+    def test_disconnect(self, mock_pool_class):
+        mock_pool = MagicMock()
+        mock_pool_class.return_value = mock_pool
+
+        manager = PostgresManager({})
+        manager._pool = mock_pool
+        manager.connected = True
+
+        manager.disconnect()
+
+        assert manager.connected is False
+        mock_pool.closeall.assert_called_once()
+
+    def test_disconnect_when_not_connected(self):
+        manager = PostgresManager({})
+        manager.disconnect()  # Should not raise

mpratyush54_sdk-0.6.0/tests/test_redis.py

@@ -0,0 +1,102 @@
+import pytest
+from unittest.mock import patch, MagicMock
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from platform_sdk.db.redis import RedisManager
+
+
+class TestRedisManager:
+    def test_init_with_config(self):
+        config = {"host": "localhost", "port": 6379, "password": None}
+        manager = RedisManager(config)
+        assert manager.config == config
+        assert manager.connected is False
+
+    def test_init_without_config(self):
+        manager = RedisManager()
+        assert manager.connected is False
+
+    @patch('platform_sdk.db.redis.redis.Redis')
+    def test_connect_success(self, mock_redis_class):
+        mock_client = MagicMock()
+        mock_redis_class.return_value = mock_client
+
+        manager = RedisManager({"host": "localhost", "port": 6379})
+        manager.connect()
+
+        assert manager.connected is True
+        mock_client.ping.assert_called_once()
+
+    @patch('platform_sdk.db.redis.redis.Redis')
+    def test_connect_failure(self, mock_redis_class):
+        mock_client = MagicMock()
+        mock_client.ping.side_effect = Exception("Connection refused")
+        mock_redis_class.return_value = mock_client
+
+        manager = RedisManager({"host": "localhost"})
+        with pytest.raises(Exception, match="Connection refused"):
+            manager.connect()
+
+        assert manager.connected is False
+
+    def test_get_when_not_connected(self):
+        manager = RedisManager()
+        assert manager.get("key") is None
+
+    @patch('platform_sdk.db.redis.redis.Redis')
+    def test_get_when_connected(self, mock_redis_class):
+        mock_client = MagicMock()
+        mock_client.get.return_value = "test-value"
+        mock_redis_class.return_value = mock_client
+
+        manager = RedisManager({})
+        manager.connect()
+
+        result = manager.get("test-key")
+        assert result == "test-value"
+        mock_client.get.assert_called_once_with("test-key")
+
+    def test_set_when_not_connected(self):
+        manager = RedisManager()
+        manager.set("key", "value")  # Should not raise
+
+    @patch('platform_sdk.db.redis.redis.Redis')
+    def test_set_when_connected(self, mock_redis_class):
+        mock_client = MagicMock()
+        mock_redis_class.return_value = mock_client
+
+        manager = RedisManager({})
+        manager.connect()
+        manager.set("key", "value")
+
+        mock_client.set.assert_called_once_with("key", "value")
+
+    @patch('platform_sdk.db.redis.redis.Redis')
+    def test_set_with_ttl(self, mock_redis_class):
+        mock_client = MagicMock()
+        mock_redis_class.return_value = mock_client
+
+        manager = RedisManager({})
+        manager.connect()
+        manager.set("key", "value", ttl=3600)
+
+        mock_client.setex.assert_called_once_with("key", 3600, "value")
+
+    @patch('platform_sdk.db.redis.redis.Redis')
+    def test_disconnect(self, mock_redis_class):
+        mock_client = MagicMock()
+        mock_redis_class.return_value = mock_client
+
+        manager = RedisManager({})
+        manager.connect()
+        manager.disconnect()
+
+        assert manager.connected is False
+        mock_client.close.assert_called_once()
+
+    def test_disconnect_when_not_connected(self):
+        manager = RedisManager()
+        manager.disconnect()  # Should not raise