janito 2.15.0__py3-none-any.whl → 2.17.0__py3-none-any.whl

janito/providers/openai/provider.py

@@ -22,46 +22,52 @@ class OpenAIProvider(LLMProvider):
     def __init__(
         self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
     ):
+        self._tools_adapter = get_local_tools_adapter()
+        self._driver = None
+
         if not self.available:
-            # Even when the OpenAI driver is unavailable we still need a tools adapter
-            # so that any generic logic that expects `execute_tool()` to work does not
-            # crash with an AttributeError when it tries to access `self._tools_adapter`.
-            self._tools_adapter = get_local_tools_adapter()
-            self._driver = None
-        else:
-            self.auth_manager = auth_manager or LLMAuthManager()
-            self._api_key = self.auth_manager.get_credentials(type(self).NAME)
-            if not self._api_key:
-                print(f"[ERROR] No API key found for provider '{self.name}'. Please set the API key using:")
-                print(f"  janito --set-api-key YOUR_API_KEY -p {self.name}")
-                print(f"Or set the OPENAI_API_KEY environment variable.")
-                return
-            
-            self._tools_adapter = get_local_tools_adapter()
-            self._driver_config = config or LLMDriverConfig(model=None)
-            if not self._driver_config.model:
-                self._driver_config.model = self.DEFAULT_MODEL
-            if not self._driver_config.api_key:
-                self._driver_config.api_key = self._api_key
-            # Set only the correct token parameter for the model
-            model_name = self._driver_config.model
-            model_spec = self.MODEL_SPECS.get(model_name)
-            # Remove both to avoid stale values
-            if hasattr(self._driver_config, "max_tokens"):
-                self._driver_config.max_tokens = None
-            if hasattr(self._driver_config, "max_completion_tokens"):
-                self._driver_config.max_completion_tokens = None
-            if model_spec:
-                if getattr(model_spec, "thinking_supported", False):
-                    max_cot = getattr(model_spec, "max_cot", None)
-                    if max_cot and max_cot != "N/A":
-                        self._driver_config.max_completion_tokens = int(max_cot)
-                else:
-                    max_response = getattr(model_spec, "max_response", None)
-                    if max_response and max_response != "N/A":
-                        self._driver_config.max_tokens = int(max_response)
-            self.fill_missing_device_info(self._driver_config)
-            self._driver = None  # to be provided by factory/agent
+            return
+
+        self._initialize_config(auth_manager, config)
+        self._setup_model_config()
+
+    def _initialize_config(self, auth_manager, config):
+        """Initialize configuration and API key."""
+        self.auth_manager = auth_manager or LLMAuthManager()
+        self._api_key = self.auth_manager.get_credentials(type(self).NAME)
+        if not self._api_key:
+            from janito.llm.auth_utils import handle_missing_api_key
+
+            handle_missing_api_key(self.name, "OPENAI_API_KEY")
+
+        self._driver_config = config or LLMDriverConfig(model=None)
+        if not self._driver_config.model:
+            self._driver_config.model = self.DEFAULT_MODEL
+        if not self._driver_config.api_key:
+            self._driver_config.api_key = self._api_key
+
+    def _setup_model_config(self):
+        """Configure token limits based on model specifications."""
+        model_name = self._driver_config.model
+        model_spec = self.MODEL_SPECS.get(model_name)
+
+        # Reset token parameters
+        if hasattr(self._driver_config, "max_tokens"):
+            self._driver_config.max_tokens = None
+        if hasattr(self._driver_config, "max_completion_tokens"):
+            self._driver_config.max_completion_tokens = None
+
+        if model_spec:
+            if getattr(model_spec, "thinking_supported", False):
+                max_cot = getattr(model_spec, "max_cot", None)
+                if max_cot and max_cot != "N/A":
+                    self._driver_config.max_completion_tokens = int(max_cot)
+            else:
+                max_response = getattr(model_spec, "max_response", None)
+                if max_response and max_response != "N/A":
+                    self._driver_config.max_tokens = int(max_response)
+
+        self.fill_missing_device_info(self._driver_config)
 
     @property
     def driver(self) -> OpenAIModelDriver:

janito/providers/zai/provider.py

@@ -33,20 +33,14 @@ class ZAIProvider(LLMProvider):
         # crash with an AttributeError when it tries to access `self._tools_adapter`.
         self._tools_adapter = get_local_tools_adapter()
         self._driver = None
-        # Initialize _driver_config to avoid AttributeError
-        self._driver_config = LLMDriverConfig(model=None)
 
     def _setup_available(self, auth_manager, config):
         self.auth_manager = auth_manager or LLMAuthManager()
         self._api_key = self.auth_manager.get_credentials(type(self).NAME)
         if not self._api_key:
-            print(
-                f"[ERROR] No API key found for provider '{self.name}'. Please set the API key using:"
-            )
-            print(f"  janito --set-api-key YOUR_API_KEY -p {self.name}")
-            print(f"Or set the ZAI_API_KEY environment variable.")
-            self._tools_adapter = get_local_tools_adapter()
-            return
+            from janito.llm.auth_utils import handle_missing_api_key
+
+            handle_missing_api_key(self.name, "ZAI_API_KEY")
 
         self._tools_adapter = get_local_tools_adapter()
         self._driver_config = config or LLMDriverConfig(model=None)

janito/regions/__init__.py

@@ -0,0 +1,16 @@
+"""
+Region definitions and geolocation utilities for LLM providers.
+
+This module provides static region definitions for various LLM providers
+and utilities to determine optimal API endpoints based on user location.
+"""
+
+from .provider_regions import PROVIDER_REGIONS, get_optimal_endpoint
+from .geo_utils import get_user_location, get_closest_region
+
+__all__ = [
+    "PROVIDER_REGIONS",
+    "get_optimal_endpoint",
+    "get_user_location",
+    "get_closest_region",
+]

janito/regions/cli.py

@@ -0,0 +1,124 @@
+"""
+CLI commands for region management and geolocation utilities.
+"""
+
+import argparse
+import json
+from typing import Optional
+
+from .geo_utils import get_region_info
+from .provider_regions import (
+    get_provider_regions,
+    get_optimal_endpoint,
+    get_all_providers,
+)
+
+
+def handle_region_info(args=None):
+    """Display current region information."""
+    info = get_region_info()
+    print(json.dumps(info, indent=2))
+
+
+def handle_provider_regions(args):
+    """Display regions for a specific provider."""
+    provider = args.provider.lower()
+    regions = get_provider_regions(provider)
+
+    if not regions:
+        print(f"Provider '{provider}' not found")
+        return
+
+    result = {
+        "provider": provider,
+        "regions": [
+            {
+                "code": r.region_code,
+                "name": r.name,
+                "endpoint": r.endpoint,
+                "location": r.location,
+                "priority": r.priority,
+            }
+            for r in regions
+        ],
+    }
+    print(json.dumps(result, indent=2))
+
+
+def handle_optimal_endpoint(args):
+    """Get optimal endpoint for a provider based on user location."""
+    from .geo_utils import get_user_location, get_closest_region
+
+    country_code, _ = get_user_location()
+    major_region = get_closest_region(country_code)
+
+    provider = args.provider.lower()
+    endpoint = get_optimal_endpoint(provider, major_region)
+
+    if not endpoint:
+        print(f"Provider '{provider}' not found")
+        return
+
+    result = {
+        "provider": provider,
+        "user_region": major_region,
+        "country_code": country_code,
+        "optimal_endpoint": endpoint,
+    }
+    print(json.dumps(result, indent=2))
+
+
+def handle_list_providers(args=None):
+    """List all supported providers."""
+    providers = get_all_providers()
+    result = {"providers": providers, "count": len(providers)}
+    print(json.dumps(result, indent=2))
+
+
+def setup_region_parser(subparsers):
+    """Setup region-related CLI commands."""
+    region_parser = subparsers.add_parser(
+        "region", help="Region and geolocation utilities"
+    )
+    region_subparsers = region_parser.add_subparsers(
+        dest="region_command", help="Region commands"
+    )
+
+    # region info
+    info_parser = region_subparsers.add_parser(
+        "info", help="Show current region information"
+    )
+    info_parser.set_defaults(func=handle_region_info)
+
+    # region providers
+    providers_parser = region_subparsers.add_parser(
+        "providers", help="List all supported providers"
+    )
+    providers_parser.set_defaults(func=handle_list_providers)
+
+    # region list
+    list_parser = region_subparsers.add_parser(
+        "list", help="List regions for a provider"
+    )
+    list_parser.add_argument("provider", help="Provider name (e.g., openai, anthropic)")
+    list_parser.set_defaults(func=handle_provider_regions)
+
+    # region endpoint
+    endpoint_parser = region_subparsers.add_parser(
+        "endpoint", help="Get optimal endpoint for provider"
+    )
+    endpoint_parser.add_argument(
+        "provider", help="Provider name (e.g., openai, anthropic)"
+    )
+    endpoint_parser.set_defaults(func=handle_optimal_endpoint)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Region utilities")
+    setup_region_parser(parser.add_subparsers(dest="command"))
+
+    args = parser.parse_args()
+    if hasattr(args, "func"):
+        args.func(args)
+    else:
+        parser.print_help()

janito/regions/geo_utils.py

@@ -0,0 +1,240 @@
+"""
+Geolocation utilities for determining user location and optimal regions.
+
+This module provides utilities to detect user location and determine
+optimal API regions based on geographic proximity.
+"""
+
+import os
+import json
+import subprocess
+import sys
+from typing import Optional, Tuple
+from pathlib import Path
+
+
+def _get_geoip_location() -> Optional[str]:
+    """Try to get location using geoip2 if available."""
+    try:
+        import geoip2.database
+        import geoip2.errors
+        import urllib.request
+
+        # Common GeoIP database locations
+        db_paths = [
+            "/usr/share/GeoIP/GeoLite2-City.mmdb",
+            "/var/lib/GeoIP/GeoLite2-City.mmdb",
+            str(Path.home() / ".local/share/GeoIP/GeoLite2-City.mmdb"),
+        ]
+
+        for db_path in db_paths:
+            if Path(db_path).exists():
+                reader = geoip2.database.Reader(db_path)
+                try:
+                    with urllib.request.urlopen(
+                        "https://api.ipify.org", timeout=2
+                    ) as response:
+                        ip = response.read().decode().strip()
+
+                    response = reader.city(ip)
+                    country_code = response.country.iso_code
+                    reader.close()
+
+                    if country_code:
+                        return country_code.upper()
+                except Exception:
+                    reader.close()
+                    continue
+    except (ImportError, Exception):
+        pass
+    return None
+
+
+def _get_ipinfo_location() -> Optional[str]:
+    """Try to get location using ipinfo.io via curl."""
+    try:
+        import subprocess
+
+        result = subprocess.run(
+            ["curl", "-s", "https://ipinfo.io/country"],
+            capture_output=True,
+            text=True,
+            timeout=3,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            return result.stdout.strip().upper()
+    except (subprocess.TimeoutExpired, FileNotFoundError, Exception):
+        pass
+    return None
+
+
+def _get_locale_location() -> Optional[str]:
+    """Try to get location from system locale."""
+    try:
+        import locale
+
+        loc = locale.getdefaultlocale()[0]
+        if loc:
+            parts = loc.split("_")
+            if len(parts) > 1:
+                return parts[-1].upper()
+    except Exception:
+        pass
+    return None
+
+
+def get_user_location() -> Tuple[str, str]:
+    """
+    Detect user's location using geoip lookup.
+
+    Returns:
+        Tuple of (country_code, region_name)
+
+    Note:
+        This is a best-effort detection. Falls back to environment variables
+        or defaults to 'US' if detection fails.
+    """
+    # Try environment variable first
+    user_region = os.getenv("JANITO_REGION")
+    if user_region:
+        return user_region.upper(), f"Environment: {user_region}"
+
+    # Try different detection methods
+    country_code = (
+        _get_geoip_location()
+        or _get_ipinfo_location()
+        or _get_locale_location()
+        or "US"
+    )
+
+    source = (
+        "GeoIP"
+        if _get_geoip_location()
+        else (
+            "ipinfo.io"
+            if _get_ipinfo_location()
+            else ("Locale" if _get_locale_location() else "Default")
+        )
+    )
+
+    return country_code, f"{source}: {country_code}"
+
+
+def get_closest_region(country_code: str) -> str:
+    """
+    Map country code to closest major region.
+
+    Args:
+        country_code: ISO country code (e.g., 'US', 'DE', 'CN')
+
+    Returns:
+        Major region identifier (US, EU, CN, CH, ASIA)
+    """
+    country_code = country_code.upper()
+
+    # US and Americas
+    if country_code in ["US", "CA", "MX", "BR", "AR", "CL", "CO", "PE"]:
+        return "US"
+
+    # European Union and Europe
+    if country_code in [
+        "AT",
+        "BE",
+        "BG",
+        "HR",
+        "CY",
+        "CZ",
+        "DK",
+        "EE",
+        "FI",
+        "FR",
+        "DE",
+        "GR",
+        "HU",
+        "IE",
+        "IT",
+        "LV",
+        "LT",
+        "LU",
+        "MT",
+        "NL",
+        "PL",
+        "PT",
+        "RO",
+        "SK",
+        "SI",
+        "ES",
+        "SE",
+        "GB",
+        "NO",
+        "CH",
+        "IS",
+        "LI",
+    ]:
+        return "EU"
+
+    # China and nearby
+    if country_code in ["CN", "HK", "MO", "TW"]:
+        return "CN"
+
+    # Switzerland
+    if country_code == "CH":
+        return "CH"
+
+    # Asia Pacific
+    if country_code in [
+        "JP",
+        "KR",
+        "SG",
+        "MY",
+        "TH",
+        "VN",
+        "PH",
+        "ID",
+        "IN",
+        "AU",
+        "NZ",
+        "BD",
+        "LK",
+        "MM",
+        "KH",
+        "LA",
+        "BN",
+        "MV",
+    ]:
+        return "ASIA"
+
+    # Middle East
+    if country_code in ["AE", "SA", "QA", "KW", "OM", "BH", "IL", "TR"]:
+        return "ASIA"
+
+    # Africa
+    if country_code in ["ZA", "NG", "KE", "EG", "MA", "TN", "GH", "UG"]:
+        return "EU"  # Route through EU for better connectivity
+
+    # Default to US for unknown regions
+    return "US"
+
+
+def get_region_info() -> dict:
+    """
+    Get comprehensive region information for the current user.
+
+    Returns:
+        Dictionary with location details
+    """
+    country_code, source = get_user_location()
+    major_region = get_closest_region(country_code)
+
+    return {
+        "country_code": country_code,
+        "major_region": major_region,
+        "source": source,
+        "timestamp": str(__import__("datetime").datetime.now()),
+    }
+
+
+if __name__ == "__main__":
+    # Test the geolocation functionality
+    info = get_region_info()
+    print(json.dumps(info, indent=2))

janito/regions/provider_regions.py

@@ -0,0 +1,158 @@
+"""
+Static region definitions for LLM providers.
+
+This module contains region mappings for major LLM providers with their
+respective API endpoints and data center locations.
+"""
+
+from typing import Dict, List, Optional
+from dataclasses import dataclass
+
+
+@dataclass
+class RegionEndpoint:
+    """Represents a provider's endpoint in a specific region."""
+
+    region_code: str
+    name: str
+    endpoint: str
+    location: str  # City, Country format
+    priority: int = 1  # Lower = higher priority
+
+
+# Region definitions for major LLM providers
+PROVIDER_REGIONS: Dict[str, List[RegionEndpoint]] = {
+    "openai": [
+        RegionEndpoint(
+            "US-WEST", "US West", "https://api.openai.com/v1", "San Francisco, US", 1
+        ),
+    ],
+    "anthropic": [
+        RegionEndpoint(
+            "US-WEST", "US West", "https://api.anthropic.com", "San Francisco, US", 1
+        ),
+    ],
+    "google": [
+        RegionEndpoint(
+            "EU-WEST",
+            "EU West",
+            "https://generativelanguage.googleapis.com/v1beta",
+            "Delfzijl, NL",
+            1,
+        ),
+    ],
+    "azure-openai": [
+        RegionEndpoint(
+            "US-EAST",
+            "East US",
+            "https://{resource}.openai.azure.com",
+            "Virginia, US",
+            1,
+        ),
+        RegionEndpoint(
+            "US-WEST",
+            "West US",
+            "https://{resource}.openai.azure.com",
+            "California, US",
+            2,
+        ),
+        RegionEndpoint(
+            "EU-WEST",
+            "West Europe",
+            "https://{resource}.openai.azure.com",
+            "Netherlands, NL",
+            3,
+        ),
+        RegionEndpoint(
+            "EU-NORTH",
+            "North Europe",
+            "https://{resource}.openai.azure.com",
+            "Ireland, IE",
+            4,
+        ),
+    ],
+    "alibaba": [
+        RegionEndpoint(
+            "SG",
+            "Singapore",
+            "https://dashscope-intl.aliyuncs.com/api/v1",
+            "Singapore, SG",
+            1,
+        ),
+        RegionEndpoint(
+            "CN-EAST",
+            "China East",
+            "https://dashscope.aliyuncs.com/api/v1",
+            "Hangzhou, CN",
+            2,
+        ),
+    ],
+    "moonshot": [
+        RegionEndpoint(
+            "US-WEST", "US West", "https://api.moonshot.ai/v1", "San Francisco, US", 1
+        ),
+        RegionEndpoint(
+            "CN-EAST", "China East", "https://api.moonshot.cn/v1", "Shanghai, CN", 2
+        ),
+        RegionEndpoint(
+            "CN-NORTH", "China North", "https://api.moonshot.cn/v1", "Beijing, CN", 3
+        ),
+    ],
+    "zai": [
+        RegionEndpoint(
+            "ASIA-PACIFIC",
+            "Asia Pacific",
+            "https://api.z.ai/api/paas/v4",
+            "Singapore, SG",
+            1,
+        ),
+    ],
+}
+
+# Geographic region mappings
+REGION_MAPPINGS = {
+    "US": ["US-EAST", "US-WEST", "US-CENTRAL", "US-NORTH", "US-SOUTH"],
+    "EU": ["EU-CENTRAL", "EU-WEST", "EU-NORTH", "EU-SOUTH", "EU-EAST"],
+    "CN": ["CN-EAST", "CN-NORTH", "CN-SOUTH", "CN-WEST", "CN-CENTRAL"],
+    "CH": ["CH-NORTH", "CH-SOUTH", "CH-EAST", "CH-WEST"],
+    "ASIA": ["ASIA-EAST", "ASIA-PACIFIC", "ASIA-SOUTH", "ASIA-CENTRAL"],
+    "GLOBAL": ["GLOBAL", "WORLDWIDE"],
+}
+
+
+def get_provider_regions(provider: str) -> List[RegionEndpoint]:
+    """Get all regions for a specific provider."""
+    return PROVIDER_REGIONS.get(provider.lower(), [])
+
+
+def get_optimal_endpoint(provider: str, user_region: str = "US") -> Optional[str]:
+    """
+    Get the optimal endpoint for a provider based on user region.
+
+    Args:
+        provider: The provider name (e.g., 'openai', 'anthropic')
+        user_region: User's geographic region (US, EU, CN, CH, ASIA)
+
+    Returns:
+        The optimal endpoint URL or None if provider not found
+    """
+    regions = get_provider_regions(provider)
+    if not regions:
+        return None
+
+    # Map user region to provider regions
+    preferred_region_codes = REGION_MAPPINGS.get(user_region.upper(), [])
+
+    # Find the highest priority region that matches
+    for region_code in preferred_region_codes:
+        for region in regions:
+            if region.region_code == region_code:
+                return region.endpoint
+
+    # Fallback to first available region
+    return regions[0].endpoint if regions else None
+
+
+def get_all_providers() -> List[str]:
+    """Get list of all supported providers."""
+    return list(PROVIDER_REGIONS.keys())

{janito-2.15.0.dist-info → janito-2.17.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.15.0
+Version: 2.17.0
 Summary: A new Python package called janito.
 Author-email: João Pinto <janito@ikignosis.org>
 Project-URL: Homepage, https://github.com/ikignosis/janito