airtrain 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

airtrain/cli/main.py

@@ -0,0 +1,120 @@
+import click
+from typing import Optional
+from airtrain.integrations.openai.skills import OpenAIChatSkill, OpenAIInput
+from airtrain.integrations.anthropic.skills import AnthropicChatSkill, AnthropicInput
+import os
+from dotenv import load_dotenv
+import sys
+from .builder import build
+
+# Load environment variables
+load_dotenv()
+
+
+def initialize_chat(provider: str = "openai"):
+    """Initialize chat skill based on provider"""
+    if provider == "openai":
+        return OpenAIChatSkill()
+    elif provider == "anthropic":
+        return AnthropicChatSkill()
+    else:
+        raise ValueError(f"Unsupported provider: {provider}")
+
+
+@click.group()
+def cli():
+    """Airtrain CLI - Your AI Agent Building Assistant"""
+    pass
+
+
+@cli.command()
+@click.option(
+    "--provider",
+    type=click.Choice(["openai", "anthropic"]),
+    default="openai",
+    help="The AI provider to use",
+)
+@click.option(
+    "--temperature",
+    type=float,
+    default=0.7,
+    help="Temperature for response generation (0.0-1.0)",
+)
+@click.option(
+    "--system-prompt",
+    type=str,
+    default="You are a helpful AI assistant that helps users build their own AI agents. Be helpful and provide clear explanations.",
+    help="System prompt to guide the model",
+)
+def chat(provider: str, temperature: float, system_prompt: str):
+    """Start an interactive chat session with Airtrain"""
+    try:
+        skill = initialize_chat(provider)
+
+        click.echo(f"\nWelcome to Airtrain! Using {provider.upper()} as the provider.")
+        click.echo("Type 'exit' to end the conversation.")
+        click.echo("Type 'clear' to clear the conversation history.\n")
+
+        conversation_history = []
+
+        while True:
+            user_input = click.prompt("You", type=str)
+
+            if user_input.lower() == "exit":
+                click.echo("\nGoodbye! Have a great day!")
+                break
+
+            if user_input.lower() == "clear":
+                conversation_history = []
+                click.echo("\nConversation history cleared!")
+                continue
+
+            try:
+                if provider == "openai":
+                    input_data = OpenAIInput(
+                        user_input=user_input,
+                        system_prompt=system_prompt,
+                        conversation_history=conversation_history,
+                        model="gpt-4o",
+                        temperature=temperature,
+                    )
+                else:
+                    input_data = AnthropicInput(
+                        user_input=user_input,
+                        system_prompt=system_prompt,
+                        conversation_history=conversation_history,
+                        model="claude-3-opus-20240229",
+                        temperature=temperature,
+                    )
+
+                result = skill.process(input_data)
+
+                # Update conversation history
+                conversation_history.extend(
+                    [
+                        {"role": "user", "content": user_input},
+                        {"role": "assistant", "content": result.response},
+                    ]
+                )
+
+                click.echo(f"\nAirtrain: {result.response}\n")
+
+            except Exception as e:
+                click.echo(f"\nError: {str(e)}\n")
+
+    except Exception as e:
+        click.echo(f"Failed to initialize chat: {str(e)}")
+        sys.exit(1)
+
+
+# Add to existing cli group
+cli.add_command(build)
+
+
+def main():
+    """Main entry point for the CLI"""
+    cli()
+
+
+if __name__ == "__main__":
+    main()

airtrain/contrib/__init__.py

@@ -0,0 +1,29 @@
+"""Airtrain contrib package for community contributions"""
+
+from .travel.agents import (
+    TravelAgentBase,
+    ClothingAgent,
+    HikingAgent,
+    InternetConnectivityAgent,
+    FoodRecommendationAgent,
+    PersonalizedRecommendationAgent,
+)
+from .travel.models import (
+    ClothingRecommendation,
+    HikingOption,
+    InternetAvailability,
+    FoodOption,
+)
+
+__all__ = [
+    "TravelAgentBase",
+    "ClothingAgent",
+    "HikingAgent",
+    "InternetConnectivityAgent",
+    "FoodRecommendationAgent",
+    "PersonalizedRecommendationAgent",
+    "ClothingRecommendation",
+    "HikingOption",
+    "InternetAvailability",
+    "FoodOption",
+]

airtrain/contrib/travel/__init__.py

@@ -0,0 +1,35 @@
+"""Travel related agents and models"""
+
+from .agents import (
+    TravelAgentBase,
+    ClothingAgent,
+    HikingAgent,
+    InternetAgent,
+    FoodAgent,
+    PersonalizedAgent,
+)
+from .models import (
+    ClothingRecommendation,
+    HikingOption,
+    InternetAvailability,
+    FoodOption,
+)
+from .agentlib.verification_agent import UserVerificationAgent
+from .modellib.verification import UserTravelInfo, TravelCompanion, HealthCondition
+
+__all__ = [
+    "TravelAgentBase",
+    "ClothingAgent",
+    "HikingAgent",
+    "InternetConnectivityAgent",
+    "FoodRecommendationAgent",
+    "PersonalizedRecommendationAgent",
+    "ClothingRecommendation",
+    "HikingOption",
+    "InternetAvailability",
+    "FoodOption",
+    "UserVerificationAgent",
+    "UserTravelInfo",
+    "TravelCompanion",
+    "HealthCondition",
+]

airtrain/contrib/travel/agents.py

@@ -0,0 +1,243 @@
+from typing import Optional, List, Any
+from airtrain.core.skills import Skill, ProcessingError
+from airtrain.integrations.openai.skills import OpenAIParserSkill, OpenAIParserInput
+from .models import (
+    ClothingRecommendation,
+    HikingOption,
+    InternetAvailability,
+    FoodOption,
+    PersonalizedRecommendation,
+)
+
+
+class TravelAgentBase(OpenAIParserSkill):
+    def __init__(self, credentials=None):
+        super().__init__(credentials)
+        self.model = "gpt-4o"
+        self.temperature = 0.0
+
+
+class ClothingAgent(TravelAgentBase):
+    """Agent for clothing recommendations"""
+
+    def get_recommendations(
+        self, location: str, duration: int, activities: List[str], season: str
+    ) -> ClothingRecommendation:
+        prompt = f"""
+        Provide clothing recommendations for a {duration}-day trip to {location} during {season}.
+        Activities planned: {', '.join(activities)}.
+        Include essential items, weather-specific clothing, and cultural considerations.
+        """
+
+        input_data = OpenAIParserInput(
+            user_input=prompt,
+            system_prompt="You are a travel clothing expert. Provide detailed packing recommendations.",
+            response_model=ClothingRecommendation,
+            model=self.model,
+            temperature=self.temperature,
+        )
+
+        result = self.process(input_data)
+        return result.parsed_response
+
+
+class HikingAgent(TravelAgentBase):
+    """Agent for hiking recommendations"""
+
+    def get_hiking_options(
+        self, location: str, difficulty: str, duration_preference: float
+    ) -> List[HikingOption]:
+        prompt = f"""
+        Find hiking trails in {location} that match:
+        - Difficulty level: {difficulty}
+        - Preferred duration: around {duration_preference} hours
+        Provide detailed trail information and safety tips.
+        """
+
+        input_data = OpenAIParserInput(
+            user_input=prompt,
+            system_prompt="You are a hiking expert. Recommend suitable trails with safety considerations.",
+            response_model=List[HikingOption],
+            model=self.model,
+        )
+
+        result = self.process(input_data)
+        return result.parsed_response
+
+
+class InternetAgent(TravelAgentBase):
+    """Agent for internet availability information"""
+
+    def get_connectivity_info(
+        self,
+        location: str,
+        duration: int,
+        work_requirements: Optional[List[str]] = None,
+    ) -> InternetAvailability:
+        prompt = f"""
+        Provide detailed internet connectivity information for {location} for a {duration}-day stay.
+        {f'Work requirements: {", ".join(work_requirements)}' if work_requirements else ''}
+        Include public WiFi spots, recommended providers, and connectivity tips.
+        """
+
+        input_data = OpenAIParserInput(
+            user_input=prompt,
+            system_prompt="You are a connectivity expert. Provide detailed internet availability information.",
+            response_model=InternetAvailability,
+            model=self.model,
+            temperature=self.temperature,
+        )
+
+        result = self.process(input_data)
+        return result.parsed_response
+
+
+class FoodAgent(TravelAgentBase):
+    """Agent for food recommendations"""
+
+    def get_food_recommendations(
+        self,
+        location: str,
+        dietary_restrictions: Optional[List[str]] = None,
+        preferences: Optional[List[str]] = None,
+        budget_level: str = "medium",
+    ) -> FoodOption:
+        prompt = f"""
+        Provide food recommendations for {location}.
+        {f'Dietary restrictions: {", ".join(dietary_restrictions)}' if dietary_restrictions else ''}
+        {f'Food preferences: {", ".join(preferences)}' if preferences else ''}
+        Budget level: {budget_level}
+        Include local specialties, restaurant recommendations, and food safety tips.
+        """
+
+        input_data = OpenAIParserInput(
+            user_input=prompt,
+            system_prompt="You are a culinary expert. Provide detailed food recommendations.",
+            response_model=FoodOption,
+            model=self.model,
+            temperature=self.temperature,
+        )
+
+        result = self.process(input_data)
+        return result.parsed_response
+
+
+class PersonalizedAgent(TravelAgentBase):
+    """Agent for personalized travel recommendations"""
+
+    def get_personalized_recommendations(
+        self,
+        location: str,
+        duration: int,
+        interests: List[str],
+        budget_level: str,
+        travel_style: str,
+        previous_destinations: Optional[List[str]] = None,
+    ) -> PersonalizedRecommendation:
+        prompt = f"""
+        Create personalized travel recommendations for {location} for {duration} days.
+        Interests: {', '.join(interests)}
+        Travel style: {travel_style}
+        Budget level: {budget_level}
+        {f'Previous destinations: {", ".join(previous_destinations)}' if previous_destinations else ''}
+        Include hidden gems, local events, and a custom itinerary.
+        """
+
+        input_data = OpenAIParserInput(
+            user_input=prompt,
+            system_prompt="You are a personal travel consultant. Provide tailored recommendations.",
+            response_model=PersonalizedRecommendation,
+            model=self.model,
+            temperature=self.temperature,
+        )
+
+        result = self.process(input_data)
+        return result.parsed_response
+
+
+# Similar pattern for other agents...
+
+if __name__ == "__main__":
+    # Initialize all agents
+    clothing_agent = ClothingAgent()
+    hiking_agent = HikingAgent()
+    internet_agent = InternetAgent()
+    food_agent = FoodAgent()
+    personalized_agent = PersonalizedAgent()
+
+    # Example location and common parameters
+    location = "Kyoto, Japan"
+    duration = 7
+    season = "spring"
+
+    try:
+        # Get clothing recommendations
+        clothing_result = clothing_agent.get_recommendations(
+            location=location,
+            duration=duration,
+            activities=["hiking", "temple visits", "city walking", "photography"],
+            season=season,
+        )
+        print("\n=== Clothing Recommendations ===")
+        print(f"Essential items: {', '.join(clothing_result.essential_items)}")
+        print(f"Weather specific: {', '.join(clothing_result.weather_specific)}")
+        print(
+            f"Cultural considerations: {', '.join(clothing_result.cultural_considerations)}"
+        )
+
+        # Get hiking options
+        hiking_result = hiking_agent.get_hiking_options(
+            location=location, difficulty="moderate", duration_preference=4.0
+        )
+        print("\n=== Hiking Options ===")
+        for trail in hiking_result:
+            print(f"\nTrail: {trail.trail_name}")
+            print(f"Difficulty: {trail.difficulty}")
+            print(f"Duration: {trail.duration_hours} hours")
+            print(f"Distance: {trail.distance_km} km")
+
+        # Get internet availability
+        internet_result = internet_agent.get_connectivity_info(
+            location=location,
+            duration=duration,
+            work_requirements=["video calls", "cloud storage access"],
+        )
+        print("\n=== Internet Availability ===")
+        print(f"General availability: {internet_result.general_availability}")
+        print(f"Average speed: {internet_result.average_speed_mbps} Mbps")
+        print(
+            f"Recommended providers: {', '.join(internet_result.recommended_providers)}"
+        )
+
+        # Get food recommendations
+        food_result = food_agent.get_food_recommendations(
+            location=location,
+            dietary_restrictions=["vegetarian"],
+            preferences=["traditional", "local specialties"],
+            budget_level="medium",
+        )
+        print("\n=== Food Recommendations ===")
+        print("Local specialties:", ", ".join(food_result.local_specialties))
+        print("Must-try dishes:", ", ".join(food_result.must_try_dishes))
+        for restaurant in food_result.recommended_restaurants[:3]:  # Show top 3
+            print(f"Restaurant: {restaurant['name']} - {restaurant['type']}")
+
+        # Get personalized recommendations
+        personal_result = personalized_agent.get_personalized_recommendations(
+            location=location,
+            duration=duration,
+            interests=["photography", "culture", "nature", "food"],
+            budget_level="medium",
+            travel_style="balanced",
+            previous_destinations=["Tokyo", "Seoul"],
+        )
+        print("\n=== Personalized Recommendations ===")
+        print("Hidden gems:", ", ".join(personal_result.hidden_gems))
+        print("\nCustom Itinerary:")
+        for day in personal_result.custom_itinerary:
+            print(f"Day {day['day']}: {day['activities']}")
+
+    except ProcessingError as e:
+        print(f"Error processing travel recommendations: {str(e)}")
+    except Exception as e:
+        print(f"Unexpected error: {str(e)}")

airtrain/contrib/travel/models.py

@@ -0,0 +1,59 @@
+from typing import List, Optional, Dict, Any
+from pydantic import BaseModel, Field, validator
+
+
+class ClothingRecommendation(BaseModel):
+    """Model for clothing recommendations"""
+
+    essential_items: List[str]
+    weather_specific: List[str]
+    activity_specific: List[str]
+    cultural_considerations: List[str]
+    packing_tips: List[str]
+
+
+class HikingOption(BaseModel):
+    """Model for hiking recommendations"""
+
+    trail_name: str
+    difficulty: str
+    duration_hours: float
+    distance_km: float
+    elevation_gain_m: float
+    best_season: List[str]
+    required_gear: List[str]
+    safety_tips: List[str]
+    highlights: List[str]
+
+
+class InternetAvailability(BaseModel):
+    """Model for internet availability information"""
+
+    general_availability: str
+    average_speed_mbps: float
+    public_wifi_spots: List[str]
+    recommended_providers: List[str]
+    connectivity_tips: List[str]
+    offline_alternatives: List[str]
+
+
+class FoodOption(BaseModel):
+    """Model for food recommendations"""
+
+    local_specialties: List[str]
+    recommended_restaurants: List[Dict[str, str]]
+    dietary_considerations: List[str]
+    food_safety_tips: List[str]
+    price_ranges: Dict[str, str]
+    must_try_dishes: List[str]
+
+
+class PersonalizedRecommendation(BaseModel):
+    """Model for personalized recommendations"""
+
+    activities: List[Dict[str, str]]
+    hidden_gems: List[str]
+    local_events: List[Dict[str, str]]
+    custom_itinerary: List[Dict[str, Any]]
+    safety_tips: List[str]
+    budget_recommendations: Dict[str, str]

airtrain/core/__init__.py

@@ -0,0 +1,7 @@
+"""Core modules for Airtrain"""
+
+from .skills import Skill, ProcessingError
+from .schemas import InputSchema, OutputSchema
+from .credentials import BaseCredentials
+
+__all__ = ["Skill", "ProcessingError", "InputSchema", "OutputSchema", "BaseCredentials"]

airtrain/core/credentials.py

@@ -0,0 +1,171 @@
+from typing import Dict, List, Optional, Set, Union
+import os
+import json
+from pathlib import Path
+from abc import ABC, abstractmethod
+import dotenv
+from pydantic import BaseModel, Field, SecretStr
+import yaml
+
+
+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: str | Path) -> "BaseCredentials":
+        """Load credentials from a file (supports .env, .json, .yaml).
+
+        Args:
+            file_path: Path to load credentials from. Can be a string or Path object.
+                Supported formats: .env, .json, .yaml/.yml
+
+        Returns:
+            BaseCredentials: Initialized credentials object
+
+        Raises:
+            FileNotFoundError: If the credentials file does not exist
+            ValueError: If the file format is not supported
+        """
+        # Convert to Path object if string
+        if isinstance(file_path, str):
+            file_path = Path(file_path)
+
+        if not file_path.exists():
+            raise FileNotFoundError(f"Credentials file not found: {file_path}")
+
+        # Get file extension, default to .env if none provided
+        suffix = file_path.suffix
+        if not suffix:
+            # Try to find a file with the same name but different extension
+            for ext in [".env", ".json", ".yaml", ".yml"]:
+                potential_path = file_path.with_suffix(ext)
+                if potential_path.exists():
+                    file_path = potential_path
+                    suffix = ext
+                    break
+            # If no file was found, default to .env
+            if not suffix:
+                file_path = file_path.with_suffix(".env")
+                suffix = ".env"
+
+        if suffix == ".env":
+            dotenv.load_dotenv(file_path)
+            return cls.from_env()
+
+        elif suffix == ".json":
+            with open(file_path) as f:
+                data = json.load(f)
+            return cls(**data)
+
+        elif 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: {suffix}")
+
+    def save_to_file(self, file_path: str | Path) -> None:
+        """Save credentials to a file.
+
+        Args:
+            file_path: Path to save credentials to. Can be a string or Path object.
+                Supported formats: .env, .json, .yaml/.yml
+        """
+        # Convert to Path object if string
+        if isinstance(file_path, str):
+            file_path = Path(file_path)
+
+        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()
+
+        # Get file extension, default to .env if none provided
+        suffix = file_path.suffix
+        if not suffix:
+            file_path = file_path.with_suffix(".env")
+            suffix = ".env"
+
+        if suffix == ".env":
+            with open(file_path, "w") as f:
+                for key, value in data.items():
+                    f.write(f"{key.upper()}={value}\n")
+
+        elif suffix == ".json":
+            with open(file_path, "w") as f:
+                json.dump(data, f, indent=2)
+
+        elif suffix in {".yaml", ".yml"}:
+            with open(file_path, "w") as f:
+                yaml.dump(data, f)
+
+        else:
+            raise ValueError(f"Unsupported file format: {suffix}")
+
+    async def validate_credentials(self) -> bool:
+        """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)}"
+            )
+        return True
+
+    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