django-cfg 1.4.20__py3-none-any.whl → 1.4.23__py3-none-any.whl

django_cfg/modules/django_client/system/templates/main_index.js.j2

@@ -0,0 +1,80 @@
+/**
+ * Django CFG API Clients
+ * Lightweight ES Modules with JSDoc type annotations
+ * Organized by Django apps
+ *
+ * @module django-cfg-api
+ *
+ * @example
+ * // Import specific app API
+ * import { tasksAPI } from '/static/api/tasks/index.mjs';
+ * const stats = await tasksAPI.cfgTasksApiTasksStatsRetrieve();
+ *
+ * @example
+ * // Import multiple APIs from main index
+ * import { tasksAPI, paymentsAPI } from '/static/api/index.mjs';
+ *
+ * @example
+ * // Import with custom base URL
+ * import { TasksAPI } from '/static/api/tasks/index.mjs';
+ * const api = new TasksAPI('https://api.example.com');
+ */
+
+import { BaseAPIClient } from './base.mjs';
+{% for app in apps %}
+import { {{ app.class_name }}, {{ app.instance_name }} } from './{{ app.app_name }}/index.mjs';
+{% endfor %}
+
+/**
+ * Export all API classes for custom instantiation
+ * @exports
+ */
+export {
+    BaseAPIClient,
+{% for app in apps %}
+    {{ app.class_name }},
+{% endfor %}
+};
+
+/**
+ * Export all default instances for convenience
+ * These instances use the current origin as base URL
+ * @exports
+ */
+export {
+{% for app in apps %}
+    {{ app.instance_name }},
+{% endfor %}
+};
+
+/**
+ * Grouped exports by functionality
+ * Access APIs by app name: apis.tasks, apis.payments, etc.
+ * @type {Object.<string, BaseAPIClient>}
+ */
+export const apis = {
+{% for app in apps %}
+    {{ app.app_name }}: {{ app.instance_name }},
+{% endfor %}
+};
+
+/**
+ * Helper function to get API by app name
+ * @param {string} appName - Name of the Django app
+ * @returns {BaseAPIClient|undefined} API instance for the app
+ * @example
+ * const tasksAPI = getAPI('tasks');
+ */
+export function getAPI(appName) {
+    return apis[appName];
+}
+
+/**
+ * List of all available apps
+ * @type {string[]}
+ */
+export const availableApps = [
+{% for app in apps %}
+    '{{ app.app_name }}',
+{% endfor %}
+];

django_cfg/modules/django_client/system/templates/types.js.j2

@@ -0,0 +1,24 @@
+/**
+ * Type definitions for django-cfg API
+ * Auto-generated from OpenAPI schema
+ * @module types
+ */
+
+// This file contains JSDoc type definitions generated from the OpenAPI schema
+// These types can be used for better IDE support and documentation
+
+{% for typedef in typedefs %}
+/**
+ * @typedef {{ '{Object}' }} {{ typedef.name }}
+{%- if typedef.description %}
+ * @description {{ typedef.description }}
+{%- endif %}
+{%- for prop in typedef.properties %}
+ * @property {{ '{' }}{{ prop.type }}{{ '}' }} {% if not prop.required %}[{% endif %}{{ prop.name }}{% if not prop.required %}]{% endif %}{% if prop.description %} - {{ prop.description }}{% endif %}
+{%- endfor %}
+ */
+
+{% endfor %}
+
+// Export empty object to make this a module
+export {};

django_cfg/modules/django_client/urls.py

@@ -5,7 +5,7 @@ Provides URL patterns for OpenAPI schema generation.
 Each configured group gets its own schema endpoint.
 """
 
-from typing import List, Any
+from typing import Any, List
 
 
 def _is_django_configured() -> bool:
@@ -30,6 +30,7 @@ def get_openapi_urls() -> List[Any]:
     try:
         from django.urls import path
         from drf_spectacular.views import SpectacularAPIView
+
         from django_cfg.modules.django_client.core import get_openapi_service
     except ImportError:
         return []
@@ -51,7 +52,7 @@ def get_openapi_urls() -> List[Any]:
             path(
                 f'{group_name}/schema/',
                 SpectacularAPIView.as_view(
-                    urlconf=f'openapi_group_{group_name}',
+                    urlconf=f'_django_client_urlconf_{group_name}',
                     api_version=group_config.version,
                 ),
                 name=f'openapi-schema-{group_name}',

django_cfg/modules/django_currency/__init__.py

@@ -6,32 +6,31 @@ Uses YFinance for fiat/major crypto pairs and CoinGecko for broad crypto coverag
 """
 
 # Core functionality
+# Clients
+from .clients import CoinPaprikaClient, HybridCurrencyClient
 from .core import (
-    CurrencyConverter,
-    Rate,
+    CacheError,
+    ConversionError,
     ConversionRequest,
     ConversionResult,
+    CurrencyConverter,
     CurrencyError,
     CurrencyNotFoundError,
+    Rate,
     RateFetchError,
-    ConversionError,
-    CacheError
 )
 
-# Utilities
-from .utils import CacheManager
-
-# Clients
-from .clients import HybridCurrencyClient, CoinPaprikaClient
-
 # Database tools
 from .database import (
     CurrencyDatabaseLoader,
     DatabaseLoaderConfig,
     create_database_loader,
-    load_currencies_to_database_format
+    load_currencies_to_database_format,
 )
 
+# Utilities
+from .utils import CacheManager
+
 # Shared global converter instance for caching efficiency
 _global_converter = None
 
@@ -80,30 +79,30 @@ def get_exchange_rate(base: str, quote: str) -> float:
 __all__ = [
     # Core converter and models
     "CurrencyConverter",
-    "Rate", 
+    "Rate",
     "ConversionRequest",
     "ConversionResult",
-    
+
     # Exceptions
     "CurrencyError",
     "CurrencyNotFoundError",
-    "RateFetchError", 
+    "RateFetchError",
     "ConversionError",
     "CacheError",
-    
+
     # Utilities
     "CacheManager",
-    
+
     # Clients
     "HybridCurrencyClient",
     "CoinPaprikaClient",
-    
+
     # Database tools
     "CurrencyDatabaseLoader",
     "DatabaseLoaderConfig",
     "create_database_loader",
     "load_currencies_to_database_format",
-    
+
     # Public API
     "convert_currency",
     "get_exchange_rate"

django_cfg/modules/django_currency/clients/__init__.py

@@ -2,10 +2,10 @@
 Currency data clients for fetching rates from external APIs.
 """
 
-from .hybrid_client import HybridCurrencyClient
 from .coinpaprika_client import CoinPaprikaClient
+from .hybrid_client import HybridCurrencyClient
 
 __all__ = [
-    'HybridCurrencyClient', 
+    'HybridCurrencyClient',
     'CoinPaprikaClient'
 ]

django_cfg/modules/django_currency/clients/coinpaprika_client.py

@@ -5,21 +5,21 @@ CoinPaprika API provides all crypto rates in a single request without rate limit
 """
 
 import logging
-import time
-import requests
 from datetime import datetime
-from typing import Dict, Set, Optional, List
+from typing import Dict, List, Set
+
+import requests
 from cachetools import TTLCache
 
-from ..core.models import Rate, CoinPaprikaTicker, CoinPaprikaTickersResponse
 from ..core.exceptions import RateFetchError
+from ..core.models import CoinPaprikaTicker, CoinPaprikaTickersResponse, Rate
 
 logger = logging.getLogger(__name__)
 
 
 class CoinPaprikaClient:
     """Client for fetching crypto rates from CoinPaprika API."""
-    
+
     def __init__(self, cache_ttl: int = 600):
         """Initialize CoinPaprika client with TTL cache."""
         self.base_url = "https://api.coinpaprika.com/v1"
@@ -30,7 +30,7 @@ class CoinPaprikaClient:
             'User-Agent': 'django-cfg-currency-client/1.0',
             'Accept': 'application/json'
         })
-    
+
     def fetch_rate(self, base: str, quote: str) -> Rate:
         """
         Fetch crypto exchange rate from CoinPaprika.
@@ -47,26 +47,26 @@ class CoinPaprikaClient:
         """
         if quote.upper() != 'USD':
             raise RateFetchError(f"CoinPaprika only supports USD quotes, got {quote}")
-        
+
         cache_key = f"{base.upper()}_{quote.upper()}"
-        
+
         # Try cache first
         if cache_key in self._rate_cache:
             logger.debug(f"Retrieved rate {base}/{quote} from cache")
             return self._rate_cache[cache_key]
-        
+
         try:
             # Get all rates and find our currency
             all_rates = self._fetch_all_rates()
-            
+
             base_upper = base.upper()
             for ticker in all_rates:
                 if ticker.symbol == base_upper:
                     price = ticker.quotes.USD.price
-                    
+
                     # Parse ISO format: 2021-01-01T00:00:00Z
                     timestamp = datetime.fromisoformat(ticker.last_updated.replace('Z', '+00:00'))
-                    
+
                     rate = Rate(
                         source="coinpaprika",
                         base_currency=base.upper(),
@@ -74,18 +74,18 @@ class CoinPaprikaClient:
                         rate=float(price),
                         timestamp=timestamp
                     )
-                    
+
                     # Cache the result
                     self._rate_cache[cache_key] = rate
-                    
+
                     return rate
-            
+
             raise RateFetchError(f"Currency {base} not found in CoinPaprika data")
-            
+
         except Exception as e:
             logger.error(f"Failed to fetch rate for {base}/{quote}: {e}")
             raise RateFetchError(f"CoinPaprika fetch failed: {e}")
-    
+
     def _fetch_all_tickers(self) -> Dict[str, dict]:
         """
         Fetch all tickers from CoinPaprika API.
@@ -102,7 +102,7 @@ class CoinPaprikaClient:
             response = requests.get(f"{self.base_url}/tickers")
             response.raise_for_status()
             tickers_data = response.json()
-            
+
             # Process data into a more accessible format: {symbol: {id: ..., price: ...}}
             processed_tickers = {}
             for ticker in tickers_data:
@@ -113,7 +113,7 @@ class CoinPaprikaClient:
                     'price_usd': ticker['quotes']['USD']['price'] if 'USD' in ticker['quotes'] else None,
                     'last_updated': ticker['last_updated']
                 }
-            
+
             self._all_rates_cache[cache_key] = processed_tickers
             logger.info(f"Fetched and cached {len(processed_tickers)} tickers from CoinPaprika")
             return processed_tickers
@@ -129,41 +129,41 @@ class CoinPaprikaClient:
             List of CoinPaprikaTicker objects
         """
         cache_key = "all_rates"
-        
+
         # Try cache first
         if cache_key in self._all_rates_cache:
             logger.debug("Retrieved all rates from cache")
             return self._all_rates_cache[cache_key]
-        
+
         try:
             url = f"{self.base_url}/tickers"
             logger.debug(f"Fetching all rates from {url}")
-            
+
             response = self._session.get(url, timeout=30)
             response.raise_for_status()
-            
+
             raw_data = response.json()
-            
+
             # Validate response using Pydantic model
             try:
                 tickers_response = CoinPaprikaTickersResponse(raw_data)
                 tickers = tickers_response.root
             except Exception as e:
                 raise RateFetchError(f"Invalid CoinPaprika response format: {e}")
-            
+
             # Cache the result
             self._all_rates_cache[cache_key] = tickers
             logger.info(f"Fetched {len(tickers)} cryptocurrencies from CoinPaprika")
-            
+
             return tickers
-            
+
         except requests.RequestException as e:
             logger.error(f"HTTP error fetching from CoinPaprika: {e}")
             raise RateFetchError(f"Failed to fetch data from CoinPaprika: {e}")
         except Exception as e:
             logger.error(f"Unexpected error fetching from CoinPaprika: {e}")
             raise RateFetchError(f"CoinPaprika fetch failed: {e}")
-    
+
     def get_supported_cryptocurrencies(self) -> Set[str]:
         """
         Get all supported cryptocurrency symbols.
@@ -184,7 +184,7 @@ class CoinPaprikaClient:
         """Get all supported cryptocurrencies from CoinPaprika."""
         all_tickers = self._fetch_all_tickers()
         return {symbol: data['name'] for symbol, data in all_tickers.items() if data['price_usd'] is not None}
-    
+
     def supports_pair(self, base: str, quote: str) -> bool:
         """
         Check if a currency pair is supported.
@@ -198,10 +198,10 @@ class CoinPaprikaClient:
         """
         if quote.upper() != 'USD':
             return False
-        
+
         supported_cryptos = self.get_supported_cryptocurrencies()
         return base.upper() in supported_cryptos
-    
+
     def fetch_multiple_rates(self, currency_codes: List[str], quote: str = 'USD') -> Dict[str, Rate]:
         """
         Fetch multiple cryptocurrency rates efficiently.
@@ -215,27 +215,27 @@ class CoinPaprikaClient:
         """
         if quote.upper() != 'USD':
             raise RateFetchError(f"CoinPaprika only supports USD quotes, got {quote}")
-        
+
         results = {}
-        
+
         try:
             # Fetch all rates once
             all_rates = self._fetch_all_rates()
-            
+
             # Create lookup dictionary
             rates_by_symbol = {ticker.symbol: ticker for ticker in all_rates}
-            
+
             # Process requested currencies
             for currency_code in currency_codes:
                 currency_upper = currency_code.upper()
-                
+
                 if currency_upper in rates_by_symbol:
                     ticker = rates_by_symbol[currency_upper]
                     price = ticker.quotes.USD.price
-                    
+
                     # Parse ISO format: 2021-01-01T00:00:00Z
                     timestamp = datetime.fromisoformat(ticker.last_updated.replace('Z', '+00:00'))
-                    
+
                     rate = Rate(
                         source="coinpaprika",
                         base_currency=currency_upper,
@@ -243,22 +243,22 @@ class CoinPaprikaClient:
                         rate=float(price),
                         timestamp=timestamp
                     )
-                    
+
                     results[currency_upper] = rate
-                    
+
                     # Cache individual rate
                     cache_key = f"{currency_upper}_USD"
                     self._rate_cache[cache_key] = rate
                 else:
                     logger.warning(f"Currency {currency_code} not found in CoinPaprika data")
-            
+
             logger.info(f"Successfully fetched {len(results)} rates from CoinPaprika")
             return results
-            
+
         except Exception as e:
             logger.error(f"Failed to fetch multiple rates: {e}")
             raise RateFetchError(f"CoinPaprika batch fetch failed: {e}")
-    
+
     def get_top_cryptocurrencies(self, limit: int = 100) -> List[Dict]:
         """
         Get top cryptocurrencies by market cap rank.
@@ -271,19 +271,19 @@ class CoinPaprikaClient:
         """
         try:
             all_rates = self._fetch_all_rates()
-            
+
             # Filter and sort by rank
             valid_tickers = [
-                ticker for ticker in all_rates 
+                ticker for ticker in all_rates
                 if ticker.rank and ticker.quotes.USD.price
             ]
-            
+
             # Sort by rank and limit
             top_tickers = sorted(valid_tickers, key=lambda x: x.rank)[:limit]
-            
+
             logger.info(f"Retrieved top {len(top_tickers)} cryptocurrencies")
             return top_tickers
-            
+
         except Exception as e:
             logger.error(f"Failed to get top cryptocurrencies: {e}")
             return []