airtrain 0.1.0__tar.gz

airtrain-0.1.0/.flake8

@@ -0,0 +1,14 @@
+[flake8]
+max-line-length = 88
+# E203 Whitespace before ':' https://www.flake8rules.com/rules/E203.html
+# W503 Line break occurred before a binary operator https://www.flake8rules.com/rules/W503.html
+# W504 Line break occurred after a binary operator https://www.flake8rules.com/rules/W504.html
+# * Rationale  for E203, W503, W504: 
+#    https://black.readthedocs.io/en/stable/faq.html#why-are-flake8-s-e203-and-w503-violated
+#    https://black.readthedocs.io/en/stable/the_black_code_style/current_style.html#line-breaks-binary-operators
+ignore = E203,W503
+enable-extensions = W504
+per-file-ignores =
+    entities/prompts.py: E501
+    entities/error.py: E501
+    validators/sigma_validator.py: E501

airtrain-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,26 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.x'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build twine
+    - name: Build and publish
+      env:
+        TWINE_USERNAME: __token__
+        TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
+      run: |
+        python -m build
+        python -m twine upload dist/* 

airtrain-0.1.0/.mypy.ini

@@ -0,0 +1,7 @@
+[mypy]
+warn_return_any = True
+warn_unused_configs = True
+disallow_untyped_defs = True
+warn_redundant_casts = True
+strict_equality = True
+warn_unreachable = True

airtrain-0.1.0/.pre-commit-config.yaml

@@ -0,0 +1,29 @@
+default_stages: [pre-commit]
+repos:
+  - repo: https://github.com/ambv/black
+    rev: '24.3.0'
+    hooks:
+      - id: black
+        language_version: python3.10
+  - repo:  https://github.com/pycqa/flake8
+    rev: '6.1.0'
+    hooks:
+      - id: flake8
+  - repo: https://github.com/PyCQA/isort
+    rev: '5.12.0'
+    hooks:
+      - id: isort
+        args: ["--profile", "black"]
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: "v1.9.0"
+    hooks:
+      - id: mypy
+        additional_dependencies: [types-PyYAML, types-requests, types-Markdown]
+  # - repo: local
+  #   hooks:
+  #     - id: pytest-check
+  #       name: pytest-check
+  #       entry: pytest
+  #       language: system
+  #       pass_filenames: false
+  #       always_run: false

airtrain-0.1.0/.vscode/extensions.json

@@ -0,0 +1,7 @@
+{
+  "recommendations": [
+    "ms-python.black-formatter",
+    "ms-python.flake8",
+    "matangover.mypy"
+  ]
+}

airtrain-0.1.0/.vscode/launch.json

@@ -0,0 +1,27 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Debug: Linux",
+            "type": "debugpy",
+            "request": "launch",
+            // "program": "${workspaceFolder}/.venv/bin/uvicorn",
+            "program": "/Users/ddod/miniconda3/envs/dh/bin/uvicorn",
+            "args": [
+                "FastAPIServer.main:app",
+                "--port",
+                "5003",
+                "--reload",
+                // "False"
+            ],
+            "env": {
+                "S2S_FILE_LOG_LEVEL": "TRACE",
+                "S2S_CONSOLE_LOG_LEVEL": "INFO",
+                "S2S_CONSOLE_LOG_COLORIZE": "true"
+            }
+        },
+    ]
+}

airtrain-0.1.0/.vscode/settings.json

@@ -0,0 +1,25 @@
+{
+    "editor.formatOnSave": true,
+    "editor.codeActionsOnSave": {
+        "source.organizeImports": "explicit"
+    },
+    "python.testing.pytestEnabled": true,
+    "isort.check": true,
+    "isort.args": [
+        "--profile",
+        "black"
+    ],
+    "[python]": {
+        "editor.defaultFormatter": "ms-python.black-formatter",
+        "editor.rulers": [
+            88,
+        ]
+    },
+    "flake8.args": [
+        "--show-source",
+        "--config=.flake8"
+    ],
+    "cSpell.words": [],
+    "mypy.runUsingActiveInterpreter": true,
+    "mypy.debugLogging": true,
+}

airtrain-0.1.0/EXPERIMENTS/schema_exps/pydantic_schemas.py

@@ -0,0 +1,37 @@
+from pydantic import BaseModel, create_model
+import json
+from typing import Optional, List
+
+# 1. Define original model
+class User(BaseModel):
+    id: int
+    name: str
+    email: str
+
+# 2. Export schema
+schema = User.model_json_schema()
+with open('schema.json', 'w') as f:
+    json.dump(schema, f)
+
+# 3. Load schema and create model
+with open('schema.json', 'r') as f:
+    loaded_schema = json.load(f)
+
+# 4. Create model using create_model
+fields = {}
+for field_name, field_info in loaded_schema['properties'].items():
+    field_type = {
+        'integer': int,
+        'string': str,
+        'number': float,
+        'boolean': bool
+    }.get(field_info['type'])
+    
+    is_required = field_name in loaded_schema.get('required', [])
+    fields[field_name] = (field_type, ... if is_required else None)
+
+DynamicModel = create_model('AirtrainSchema', **fields)
+
+# Test
+user = DynamicModel(id=1, name="John", email="john@example.com")
+print(user.model_dump())

airtrain-0.1.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.2
+Name: airtrain
+Version: 0.1.0
+Summary: A platform for building and deploying AI agents with structured skills
+Home-page: https://github.com/rosaboyle/airtrain.dev
+Author: Dheeraj Pai
+Author-email: helloworldcmu@gmail.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: python-dotenv>=0.19.0
+Requires-Dist: PyYAML>=5.4.1
+Requires-Dist: firebase-admin>=5.0.0
+Requires-Dist: loguru>=0.5.3
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Airtrain
+
+A powerful platform for building and deploying AI agents with structured skills and capabilities.
+
+## Features
+
+- **Structured Skills**: Build modular AI skills with defined input/output schemas
+- **OpenAI Integration**: Built-in support for OpenAI's GPT models with structured outputs
+- **Credential Management**: Secure handling of API keys and credentials
+- **Type Safety**: Full type hints and Pydantic model support
+- **Async Support**: Both synchronous and asynchronous API implementations
+
+## Installation
+
+```bash
+pip install airtrain
+```
+
+## Quick Start
+
+### Creating a Structured OpenAI Skill
+
+```python
+from airtrain.core.skills import Skill
+from airtrain.core.schemas import InputSchema, OutputSchema
+from pydantic import BaseModel
+from typing import List
+
+# Define your response model
+class PersonInfo(BaseModel):
+    name: str
+    age: int
+    occupation: str
+    skills: List[str]
+
+# Create a skill
+class OpenAIParserSkill(Skill):
+    def process(self, input_data):
+        # Implementation
+        return parsed_response
+
+# Use the skill
+skill = OpenAIParserSkill()
+result = skill.process(input_data)
+```
+
+### Managing Credentials
+
+```python
+from airtrain.core.credentials import OpenAICredentials
+from pathlib import Path
+
+# Load credentials
+creds = OpenAICredentials(
+    api_key="your-api-key",
+    organization_id="optional-org-id"
+)
+
+# Save to environment
+creds.load_to_env()
+```
+
+## Documentation
+
+For detailed documentation, visit [our documentation site](https://airtrain.readthedocs.io/).
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details. 

airtrain-0.1.0/README.md

@@ -0,0 +1,73 @@
+# Airtrain
+
+A powerful platform for building and deploying AI agents with structured skills and capabilities.
+
+## Features
+
+- **Structured Skills**: Build modular AI skills with defined input/output schemas
+- **OpenAI Integration**: Built-in support for OpenAI's GPT models with structured outputs
+- **Credential Management**: Secure handling of API keys and credentials
+- **Type Safety**: Full type hints and Pydantic model support
+- **Async Support**: Both synchronous and asynchronous API implementations
+
+## Installation
+
+```bash
+pip install airtrain
+```
+
+## Quick Start
+
+### Creating a Structured OpenAI Skill
+
+```python
+from airtrain.core.skills import Skill
+from airtrain.core.schemas import InputSchema, OutputSchema
+from pydantic import BaseModel
+from typing import List
+
+# Define your response model
+class PersonInfo(BaseModel):
+    name: str
+    age: int
+    occupation: str
+    skills: List[str]
+
+# Create a skill
+class OpenAIParserSkill(Skill):
+    def process(self, input_data):
+        # Implementation
+        return parsed_response
+
+# Use the skill
+skill = OpenAIParserSkill()
+result = skill.process(input_data)
+```
+
+### Managing Credentials
+
+```python
+from airtrain.core.credentials import OpenAICredentials
+from pathlib import Path
+
+# Load credentials
+creds = OpenAICredentials(
+    api_key="your-api-key",
+    organization_id="optional-org-id"
+)
+
+# Save to environment
+creds.load_to_env()
+```
+
+## Documentation
+
+For detailed documentation, visit [our documentation site](https://airtrain.readthedocs.io/).
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details. 

airtrain-0.1.0/airtrain/core/credentials.py

@@ -0,0 +1,153 @@
+from typing import Dict, List, Optional, Set
+import os
+import json
+from pathlib import Path
+from abc import ABC, abstractmethod
+import dotenv
+from pydantic import BaseModel, Field, SecretStr
+import yaml  # type: ignore
+
+
+class CredentialError(Exception):
+    """Base exception for credential-related errors"""
+
+    pass
+
+
+class CredentialNotFoundError(CredentialError):
+    """Raised when a required credential is not found"""
+
+    pass
+
+
+class CredentialValidationError(CredentialError):
+    """Raised when credentials fail validation"""
+
+    pass
+
+
+class BaseCredentials(BaseModel):
+    """Base class for all credential configurations"""
+
+    _loaded: bool = False
+    _required_credentials: Set[str] = set()
+
+    def load_to_env(self) -> None:
+        """Load credentials into environment variables"""
+        for field_name, field_value in self:
+            if isinstance(field_value, SecretStr):
+                value = field_value.get_secret_value()
+            else:
+                value = str(field_value)
+            os.environ[field_name.upper()] = value
+        self._loaded = True
+
+    @classmethod
+    def from_env(cls) -> "BaseCredentials":
+        """Create credentials instance from environment variables"""
+        field_values = {}
+        for field_name in cls.model_fields:
+            env_key = field_name.upper()
+            if env_value := os.getenv(env_key):
+                field_values[field_name] = env_value
+        return cls(**field_values)
+
+    @classmethod
+    def from_file(cls, file_path: Path) -> "BaseCredentials":
+        """Load credentials from a file (supports .env, .json, .yaml)"""
+        if not file_path.exists():
+            raise FileNotFoundError(f"Credentials file not found: {file_path}")
+
+        if file_path.suffix == ".env":
+            dotenv.load_dotenv(file_path)
+            return cls.from_env()
+
+        elif file_path.suffix == ".json":
+            with open(file_path) as f:
+                data = json.load(f)
+            return cls(**data)
+
+        elif file_path.suffix in {".yaml", ".yml"}:
+            with open(file_path) as f:
+                data = yaml.safe_load(f)
+            return cls(**data)
+
+        else:
+            raise ValueError(f"Unsupported file format: {file_path.suffix}")
+
+    def save_to_file(self, file_path: Path) -> None:
+        """Save credentials to a file"""
+        data = self.model_dump(exclude={"_loaded"})
+
+        # Convert SecretStr to plain strings for saving
+        for key, value in data.items():
+            if isinstance(value, SecretStr):
+                data[key] = value.get_secret_value()
+
+        if file_path.suffix == ".env":
+            with open(file_path, "w") as f:
+                for key, value in data.items():
+                    f.write(f"{key.upper()}={value}\n")
+
+        elif file_path.suffix == ".json":
+            with open(file_path, "w") as f:
+                json.dump(data, f, indent=2)
+
+        elif file_path.suffix in {".yaml", ".yml"}:
+            with open(file_path, "w") as f:
+                yaml.dump(data, f)
+
+        else:
+            raise ValueError(f"Unsupported file format: {file_path.suffix}")
+
+    def validate_credentials(self) -> None:
+        """Validate that all required credentials are present"""
+        missing = []
+        for field_name in self._required_credentials:
+            value = getattr(self, field_name, None)
+            if value is None or (
+                isinstance(value, SecretStr) and not value.get_secret_value()
+            ):
+                missing.append(field_name)
+
+        if missing:
+            raise CredentialValidationError(
+                f"Missing required credentials: {', '.join(missing)}"
+            )
+
+    def clear_from_env(self) -> None:
+        """Remove credentials from environment variables"""
+        for field_name in self.model_fields:
+            env_key = field_name.upper()
+            if env_key in os.environ:
+                del os.environ[env_key]
+        self._loaded = False
+
+
+class OpenAICredentials(BaseCredentials):
+    """OpenAI API credentials"""
+
+    api_key: SecretStr = Field(..., description="OpenAI API key")
+    organization_id: Optional[str] = Field(None, description="OpenAI organization ID")
+
+    _required_credentials = {"api_key"}
+
+
+class AWSCredentials(BaseCredentials):
+    """AWS credentials"""
+
+    aws_access_key_id: SecretStr
+    aws_secret_access_key: SecretStr
+    aws_region: str = "us-east-1"
+    aws_session_token: Optional[SecretStr] = None
+
+    _required_credentials = {"aws_access_key_id", "aws_secret_access_key"}
+
+
+class GoogleCloudCredentials(BaseCredentials):
+    """Google Cloud credentials"""
+
+    project_id: str
+    service_account_key: SecretStr
+
+    _required_credentials = {"project_id", "service_account_key"}