Initial test

.streamlit/config.toml

@@ -0,0 +1,5 @@
+[theme]
+primaryColor="#01d2fc"
+backgroundColor="#252040"
+secondaryBackgroundColor="#262626"
+textColor="#f4f4f4"

requirements.txt

@@ -0,0 +1,84 @@
+# Core dependencies
+gradio
+requests
+python-dotenv
+tokonomics
+aiofiles==23.2.1
+altair==5.5.0
+annotated-types==0.7.0
+anyenv==0.4.11
+anyio==4.9.0
+appdirs==1.4.4
+attrs==25.3.0
+audioop-lts==0.2.1
+blinker==1.9.0
+cachetools==5.5.2
+certifi==2025.1.31
+charset-normalizer==3.4.1
+click==8.1.8
+fastapi==0.115.12
+ffmpy==0.5.0
+filelock==3.18.0
+fsspec==2025.3.0
+gitdb==4.0.12
+GitPython==3.1.44
+gradio==5.23.0
+gradio_client==1.8.0
+groovy==0.1.2
+h11==0.14.0
+hishel==0.1.1
+httpcore==1.0.7
+httpx==0.28.1
+huggingface-hub==0.29.3
+idna==3.10
+Jinja2==3.1.6
+jsonschema==4.23.0
+jsonschema-specifications==2024.10.1
+markdown-it-py==3.0.0
+MarkupSafe==3.0.2
+mdurl==0.1.2
+narwhals==1.32.0
+numpy==2.2.4
+orjson==3.10.16
+packaging==24.2
+pandas==2.2.3
+pillow==11.1.0
+platformdirs==4.3.7
+protobuf==5.29.4
+pyarrow==19.0.1
+pydantic==2.10.6
+pydantic_core==2.27.2
+pydeck==0.9.1
+pydub==0.25.1
+Pygments==2.19.1
+python-dateutil==2.9.0.post0
+python-dotenv==1.0.1
+python-multipart==0.0.20
+pytz==2025.2
+PyYAML==6.0.2
+referencing==0.36.2
+requests==2.32.3
+rich==13.9.4
+rpds-py==0.23.1
+ruff==0.11.2
+safehttpx==0.1.6
+semantic-version==2.10.0
+shellingham==1.5.4
+six==1.17.0
+smmap==5.0.2
+sniffio==1.3.1
+starlette==0.46.1
+streamlit==1.44.0
+tenacity==9.0.0
+tokonomics==0.3.9
+toml==0.10.2
+tomlkit==0.13.2
+tornado==6.4.2
+tqdm==4.67.1
+typer==0.15.2
+typing_extensions==4.12.2
+tzdata==2025.2
+urllib3==2.3.0
+uvicorn==0.34.0
+watchdog==6.0.0
+websockets==15.0.1

streamlit.py

@@ -0,0 +1,176 @@
+import streamlit as st
+import asyncio
+import tokonomics
+from utils import  create_model_hierarchy
+
+st.set_page_config(page_title="LLM Pricing App", layout="wide")
+
+# --------------------------
+# Async Data Loading Function
+# --------------------------
+async def load_data():
+    """Simulate loading data asynchronously."""
+    AVAILABLE_MODELS = await tokonomics.get_available_models()
+    hierarchy = create_model_hierarchy(AVAILABLE_MODELS)
+    FILTERED_MODELS = []
+    MODEL_PRICING = {}
+    PROVIDERS = list(hierarchy.keys())
+    for provider in PROVIDERS:
+        for model_family in hierarchy[provider]:
+            for model_version in hierarchy[provider][model_family].keys():
+                for region in hierarchy[provider][model_family][model_version]:
+                    model_id = hierarchy[provider][model_family][model_version][region]
+                    MODEL_PRICING[model_id] = await tokonomics.get_model_costs(model_id)
+                    FILTERED_MODELS.append(model_id)
+    return FILTERED_MODELS, MODEL_PRICING, PROVIDERS
+
+# --------------------------
+# Provider Change Function
+# --------------------------
+def provider_change(provider, selected_type, all_types=["text", "vision", "video", "image"]):
+    """Filter models based on the selected provider and type."""
+    all_models = st.session_state.get("models", [])
+    new_models = []
+    others = [a_type for a_type in all_types if selected_type != a_type]
+    for model_name in all_models:
+        if provider in model_name:
+            if selected_type in model_name:
+                new_models.append(model_name)
+            elif any(other in model_name for other in others):
+                continue
+            else:
+                new_models.append(model_name)
+    return new_models if new_models else all_models
+
+# --------------------------
+# Estimate Cost Function (Updated)
+# --------------------------
+def estimate_cost(num_alerts, input_size, output_size, model_id):
+    pricing = st.session_state.get("pricing", {})
+    cost_token = pricing.get(model_id)
+    if not cost_token:
+        return "NA"
+    input_tokens = round(input_size * 1.3)
+    output_tokens = round(output_size * 1.3)
+    price_day = cost_token.get("input_cost_per_token", 0) * input_tokens + cost_token.get("output_cost_per_token", 0) * output_tokens
+    price_total = price_day * num_alerts
+    return f"""## Estimated Cost:
+
+Day Price: {price_total:0.2f} USD  
+Month Price: {price_total * 31:0.2f} USD  
+Year Price: {price_total * 365:0.2f} USD  
+"""
+
+# --------------------------
+# Load Data into Session State (only once)
+# --------------------------
+if "data_loaded" not in st.session_state:
+    with st.spinner("Loading pricing data..."):
+        models, pricing, providers = asyncio.run(load_data())
+        st.session_state["models"] = models
+        st.session_state["pricing"] = pricing
+        st.session_state["providers"] = providers
+        st.session_state["data_loaded"] = True
+
+# --------------------------
+# Sidebar
+# --------------------------
+with st.sidebar:
+    st.image("https://cdn.prod.website-files.com/630f558f2a15ca1e88a2f774/631f1436ad7a0605fecc5e15_Logo.svg", use_container_width=True)
+    st.divider()
+    st.sidebar.title("LLM Pricing Calculator")
+
+
+# --------------------------
+# Main Content Layout (Model Selection Tab)
+# --------------------------
+tab1, tab2 = st.tabs(["Model Selection", "About"])
+
+with tab1:
+    st.header("LLM Pricing App")
+
+    # --- Row 1: Provider/Type and Model Selection ---
+    col_left, col_right = st.columns(2)
+    with col_left:
+        selected_provider = st.selectbox("Select a provider", st.session_state["providers"])
+        selected_type = st.radio("Select type", options=["text", "image"], index=0)
+    with col_right:
+        # Filter models based on the selected provider and type
+        filtered_models = provider_change(selected_provider, selected_type)
+        if filtered_models:
+            selected_model = st.selectbox("Select a model", options=filtered_models)
+        else:
+            selected_model = None
+            st.write("No models available")
+
+    # --- Row 2: Alert Stats ---
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        num_alerts = st.number_input(
+            "Security Alerts Per Day",
+            value=100,
+            min_value=1,
+            step=1,
+            help="Number of security alerts to analyze daily"
+        )
+    with col2:
+        input_size = st.number_input(
+            "Alert Content Size (characters)",
+            value=1000,
+            min_value=1,
+            step=1,
+            help="Include logs, metadata, and context per alert"
+        )
+    with col3:
+        output_size = st.number_input(
+            "Analysis Output Size (characters)",
+            value=500,
+            min_value=1,
+            step=1,
+            help="Expected length of security analysis and recommendations"
+        )
+
+    # --- Row 3: Buttons ---
+    btn_col1, btn_col2 = st.columns(2)
+    with btn_col1:
+        if st.button("Estimate"):
+            if selected_model:
+                st.session_state["result"] = estimate_cost(num_alerts, input_size, output_size, selected_model)
+            else:
+                st.session_state["result"] = "No model selected."
+    with btn_col2:
+        if st.button("Refresh Pricing Data"):
+            with st.spinner("Refreshing pricing data..."):
+                models, pricing, providers = asyncio.run(load_data())
+                st.session_state["models"] = models
+                st.session_state["pricing"] = pricing
+                st.session_state["providers"] = providers
+                st.success("Pricing data refreshed!")
+
+    st.divider()
+    # --- Display Results ---
+    st.markdown("### Results")
+    if "result" in st.session_state:
+        st.write(st.session_state["result"])
+    else:
+        st.write("Use the buttons above to estimate costs.")
+
+    # --- Clear Button Below Results ---
+    if st.button("Clear"):
+        st.session_state.pop("result", None)
+        st.rerun()
+
+with tab2:
+    st.markdown(
+        """
+        ## About This App
+
+        This is based on the tokonomics package.
+
+        - The app downloads the latest pricing from the LiteLLM repository.
+        - Using simple maths to estimate the total tokens.
+        - Version 0.1
+
+        Website: [https://www.priam.ai](https://www.priam.ai)
+        """
+    )

utils.py

@@ -0,0 +1,144 @@
+from typing import List,Dict
+import re
+
+def parse_model_entries(model_entries: List[str]) -> List[Dict[str, str]]:
+    """
+    Parse a list of model entries into structured dictionaries with provider, model name, version, region, and type.
+
+    Args:
+        model_entries: List of model entry strings as found in models.txt
+
+    Returns:
+        List of dictionaries with parsed model information containing keys:
+        - provider: Name of the provider (e.g., 'azure', 'openai', 'anthropic', etc.)
+        - model_name: Base name of the model
+        - version: Version of the model (if available)
+        - region: Deployment region (if available)
+        - model_type: Type of the model (text, image, audio based on pattern analysis)
+    """
+    parsed_models = []
+
+    # Common provider prefixes to identify
+    known_providers = [
+        'azure', 'bedrock', 'anthropic', 'openai', 'cohere', 'google',
+        'mistral', 'meta', 'amazon', 'ai21', 'anyscale', 'stability',
+        'cloudflare', 'databricks', 'cerebras', 'assemblyai'
+    ]
+
+    # Image-related keywords to identify image models
+    image_indicators = ['dall-e', 'stable-diffusion', 'image', 'canvas', 'x-', 'steps']
+
+    # Audio-related keywords to identify audio models
+    audio_indicators = ['whisper', 'tts', 'audio', 'voice']
+
+    for entry in model_entries:
+        model_info = {
+            'provider': '',
+            'model_name': '',
+            'version': '',
+            'region': '',
+            'model_type': 'text'  # Default to text
+        }
+
+        # Check for image models
+        if any(indicator in entry.lower() for indicator in image_indicators):
+            model_info['model_type'] = 'image'
+
+        # Check for audio models
+        elif any(indicator in entry.lower() for indicator in audio_indicators):
+            model_info['model_type'] = 'audio'
+
+        # Parse the entry based on common patterns
+        parts = entry.split('/')
+
+        # Handle region and provider extraction
+        if len(parts) >= 2:
+            # Extract provider from the beginning (common pattern)
+            if parts[0].lower() in known_providers:
+                model_info['provider'] = parts[0].lower()
+
+                # For bedrock and azure, the region is often the next part
+                if parts[0].lower() in ['bedrock', 'azure'] and len(parts) >= 3:
+                    # Skip commitment parts if present
+                    if 'commitment' not in parts[1]:
+                        model_info['region'] = parts[1]
+
+            # The last part typically contains the model name and possibly version
+            model_with_version = parts[-1]
+        else:
+            # For single-part entries
+            model_with_version = entry
+
+        # Extract provider from model name if not already set
+        if not model_info['provider']:
+            # Look for known providers within the model name
+            for provider in known_providers:
+                if provider in model_with_version.lower() or f'{provider}.' in model_with_version.lower():
+                    model_info['provider'] = provider
+                    # Remove provider prefix if it exists at the beginning
+                    if model_with_version.lower().startswith(f'{provider}.'):
+                        model_with_version = model_with_version[len(provider) + 1:]
+                    break
+
+        # Extract version information
+        version_match = re.search(r'[:.-]v(\d+(?:\.\d+)*(?:-\d+)?|\d+)(?::\d+)?$', model_with_version)
+        if version_match:
+            model_info['version'] = version_match.group(1)
+            # Remove version from model name
+            model_name = model_with_version[:version_match.start()]
+        else:
+            # Look for date-based versions like 2024-08-06
+            date_match = re.search(r'-(\d{4}-\d{2}-\d{2})$', model_with_version)
+            if date_match:
+                model_info['version'] = date_match.group(1)
+                model_name = model_with_version[:date_match.start()]
+            else:
+                model_name = model_with_version
+
+        # Clean up model name by removing trailing/leading separators
+        model_info['model_name'] = model_name.strip('.-:')
+
+        parsed_models.append(model_info)
+
+    return parsed_models
+
+
+def create_model_hierarchy(model_entries: List[str]) -> Dict[str, Dict[str, Dict[str, Dict[str, str]]]]:
+    """
+    Organize model entries into a nested dictionary structure by provider, model, version, and region.
+
+    Args:
+        model_entries: List of model entry strings as found in models.txt
+
+    Returns:
+        Nested dictionary with the structure:
+        Provider -> Model -> Version -> Region = full model string
+        If region or version is None, they are replaced with "NA".
+    """
+    # Parse the model entries to get structured information
+    parsed_models = parse_model_entries(model_entries)
+
+    # Create the nested dictionary structure
+    hierarchy = {}
+
+    for i, model_info in enumerate(parsed_models):
+        provider = model_info['provider'] if model_info['provider'] else 'unknown'
+        model_name = model_info['model_name']
+        version = model_info['version'] if model_info['version'] else 'NA'
+        # For Azure models, always use 'NA' as region since they are globally available
+        region = 'NA' if provider == 'azure' else (model_info['region'] if model_info['region'] else 'NA')
+
+        # Initialize nested dictionaries if they don't exist
+        if provider not in hierarchy:
+            hierarchy[provider] = {}
+
+        if model_name not in hierarchy[provider]:
+            hierarchy[provider][model_name] = {}
+
+        if version not in hierarchy[provider][model_name]:
+            hierarchy[provider][model_name][version] = {}
+
+        # Store the full model string at the leaf node
+        hierarchy[provider][model_name][version][region] = model_entries[i]
+
+    return hierarchy