248-sdk 0.1.0__tar.gz

248_sdk-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+.env
+.DS_Store
+.idea/
+.vscode/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.coverage
+.coverage.*
+.coverage.*

248_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: 248-sdk
+Version: 0.1.0
+Summary: Shared SDK for 248 products - MongoDB models, PostgreSQL models, and SmartLead schemas
+Project-URL: Repository, https://github.com/248ai/248-sdk
+Author-email: Wenzo Rithelly <rithellyenzo@gmail.com>
+License: MIT
+Keywords: beanie,mongodb,postgresql,sdk,smartlead,sqlalchemy
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: beanie<3.0.0,>=2.0.1
+Requires-Dist: motor<4.0.0,>=3.3.0
+Requires-Dist: pydantic<3.0.0,>=2.0.0
+Requires-Dist: sqlalchemy<3.0.0,>=2.0.0
+Provides-Extra: all
+Requires-Dist: mypy>=1.8.0; extra == 'all'
+Requires-Dist: psycopg2-binary<3.0.0,>=2.9.0; extra == 'all'
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'all'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'all'
+Requires-Dist: pytest>=8.0.0; extra == 'all'
+Requires-Dist: ruff>=0.2.0; extra == 'all'
+Provides-Extra: asyncpg
+Requires-Dist: asyncpg<1.0.0,>=0.29.0; extra == 'asyncpg'
+Provides-Extra: dev
+Requires-Dist: mypy>=1.8.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.2.0; extra == 'dev'
+Provides-Extra: postgres
+Requires-Dist: psycopg2-binary<3.0.0,>=2.9.0; extra == 'postgres'
+Description-Content-Type: text/markdown
+
+# 248 SDK
+
+Shared SDK for 248 products - MongoDB models, PostgreSQL models, and SmartLead schemas.
+
+## Installation
+
+```bash
+# From Git
+pip install git+https://github.com/248ai/248-sdk.git
+
+# With PostgreSQL support
+pip install "248-sdk[postgres] @ git+https://github.com/248ai/248-sdk.git"
+
+# Local development (editable)
+pip install -e .
+```
+
+## Quick Start
+
+### MongoDB Models
+
+```python
+import asyncio
+from sdk_248 import mongodb
+from sdk_248.models import Campaign, CampaignStatus
+
+async def main():
+    # Initialize MongoDB connection
+    await mongodb.initialize(
+        connection_string="mongodb://localhost:27017",
+        database_name="mydb"
+    )
+
+    # Query campaigns
+    campaigns = await Campaign.find(
+        Campaign.status == CampaignStatus.RUNNING
+    ).to_list()
+
+    for campaign in campaigns:
+        print(f"Campaign: {campaign.name}")
+
+    # Close connection
+    await mongodb.close()
+
+asyncio.run(main())
+```
+
+### PostgreSQL Models
+
+```python
+from sdk_248 import postgres
+from sdk_248.models import Organization
+
+# Initialize PostgreSQL
+postgres.initialize(
+    connection_string="postgresql://user:pass@localhost:5432/db"
+)
+
+# Use sessions
+with postgres.session() as session:
+    orgs = session.query(Organization).all()
+    for org in orgs:
+        print(f"Organization: {org.name}")
+```
+
+### Using Models Without Database
+
+```python
+from sdk_248.models import Lead, CampaignStatus
+
+# Create models for validation/serialization
+lead = Lead(
+    email="test@example.com",
+    first_name="John",
+    last_name="Doe"
+)
+
+# Serialize to dict
+lead_dict = lead.model_dump()
+
+# Use enums
+status = CampaignStatus.RUNNING
+```
+
+## Available Exports
+
+### From `sdk_248`
+- `MongoDBManager`, `mongodb` - MongoDB connection management
+- `PostgresManager`, `postgres`, `Base` - PostgreSQL connection management
+
+### From `sdk_248.models`
+
+#### Enums
+- `CampaignStatus` - Campaign status values
+- `EmailOrchestrator` - Email orchestrator options
+- `AppType` - Application types
+- `NodeType` - Node types for responder actions
+- `ActionRunStatus` - Action run status values
+- `CategoriserStatus` - Categoriser status values
+
+#### MongoDB Models
+- `Campaign` - Main campaign document (Beanie)
+- `Lead` - Lead embedded model
+- `ActionRun` - Action run embedded model
+- `Node` - Responder node model
+
+#### PostgreSQL Models
+- `Organization` - Organization entity
+- `OrganizationStatus` - Organization status enum
+
+### From `sdk_248.schemas`
+- `CampaignSequenceInput` - Campaign sequence configuration
+- `CampaignReplyWebhookSchema` - Reply webhook payload
+- `EmailSentWebhookSchema` - Email sent webhook payload
+- `Organization` - Organization response schema (Pydantic)
+- `OrganizationCreate` - Organization create schema
+- `OrganizationUpdate` - Organization update schema

248_sdk-0.1.0/README.md

@@ -0,0 +1,117 @@
+# 248 SDK
+
+Shared SDK for 248 products - MongoDB models, PostgreSQL models, and SmartLead schemas.
+
+## Installation
+
+```bash
+# From Git
+pip install git+https://github.com/248ai/248-sdk.git
+
+# With PostgreSQL support
+pip install "248-sdk[postgres] @ git+https://github.com/248ai/248-sdk.git"
+
+# Local development (editable)
+pip install -e .
+```
+
+## Quick Start
+
+### MongoDB Models
+
+```python
+import asyncio
+from sdk_248 import mongodb
+from sdk_248.models import Campaign, CampaignStatus
+
+async def main():
+    # Initialize MongoDB connection
+    await mongodb.initialize(
+        connection_string="mongodb://localhost:27017",
+        database_name="mydb"
+    )
+
+    # Query campaigns
+    campaigns = await Campaign.find(
+        Campaign.status == CampaignStatus.RUNNING
+    ).to_list()
+
+    for campaign in campaigns:
+        print(f"Campaign: {campaign.name}")
+
+    # Close connection
+    await mongodb.close()
+
+asyncio.run(main())
+```
+
+### PostgreSQL Models
+
+```python
+from sdk_248 import postgres
+from sdk_248.models import Organization
+
+# Initialize PostgreSQL
+postgres.initialize(
+    connection_string="postgresql://user:pass@localhost:5432/db"
+)
+
+# Use sessions
+with postgres.session() as session:
+    orgs = session.query(Organization).all()
+    for org in orgs:
+        print(f"Organization: {org.name}")
+```
+
+### Using Models Without Database
+
+```python
+from sdk_248.models import Lead, CampaignStatus
+
+# Create models for validation/serialization
+lead = Lead(
+    email="test@example.com",
+    first_name="John",
+    last_name="Doe"
+)
+
+# Serialize to dict
+lead_dict = lead.model_dump()
+
+# Use enums
+status = CampaignStatus.RUNNING
+```
+
+## Available Exports
+
+### From `sdk_248`
+- `MongoDBManager`, `mongodb` - MongoDB connection management
+- `PostgresManager`, `postgres`, `Base` - PostgreSQL connection management
+
+### From `sdk_248.models`
+
+#### Enums
+- `CampaignStatus` - Campaign status values
+- `EmailOrchestrator` - Email orchestrator options
+- `AppType` - Application types
+- `NodeType` - Node types for responder actions
+- `ActionRunStatus` - Action run status values
+- `CategoriserStatus` - Categoriser status values
+
+#### MongoDB Models
+- `Campaign` - Main campaign document (Beanie)
+- `Lead` - Lead embedded model
+- `ActionRun` - Action run embedded model
+- `Node` - Responder node model
+
+#### PostgreSQL Models
+- `Organization` - Organization entity
+- `OrganizationStatus` - Organization status enum
+
+### From `sdk_248.schemas`
+- `CampaignSequenceInput` - Campaign sequence configuration
+- `CampaignReplyWebhookSchema` - Reply webhook payload
+- `EmailSentWebhookSchema` - Email sent webhook payload
+- `Organization` - Organization response schema (Pydantic)
+- `OrganizationCreate` - Organization create schema
+- `OrganizationUpdate` - Organization update schema

248_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,78 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "248-sdk"
+version = "0.1.0"
+description = "Shared SDK for 248 products - MongoDB models, PostgreSQL models, and SmartLead schemas"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [
+    {name = "Wenzo Rithelly", email = "rithellyenzo@gmail.com"}
+]
+requires-python = ">=3.10"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Typing :: Typed",
+]
+keywords = ["sdk", "mongodb", "postgresql", "beanie", "sqlalchemy", "smartlead"]
+
+dependencies = [
+    "pydantic>=2.0.0,<3.0.0",
+    "beanie>=2.0.1,<3.0.0",
+    "motor>=3.3.0,<4.0.0",
+    "sqlalchemy>=2.0.0,<3.0.0",
+]
+
+[project.optional-dependencies]
+postgres = [
+    "psycopg2-binary>=2.9.0,<3.0.0",
+]
+asyncpg = [
+    "asyncpg>=0.29.0,<1.0.0",
+]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+    "pytest-cov>=4.0.0",
+    "mypy>=1.8.0",
+    "ruff>=0.2.0",
+]
+all = [
+    "248-sdk[postgres,dev]",
+]
+
+[project.urls]
+Repository = "https://github.com/248ai/248-sdk"
+
+[tool.hatch.build.targets.wheel]
+packages = ["sdk_248"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/sdk_248",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+warn_return_any = true
+warn_unused_ignores = true
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "W", "B", "Q"]

248_sdk-0.1.0/sdk_248/__init__.py

@@ -0,0 +1,34 @@
+"""248 SDK - Shared models and utilities for 248 products.
+
+Usage:
+    from sdk_248 import mongodb, postgres
+    from sdk_248.models import Campaign, CampaignStatus
+
+    # Initialize MongoDB
+    await mongodb.initialize(
+        connection_string="mongodb://localhost:27017",
+        database_name="mydb"
+    )
+
+    # Use models
+    campaigns = await Campaign.find(
+        Campaign.status == CampaignStatus.RUNNING
+    ).to_list()
+"""
+
+__version__ = "0.1.0"
+
+# Database managers
+from sdk_248.db.mongo import MongoDBManager, mongodb
+from sdk_248.db.postgres import Base, PostgresManager, postgres
+
+__all__ = [
+    # Version
+    "__version__",
+    # Database managers
+    "MongoDBManager",
+    "mongodb",
+    "PostgresManager",
+    "postgres",
+    "Base",
+]

248_sdk-0.1.0/sdk_248/db/__init__.py

@@ -0,0 +1,12 @@
+"""Database connection managers for the SDK."""
+
+from sdk_248.db.mongo import MongoDBManager, mongodb
+from sdk_248.db.postgres import Base, PostgresManager, postgres
+
+__all__ = [
+    "MongoDBManager",
+    "mongodb",
+    "PostgresManager",
+    "postgres",
+    "Base",
+]

248_sdk-0.1.0/sdk_248/db/mongo.py

@@ -0,0 +1,119 @@
+"""MongoDB connection and Beanie initialization for the SDK."""
+
+from typing import List, Optional, Type
+
+from beanie import Document, init_beanie
+from motor.motor_asyncio import AsyncIOMotorClient, AsyncIOMotorDatabase
+
+
+class MongoDBManager:
+    """Manages MongoDB connections and Beanie initialization.
+
+    Usage:
+        # Option 1: Let the SDK create the client
+        from sdk_248 import mongodb, Campaign
+
+        await mongodb.initialize(
+            connection_string="mongodb://user:pass@host:27017",
+            database_name="mydb"
+        )
+
+        # Now use models
+        campaigns = await Campaign.find_all().to_list()
+
+        # Option 2: Use your own client
+        from motor.motor_asyncio import AsyncIOMotorClient
+        from sdk_248 import MongoDBManager, Campaign
+
+        client = AsyncIOMotorClient("mongodb://...")
+        manager = MongoDBManager()
+        await manager.initialize_with_client(
+            client=client,
+            database_name="mydb"
+        )
+    """
+
+    _client: Optional[AsyncIOMotorClient] = None
+    _database: Optional[AsyncIOMotorDatabase] = None
+    _initialized: bool = False
+
+    def _get_document_models(self) -> List[Type[Document]]:
+        """Get all Beanie document models to register.
+
+        Import here to avoid circular imports.
+        """
+        from sdk_248.models.mongo.campaign import Campaign
+
+        return [Campaign]
+
+    async def initialize(
+        self,
+        connection_string: str,
+        database_name: str,
+        document_models: Optional[List[Type[Document]]] = None,
+    ) -> None:
+        """Initialize MongoDB connection and Beanie ODM.
+
+        Args:
+            connection_string: MongoDB connection URI
+            database_name: Name of the database to use
+            document_models: Optional custom list of document models.
+                           If None, uses default SDK models.
+        """
+        self._client = AsyncIOMotorClient(connection_string)
+        self._database = self._client[database_name]
+
+        models = document_models or self._get_document_models()
+        await init_beanie(database=self._database, document_models=models)
+        self._initialized = True
+
+    async def initialize_with_client(
+        self,
+        client: AsyncIOMotorClient,
+        database_name: str,
+        document_models: Optional[List[Type[Document]]] = None,
+    ) -> None:
+        """Initialize Beanie with an existing MongoDB client.
+
+        Args:
+            client: Existing AsyncIOMotorClient instance
+            database_name: Name of the database to use
+            document_models: Optional custom list of document models
+        """
+        self._client = client
+        self._database = client[database_name]
+
+        models = document_models or self._get_document_models()
+        await init_beanie(database=self._database, document_models=models)
+        self._initialized = True
+
+    async def close(self) -> None:
+        """Close the MongoDB connection."""
+        if self._client:
+            self._client.close()
+            self._client = None
+            self._database = None
+            self._initialized = False
+
+    @property
+    def database(self) -> AsyncIOMotorDatabase:
+        """Get the database instance."""
+        if not self._initialized:
+            raise RuntimeError("MongoDB not initialized. Call initialize() first.")
+        return self._database
+
+    @property
+    def client(self) -> AsyncIOMotorClient:
+        """Get the MongoDB client instance."""
+        if not self._initialized:
+            raise RuntimeError("MongoDB not initialized. Call initialize() first.")
+        return self._client
+
+    @property
+    def is_initialized(self) -> bool:
+        """Check if the database is initialized."""
+        return self._initialized
+
+
+# Global instance for convenience
+mongodb = MongoDBManager()

248_sdk-0.1.0/sdk_248/db/postgres.py

@@ -0,0 +1,139 @@
+"""PostgreSQL connection and SQLAlchemy setup for the SDK."""
+
+from contextlib import contextmanager
+from typing import Generator, Optional
+
+from sqlalchemy import create_engine
+from sqlalchemy.engine import Engine
+from sqlalchemy.orm import Session, declarative_base, sessionmaker
+
+# Create the declarative base for all SQLAlchemy models
+Base = declarative_base()
+
+
+class PostgresManager:
+    """Manages PostgreSQL connections and sessions.
+
+    Usage:
+        from sdk_248 import postgres, Organization
+
+        # Initialize PostgreSQL
+        postgres.initialize(
+            connection_string="postgresql://user:pass@host:5432/db"
+        )
+
+        # Use sessions
+        with postgres.session() as session:
+            orgs = session.query(Organization).all()
+
+        # Or create tables
+        postgres.create_tables()
+    """
+
+    _engine: Optional[Engine] = None
+    _session_factory: Optional[sessionmaker] = None
+    _initialized: bool = False
+
+    def initialize(
+        self,
+        connection_string: str,
+        echo: bool = False,
+        pool_size: int = 5,
+        max_overflow: int = 10,
+    ) -> None:
+        """Initialize PostgreSQL connection.
+
+        Args:
+            connection_string: PostgreSQL connection URI
+            echo: If True, log all SQL statements
+            pool_size: Connection pool size
+            max_overflow: Max connections beyond pool_size
+        """
+        self._engine = create_engine(
+            connection_string,
+            echo=echo,
+            pool_size=pool_size,
+            max_overflow=max_overflow,
+        )
+        self._session_factory = sessionmaker(
+            autocommit=False,
+            autoflush=False,
+            bind=self._engine,
+        )
+        self._initialized = True
+
+    def initialize_with_engine(self, engine: Engine) -> None:
+        """Initialize with an existing SQLAlchemy engine.
+
+        Args:
+            engine: Existing SQLAlchemy Engine instance
+        """
+        self._engine = engine
+        self._session_factory = sessionmaker(
+            autocommit=False,
+            autoflush=False,
+            bind=self._engine,
+        )
+        self._initialized = True
+
+    @contextmanager
+    def session(self) -> Generator[Session, None, None]:
+        """Get a database session (context manager).
+
+        Yields:
+            SQLAlchemy Session instance
+
+        Example:
+            with postgres.session() as session:
+                orgs = session.query(Organization).all()
+        """
+        if not self._initialized:
+            raise RuntimeError("PostgreSQL not initialized. Call initialize() first.")
+
+        session = self._session_factory()
+        try:
+            yield session
+            session.commit()
+        except Exception:
+            session.rollback()
+            raise
+        finally:
+            session.close()
+
+    def create_session(self) -> Session:
+        """Create a new session (caller responsible for closing).
+
+        Returns:
+            SQLAlchemy Session instance
+        """
+        if not self._initialized:
+            raise RuntimeError("PostgreSQL not initialized. Call initialize() first.")
+        return self._session_factory()
+
+    @property
+    def engine(self) -> Engine:
+        """Get the SQLAlchemy engine."""
+        if not self._initialized:
+            raise RuntimeError("PostgreSQL not initialized. Call initialize() first.")
+        return self._engine
+
+    def create_tables(self) -> None:
+        """Create all tables defined in models."""
+        if not self._initialized:
+            raise RuntimeError("PostgreSQL not initialized. Call initialize() first.")
+        Base.metadata.create_all(bind=self._engine)
+
+    def drop_tables(self) -> None:
+        """Drop all tables defined in models. Use with caution!"""
+        if not self._initialized:
+            raise RuntimeError("PostgreSQL not initialized. Call initialize() first.")
+        Base.metadata.drop_all(bind=self._engine)
+
+    @property
+    def is_initialized(self) -> bool:
+        """Check if the database is initialized."""
+        return self._initialized
+
+
+# Global instance for convenience
+postgres = PostgresManager()

248_sdk-0.1.0/sdk_248/models/__init__.py

@@ -0,0 +1,30 @@
+"""All data models for the 248 SDK."""
+
+from sdk_248.models.enums import (
+    ActionRunStatus,
+    AppType,
+    CampaignStatus,
+    CategoriserStatus,
+    EmailOrchestrator,
+    NodeType,
+)
+from sdk_248.models.mongo import ActionRun, Campaign, Lead, Node
+from sdk_248.models.postgres import Organization, OrganizationStatus
+
+__all__ = [
+    # Enums
+    "ActionRunStatus",
+    "AppType",
+    "CampaignStatus",
+    "CategoriserStatus",
+    "EmailOrchestrator",
+    "NodeType",
+    # MongoDB models
+    "ActionRun",
+    "Campaign",
+    "Lead",
+    "Node",
+    # PostgreSQL models
+    "Organization",
+    "OrganizationStatus",
+]