wizelit-sdk 0.1.23__py3-none-any.whl

wizelit_sdk/database.py

@@ -0,0 +1,148 @@
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import (
+    create_async_engine,
+    async_sessionmaker,
+    AsyncSession,
+    AsyncEngine
+)
+from contextlib import asynccontextmanager
+from typing import AsyncGenerator, Optional
+import logging
+import os
+
+from wizelit_sdk.models.base import BaseModel
+
+logger = logging.getLogger(__name__)
+
+class DatabaseManager:
+    """Singleton database manager with connection pooling."""
+
+    DATABASE_URL: str = ""
+    POOL_SIZE: int = 5
+    MAX_OVERFLOW: int = 10
+    POOL_TIMEOUT: int = 30
+    POOL_RECYCLE: int = 3600
+    ECHO_SQL: bool = False
+
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(
+        self,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        host: Optional[str] = None,
+        port: Optional[str] = None,
+        database: Optional[str] = None,
+    ):
+        if self._initialized:
+            return
+
+        # Use provided values or fall back to environment variables
+        USERNAME = username or os.getenv("POSTGRES_USER")
+        PASSWORD = password or os.getenv("POSTGRES_PASSWORD")
+        HOST = host or os.getenv("POSTGRES_HOST")
+        PORT = port or os.getenv("POSTGRES_PORT")
+        DATABASE = database or os.getenv("POSTGRES_DB")
+        self.DATABASE_URL = f"postgresql+asyncpg://{USERNAME}:{PASSWORD}@{HOST}:{PORT}/{DATABASE}"
+
+        # Create async engine
+        self.engine: AsyncEngine = create_async_engine(
+            self.DATABASE_URL,
+            pool_size=self.POOL_SIZE,
+            max_overflow=self.MAX_OVERFLOW,
+            pool_timeout=self.POOL_TIMEOUT,
+            pool_recycle=self.POOL_RECYCLE,
+            echo=self.ECHO_SQL,
+            pool_pre_ping=True,
+        )
+
+        # Create async session factory
+        self.async_session_factory = async_sessionmaker(
+            self.engine,
+            class_=AsyncSession,
+            expire_on_commit=False,
+            autoflush=False,
+            autocommit=False,
+        )
+
+        self._initialized = True
+        logger.info("Database manager initialized")
+
+    async def init_db(self, drop_existing: bool = False):
+        """
+        Initialize database tables.
+
+        Args:
+            drop_existing: If True, drops all existing tables before creating
+        """
+        try:
+            async with self.engine.begin() as conn:
+                if drop_existing:
+                    logger.warning("Dropping all existing tables")
+                    await conn.run_sync(BaseModel.metadata.drop_all)
+
+                await conn.run_sync(BaseModel.metadata.create_all)
+
+            logger.info("Database tables initialized successfully")
+
+        except Exception as e:
+            logger.error(f"Failed to initialize database: {e}")
+            raise
+
+    @asynccontextmanager
+    async def get_session(self) -> AsyncGenerator[AsyncSession, None]:
+        """
+        Async context manager for database sessions.
+
+        Usage:
+            async with db_manager.get_session() as session:
+                user = await session.get(User, user_id)
+                await session.commit()
+        """
+        session = self.async_session_factory()
+        try:
+            yield session
+            await session.commit()
+        except Exception as e:
+            await session.rollback()
+            logger.error(f"Session error: {e}")
+            raise
+        finally:
+            await session.close()
+
+    async def get_db(self) -> AsyncGenerator[AsyncSession, None]:
+        """
+        Dependency injection for FastAPI/similar frameworks.
+
+        Usage:
+            @app.get("/users")
+            async def get_users(db: AsyncSession = Depends(db_manager.get_db)):
+                result = await db.execute(select(User))
+                return result.scalars().all()
+        """
+        session = self.async_session_factory()
+        try:
+            yield session
+        finally:
+            await session.close()
+
+    async def close(self):
+        """Dispose of the engine and close all connections."""
+        await self.engine.dispose()
+        logger.info("Database connections closed")
+
+    async def health_check(self) -> bool:
+        """Check if database connection is healthy."""
+        try:
+            async with self.get_session() as session:
+                await session.execute(text("SELECT 1"))
+            return True
+        except Exception as e:
+            logger.error(f"Health check failed: {e}")
+            return False

wizelit_sdk/models/__init__.py

@@ -0,0 +1,4 @@
+from .base import BaseModel
+from .job import JobModel, JobLogModel, JobStatus
+
+__all__ = ["BaseModel", "JobModel", "JobLogModel", "JobStatus"]

wizelit_sdk/models/base.py

@@ -0,0 +1,25 @@
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column
+from sqlalchemy.dialects.postgresql import UUID
+import uuid
+from datetime import datetime
+
+Base = declarative_base()
+
+class TimestampMixin:
+    """Mixin for models that need timestamp functionality."""
+
+    @staticmethod
+    def get_timestamp():
+        return datetime.utcnow().isoformat()
+
+
+class BaseModel(Base):
+    """Abstract base model with common functionality."""
+    __abstract__ = True
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+
+    def to_dict(self):
+        """Convert model to dictionary."""
+        return {c.name: getattr(self, c.name) for c in self.__table__.columns}

wizelit_sdk/models/job.py

@@ -0,0 +1,72 @@
+"""
+Job and JobLog models for persistent storage of job execution data.
+"""
+from sqlalchemy import Column, String, Text, DateTime, Integer, ForeignKey, Index
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.orm import relationship
+from datetime import datetime
+import enum
+
+from wizelit_sdk.models.base import BaseModel
+
+
+
+class JobStatus(str, enum.Enum):
+    """Enumeration of possible job statuses."""
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+class JobModel(BaseModel):
+    """
+    Persistent storage for job execution data.
+    Tracks status, results, and errors for long-running jobs.
+    """
+    __tablename__ = "jobs"
+
+    id = Column(String(64), primary_key=True)  # JOB-xxxxx
+    status = Column(String(20), default=JobStatus.RUNNING.value, nullable=False)
+    result = Column(JSONB, nullable=True)  # JSON result for completed jobs
+    error = Column(Text, nullable=True)  # Error message for failed jobs
+    created_at = Column(DateTime, default=datetime.utcnow, nullable=False)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False)
+
+    # Relationship to logs
+    logs = relationship("JobLogModel", back_populates="job", cascade="all, delete-orphan")
+
+    # Index for faster queries
+    __table_args__ = (
+        Index('idx_job_status', 'status'),
+        Index('idx_job_created_at', 'created_at'),
+    )
+
+    def __repr__(self):
+        return f"<JobModel(id={self.id}, status={self.status})>"
+
+
+class JobLogModel(BaseModel):
+    """
+    Persistent storage for individual job log entries.
+    Captures timestamped log messages with severity levels.
+    """
+    __tablename__ = "job_logs"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    job_id = Column(String(64), ForeignKey("jobs.id", ondelete="CASCADE"), nullable=False)
+    message = Column(Text, nullable=False)
+    level = Column(String(20), nullable=False)  # INFO, ERROR, WARNING, DEBUG
+    timestamp = Column(DateTime, default=datetime.utcnow, nullable=False)
+
+    # Relationship to job
+    job = relationship("JobModel", back_populates="logs")
+
+    # Indexes for faster queries
+    __table_args__ = (
+        Index('idx_job_log_job_id', 'job_id'),
+        Index('idx_job_log_timestamp', 'timestamp'),
+        Index('idx_job_log_job_id_timestamp', 'job_id', 'timestamp'),
+    )
+
+    def __repr__(self):
+        return f"<JobLogModel(id={self.id}, job_id={self.job_id}, level={self.level})>"

wizelit_sdk-0.1.23.dist-info/METADATA

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: wizelit-sdk
+Version: 0.1.23
+Summary: Wizelit Agent Wrapper - Internal utility package
+Author-email: Your Name <your.email@company.com>
+Requires-Python: >=3.10
+Requires-Dist: asyncpg>=0.26.0
+Requires-Dist: fastmcp>=0.1.0
+Requires-Dist: redis>=4.5.0
+Requires-Dist: sqlalchemy>=1.4
+Requires-Dist: typing-extensions>=4.0.0
+Provides-Extra: dev
+Requires-Dist: black>=22.0.0; extra == 'dev'
+Requires-Dist: build>=1.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: streaming
+Requires-Dist: redis>=4.5.0; extra == 'streaming'
+Description-Content-Type: text/markdown
+
+# wizelit-sdk
+
+Internal utility package for Wizelit Agent operations.
+
+## Installation
+
+### Install from Git Repository
+
+```bash
+# Install latest version from main branch
+uv pip install git+https://github.com/your-org/wizelit-sdk.git
+
+# Install specific version
+uv pip install git+https://github.com/your-org/wizelit-sdk.git@v0.1.0
+
+# Install with SSH (Recommended for Private Repos)
+uv pip install git+ssh://git@github.com/your-org/wizelit-sdk.git@v0.1.0
+```
+
+### Add to pyproject.toml
+
+```toml
+[project]
+dependencies = [
+    "wizelit-sdk @ git+ssh://git@github.com/your-org/wizelit-sdk.git@v0.1.0"
+]
+```
+
+## Usage
+
+```python
+from wizelit_agent_wrapper import your_module
+
+# Use the wrapper
+result = your_module.function()
+```
+
+## Development
+
+### Setup Development Environment
+
+```bash
+# Clone repository
+git clone https://github.com/your-org/wizelit-sdk.git
+cd wizelit-sdk
+
+# Set up environment
+make setup
+
+# Activate virtual environment
+source .venv/bin/activate  # Windows: .venv\Scripts\activate
+
+# Install in development mode
+make install-dev
+```
+
+### Available Make Commands
+
+```bash
+make setup          # Set up development environment
+make install-dev    # Install in development mode
+make test           # Run tests
+make format         # Format code with black
+make lint           # Lint code with ruff
+make check          # Run tests and linting
+make clean          # Clean build artifacts
+make build          # Build package
+make release        # Create new release (interactive)
+make tag VERSION=x.x.x  # Create specific version tag
+make push           # Push code and tags
+make version        # Show current version
+make versions       # List all available versions
+```
+
+## Contributing
+
+1. Create a feature branch
+2. Make your changes
+3. Run tests and linting: `make check`
+4. Commit your changes
+5. Push and create a pull request
+
+## Versioning
+
+We use [Semantic Versioning](https://semver.org/):
+- **MAJOR** version for incompatible API changes
+- **MINOR** version for new functionality (backward compatible)
+- **PATCH** version for bug fixes
+
+See [CHANGELOG.md](CHANGELOG.md) for version history.
+

wizelit_sdk-0.1.23.dist-info/RECORD

@@ -0,0 +1,13 @@
+wizelit_sdk/__init__.py,sha256=6UyHRL8Wu0CAWHIErlmDZFxqI_BZwsco_DWnoMr_H6A,485
+wizelit_sdk/database.py,sha256=39Vu5A8CV7u7ItIwRgrkAugD9UqNbG5vQrCsMOgTamc,4631
+wizelit_sdk/agent_wrapper/__init__.py,sha256=q4xsoiAyI_KM9TSL9rFfxPzGrONJt3GF6MlEx6vDkis,321
+wizelit_sdk/agent_wrapper/agent_wrapper.py,sha256=r1N47KT4Sh6Gudt6ZEFNXvDDD8g4kOkuwTm19K9Np9c,22644
+wizelit_sdk/agent_wrapper/job.py,sha256=Vvmm6eTX1cbXpFuwPMLaom6hEgdk3ovitnaj9d9p02o,13804
+wizelit_sdk/agent_wrapper/streaming.py,sha256=f0VV3IzGAlfQY_cw2OHgxWjvM16Hs42_b700EUX2QpY,6633
+wizelit_sdk/agent_wrapper/utils.py,sha256=OUihj3Kk6uI0y7bDr_L_YQs33vSK0GAJRl0c4km4DNs,951
+wizelit_sdk/models/__init__.py,sha256=UB7nfHoE6hGcjfzy7w8AmuKVmYrTg9wIgGjG8GWziJ0,143
+wizelit_sdk/models/base.py,sha256=aEPGMZVczKnlWz4Ps99e_xI5TcuSV3DxCigRMU5BnhE,704
+wizelit_sdk/models/job.py,sha256=P68Vb1k77Z_Tha4dE0GzrLPa0LJrnMCxyYMENZyD7Kc,2480
+wizelit_sdk-0.1.23.dist-info/METADATA,sha256=ta0J_LwnCa4NGBO2q-v0c23_G-b-SfK6Okhhzr-3zjM,2778
+wizelit_sdk-0.1.23.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+wizelit_sdk-0.1.23.dist-info/RECORD,,

wizelit_sdk-0.1.23.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any