netra-zen 1.0.0__py3-none-any.whl

token_budget/budget_manager.py

@@ -0,0 +1,200 @@
+"""Token budget manager - enhanced implementation with cost support."""
+
+from .models import CommandBudgetInfo, BudgetType
+from typing import Dict, Optional, List, Union
+import sys
+from pathlib import Path
+
+# Import ClaudePricingEngine for cost calculations
+sys.path.insert(0, str(Path(__file__).parent.parent))
+try:
+    from token_transparency import ClaudePricingEngine, TokenUsageData
+except ImportError:
+    ClaudePricingEngine = None
+    TokenUsageData = None
+
+class TokenBudgetManager:
+    """Manages budgets for overall session and individual commands with support for both tokens and cost."""
+
+    def __init__(self, overall_budget: Optional[Union[int, float]] = None,
+                 enforcement_mode: str = "warn",
+                 budget_type: Union[str, BudgetType] = BudgetType.TOKENS,
+                 overall_cost_budget: Optional[float] = None):
+        """
+        Initialize the budget manager.
+
+        Args:
+            overall_budget: Overall token budget (backward compatibility)
+            enforcement_mode: Action when budget exceeded ("warn" or "block")
+            budget_type: Type of budget ("tokens", "cost", or "mixed")
+            overall_cost_budget: Overall cost budget in USD
+        """
+        # Handle backward compatibility
+        if overall_cost_budget is not None:
+            self.overall_budget = overall_cost_budget
+            self.budget_type = BudgetType.COST
+        else:
+            self.overall_budget = overall_budget
+            if isinstance(budget_type, str):
+                self.budget_type = BudgetType(budget_type.lower())
+            else:
+                self.budget_type = budget_type
+
+        self.enforcement_mode = enforcement_mode
+        self.command_budgets: Dict[str, CommandBudgetInfo] = {}
+        self.total_usage: Union[int, float] = 0.0 if self.is_cost_budget else 0
+
+        # Initialize pricing engine if needed for cost calculations
+        self.pricing_engine = None
+        if ClaudePricingEngine and (self.is_cost_budget or self.is_mixed_budget):
+            self.pricing_engine = ClaudePricingEngine()
+
+    @property
+    def is_token_budget(self) -> bool:
+        """Check if this is a token-based budget."""
+        return self.budget_type == BudgetType.TOKENS
+
+    @property
+    def is_cost_budget(self) -> bool:
+        """Check if this is a cost-based budget."""
+        return self.budget_type == BudgetType.COST
+
+    @property
+    def is_mixed_budget(self) -> bool:
+        """Check if this is a mixed budget."""
+        return self.budget_type == BudgetType.MIXED
+
+    def set_command_budget(self, command_name: str, limit: int):
+        """Sets the token budget for a specific command (backward compatibility)."""
+        if command_name in self.command_budgets:
+            # Preserve existing usage when updating budget limit
+            existing_usage = self.command_budgets[command_name].used
+            self.command_budgets[command_name] = CommandBudgetInfo(
+                limit=limit, used=existing_usage, budget_type=BudgetType.TOKENS)
+        else:
+            self.command_budgets[command_name] = CommandBudgetInfo(
+                limit=limit, budget_type=BudgetType.TOKENS)
+
+    def set_command_cost_budget(self, command_name: str, limit: float):
+        """Sets the cost budget for a specific command in USD."""
+        if command_name in self.command_budgets:
+            # Preserve existing usage when updating budget limit
+            existing_usage = self.command_budgets[command_name].used
+            self.command_budgets[command_name] = CommandBudgetInfo(
+                limit=limit, used=existing_usage, budget_type=BudgetType.COST)
+        else:
+            self.command_budgets[command_name] = CommandBudgetInfo(
+                limit=limit, budget_type=BudgetType.COST)
+
+    def record_usage(self, command_name: str, tokens: int):
+        """Records token usage for a command and updates the overall total (backward compatibility)."""
+        if self.is_cost_budget and self.pricing_engine:
+            # Convert tokens to cost for cost-based budgets
+            cost = self.convert_tokens_to_cost(tokens)
+            self.record_cost_usage(command_name, cost)
+        else:
+            # Traditional token usage
+            self.total_usage += tokens
+            if command_name in self.command_budgets:
+                self.command_budgets[command_name].used += tokens
+
+    def record_cost_usage(self, command_name: str, cost: float):
+        """Records cost usage for a command and updates the overall total."""
+        self.total_usage += cost
+        if command_name in self.command_budgets:
+            self.command_budgets[command_name].used += cost
+
+    def check_budget(self, command_name: str, estimated_tokens: int) -> tuple[bool, str]:
+        """Checks if a command can run based on its budget and the overall budget (backward compatibility).
+
+        Returns:
+            tuple: (can_run: bool, reason: str) - reason explains which budget would be exceeded
+        """
+        if self.is_cost_budget:
+            # Convert tokens to cost for cost budget checking
+            estimated_cost = self.convert_tokens_to_cost(estimated_tokens)
+            return self.check_cost_budget(command_name, estimated_cost)
+        else:
+            return self._check_token_budget(command_name, estimated_tokens)
+
+    def check_cost_budget(self, command_name: str, estimated_cost: float) -> tuple[bool, str]:
+        """Checks if a command can run based on cost budgets.
+
+        Returns:
+            tuple: (can_run: bool, reason: str) - reason explains which budget would be exceeded
+        """
+        # Check overall cost budget FIRST (takes precedence)
+        if self.overall_budget is not None and (self.total_usage + estimated_cost) > self.overall_budget:
+            projected_total = self.total_usage + estimated_cost
+            return False, f"Overall cost budget exceeded: ${projected_total:.4f}/${self.overall_budget:.4f}"
+
+        # Check per-command cost budget
+        if command_name in self.command_budgets:
+            command_budget = self.command_budgets[command_name]
+            if command_budget.is_cost_budget and (command_budget.used + estimated_cost) > command_budget.limit:
+                projected_command = command_budget.used + estimated_cost
+                return False, f"Command '{command_name}' cost budget exceeded: ${projected_command:.4f}/${command_budget.limit:.4f}"
+
+        return True, "Within cost budget limits"
+
+    def _check_token_budget(self, command_name: str, estimated_tokens: int) -> tuple[bool, str]:
+        """Internal method for checking token budgets."""
+        # Check overall budget FIRST (takes precedence)
+        if self.overall_budget is not None and (self.total_usage + estimated_tokens) > self.overall_budget:
+            projected_total = self.total_usage + estimated_tokens
+            return False, f"Overall budget exceeded: {projected_total}/{self.overall_budget} tokens"
+
+        # Check per-command budget
+        if command_name in self.command_budgets:
+            command_budget = self.command_budgets[command_name]
+            if command_budget.is_token_budget and (command_budget.used + estimated_tokens) > command_budget.limit:
+                projected_command = command_budget.used + estimated_tokens
+                return False, f"Command '{command_name}' budget exceeded: {projected_command}/{command_budget.limit} tokens"
+
+        return True, "Within budget limits"
+
+    def convert_tokens_to_cost(self, tokens: int, model: str = "claude-3-5-sonnet") -> float:
+        """Convert tokens to cost using the pricing engine."""
+        if not self.pricing_engine:
+            raise AttributeError("Pricing engine not available for cost conversion")
+
+        # Create usage data for cost calculation
+        # Assume equal split between input and output tokens for estimation
+        input_tokens = int(tokens * 0.6)  # Estimate 60% input
+        output_tokens = tokens - input_tokens  # Remaining 40% output
+
+        usage_data = TokenUsageData(
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            model=model
+        )
+
+        cost_breakdown = self.pricing_engine.calculate_cost(usage_data)
+        return cost_breakdown.total_cost
+
+    def convert_cost_to_tokens(self, cost: float, model: str = "claude-3-5-sonnet") -> int:
+        """Convert cost to approximate token count using the pricing engine."""
+        if not self.pricing_engine:
+            raise AttributeError("Pricing engine not available for cost conversion")
+
+        # Get model pricing
+        model_pricing = self.pricing_engine.pricing_config.MODEL_PRICING.get(
+            model, self.pricing_engine.pricing_config.MODEL_PRICING["claude-3-5-sonnet"]
+        )
+
+        # Use average of input and output pricing for estimation
+        avg_price_per_million = (model_pricing["input"] + model_pricing["output"]) / 2
+        tokens = int((cost / avg_price_per_million) * 1_000_000)
+
+        return tokens
+
+    def set_budget_parameter_type(self, budget_type: Union[str, BudgetType]):
+        """Set the budget parameter type (tokens, cost, or mixed)."""
+        if isinstance(budget_type, str):
+            self.budget_type = BudgetType(budget_type.lower())
+        else:
+            self.budget_type = budget_type
+
+        # Initialize pricing engine if switching to cost or mixed mode
+        if ClaudePricingEngine and (self.is_cost_budget or self.is_mixed_budget) and not self.pricing_engine:
+            self.pricing_engine = ClaudePricingEngine()

token_budget/models.py

@@ -0,0 +1,74 @@
+"""Token budget data models - enhanced implementation with cost support."""
+
+from typing import Dict, Optional, Union
+from enum import Enum
+
+class BudgetType(Enum):
+    """Types of budget tracking supported."""
+    TOKENS = "tokens"
+    COST = "cost"
+    MIXED = "mixed"
+
+class CommandBudgetInfo:
+    """Tracks the budget status for a single command with support for both tokens and cost."""
+
+    def __init__(self, limit: Union[int, float], used: Union[int, float] = 0,
+                 budget_type: BudgetType = BudgetType.TOKENS):
+        """
+        Initialize command budget info.
+
+        Args:
+            limit: Budget limit (tokens as int, cost as float)
+            used: Current usage (tokens as int, cost as float)
+            budget_type: Type of budget (tokens, cost, or mixed)
+        """
+        self.limit = limit
+        self.used = used
+        self.budget_type = budget_type
+
+    @property
+    def remaining(self) -> Union[int, float]:
+        """Get remaining budget amount."""
+        return self.limit - self.used
+
+    @property
+    def percentage(self) -> float:
+        """Get percentage of budget used."""
+        return (self.used / self.limit * 100) if self.limit > 0 else 0
+
+    @property
+    def is_token_budget(self) -> bool:
+        """Check if this is a token-based budget."""
+        return self.budget_type == BudgetType.TOKENS
+
+    @property
+    def is_cost_budget(self) -> bool:
+        """Check if this is a cost-based budget."""
+        return self.budget_type == BudgetType.COST
+
+    @property
+    def is_mixed_budget(self) -> bool:
+        """Check if this is a mixed budget (both tokens and cost)."""
+        return self.budget_type == BudgetType.MIXED
+
+    def format_limit(self) -> str:
+        """Format the limit for display."""
+        if self.is_cost_budget:
+            return f"${self.limit:.4f}"
+        else:
+            return f"{int(self.limit)} tokens"
+
+    def format_used(self) -> str:
+        """Format the used amount for display."""
+        if self.is_cost_budget:
+            return f"${self.used:.4f}"
+        else:
+            return f"{int(self.used)} tokens"
+
+    def format_remaining(self) -> str:
+        """Format the remaining amount for display."""
+        remaining = self.remaining
+        if self.is_cost_budget:
+            return f"${remaining:.4f}"
+        else:
+            return f"{int(remaining)} tokens"

token_budget/visualization.py

@@ -0,0 +1,22 @@
+"""Token budget visualization utilities."""
+
+def render_progress_bar(used: int, total: int, width: int = 20) -> str:
+    """Renders an ASCII progress bar."""
+    if total == 0:
+        return "[NO BUDGET SET]"
+
+    percentage = min(used / total, 1.0)
+    filled_width = int(percentage * width)
+
+    # Use ASCII characters for Windows compatibility
+    bar = '#' * filled_width + '-' * (width - filled_width)
+
+    # Color coding (ANSI escape codes)
+    color_start = '\033[92m'  # Green
+    if percentage > 0.9:
+        color_start = '\033[91m'  # Red
+    elif percentage > 0.7:
+        color_start = '\033[93m'  # Yellow
+    color_end = '\033[0m'  # Reset
+
+    return f"[{color_start}{bar}{color_end}] {percentage:.0%}"

token_transparency/__init__.py

@@ -0,0 +1,20 @@
+"""
+Token Transparency Module for Zen Claude Orchestrator
+
+This module provides transparent token usage tracking and cost calculation
+for Claude Code instances, ensuring compliance with official Claude pricing.
+"""
+
+from .claude_pricing_engine import (
+    ClaudePricingEngine,
+    ClaudePricingConfig,
+    TokenUsageData,
+    CostBreakdown
+)
+
+__all__ = [
+    'ClaudePricingEngine',
+    'ClaudePricingConfig',
+    'TokenUsageData',
+    'CostBreakdown'
+]

token_transparency/claude_pricing_engine.py

@@ -0,0 +1,327 @@
+#!/usr/bin/env python3
+"""
+Claude Code Pricing Compliance Engine
+
+Provides accurate token counting and cost calculation based on official Claude pricing.
+Designed to be the SSOT for all Claude Code pricing calculations within zen.
+
+Key Features:
+- Model detection from API responses
+- Accurate cache pricing based on duration
+- Tool cost calculation
+- Compliance with Claude pricing documentation
+- Extensible for future Claude Code agent support
+"""
+
+from dataclasses import dataclass
+from typing import Dict, Optional, Tuple, Any
+import re
+import json
+import logging
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class ClaudePricingConfig:
+    """Current Claude pricing rates as of 2024-2025"""
+
+    # Model pricing per million tokens (input, output)
+    MODEL_PRICING = {
+        "claude-opus-4": {"input": 15.0, "output": 75.0},
+        "claude-opus-4.1": {"input": 15.0, "output": 75.0},
+        "claude-sonnet-4": {"input": 3.0, "output": 15.0},
+        "claude-sonnet-3.7": {"input": 3.0, "output": 15.0},
+        "claude-3-5-sonnet": {"input": 3.0, "output": 15.0},
+        "claude-haiku-3.5": {"input": 0.8, "output": 4.0},
+    }
+
+    # Cache pricing multipliers
+    CACHE_READ_MULTIPLIER = 0.1  # 10% of base input price
+    CACHE_5MIN_WRITE_MULTIPLIER = 1.25  # 25% premium
+    CACHE_1HOUR_WRITE_MULTIPLIER = 2.0  # 100% premium
+
+    # Tool pricing (per 1000 calls)
+    TOOL_PRICING = {
+        "web_search": 10.0,  # $10 per 1000 searches
+        "web_fetch": 0.0,    # No additional charge
+        "default": 0.0       # Most tools have no additional charge
+    }
+
+@dataclass
+class TokenUsageData:
+    """Token usage data with detailed breakdown"""
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cache_read_tokens: int = 0
+    cache_creation_tokens: int = 0
+    cache_type: str = "5min"  # "5min" or "1hour"
+    total_tokens: int = 0
+    tool_calls: int = 0
+    model: str = "claude-3-5-sonnet"
+
+    def __post_init__(self):
+        """Calculate total if not provided"""
+        if self.total_tokens == 0:
+            self.total_tokens = (self.input_tokens + self.output_tokens +
+                               self.cache_read_tokens + self.cache_creation_tokens)
+
+@dataclass
+class CostBreakdown:
+    """Detailed cost breakdown for transparency"""
+    input_cost: float = 0.0
+    output_cost: float = 0.0
+    cache_read_cost: float = 0.0
+    cache_creation_cost: float = 0.0
+    tool_cost: float = 0.0
+    total_cost: float = 0.0
+    model_used: str = ""
+    cache_type: str = ""
+
+    def __post_init__(self):
+        """Calculate total cost"""
+        self.total_cost = (self.input_cost + self.output_cost +
+                          self.cache_read_cost + self.cache_creation_cost + self.tool_cost)
+
+class ClaudePricingEngine:
+    """
+    Claude Code pricing compliance engine for accurate cost calculation.
+
+    Ensures compliance with official Claude pricing documentation and provides
+    detailed transparency for token usage costs.
+    """
+
+    def __init__(self):
+        self.pricing_config = ClaudePricingConfig()
+
+    def detect_model_from_response(self, response_data: Dict[str, Any]) -> str:
+        """
+        Detect Claude model from API response or usage data.
+
+        Args:
+            response_data: API response or usage data containing model information
+
+        Returns:
+            Model name string, defaults to claude-3-5-sonnet if not detected
+        """
+        # Try multiple locations where model might be specified
+        model_locations = [
+            response_data.get('model'),
+            response_data.get('model_name'),
+            response_data.get('usage', {}).get('model'),
+            response_data.get('message', {}).get('model'),
+            response_data.get('metadata', {}).get('model')
+        ]
+
+        for model in model_locations:
+            if model and isinstance(model, str):
+                # Normalize model name
+                normalized = self._normalize_model_name(model)
+                if normalized in self.pricing_config.MODEL_PRICING:
+                    return normalized
+
+        # Default fallback
+        logger.debug("Model not detected in response, defaulting to claude-3-5-sonnet")
+        return "claude-3-5-sonnet"
+
+    def _normalize_model_name(self, model_name: str) -> str:
+        """Normalize model name to match pricing config keys"""
+        model_name = model_name.lower().strip()
+
+        # Handle various model name formats
+        if "opus" in model_name:
+            if "4.1" in model_name:
+                return "claude-opus-4.1"
+            elif "4" in model_name:
+                return "claude-opus-4"
+        elif "sonnet" in model_name:
+            if "4" in model_name:
+                return "claude-sonnet-4"
+            elif "3.7" in model_name:
+                return "claude-sonnet-3.7"
+            elif "3.5" in model_name or "3-5" in model_name:
+                return "claude-3-5-sonnet"
+        elif "haiku" in model_name:
+            if "3.5" in model_name:
+                return "claude-haiku-3.5"
+
+        return model_name
+
+    def detect_cache_type(self, response_data: Dict[str, Any]) -> str:
+        """
+        Detect cache type (5min vs 1hour) from response data.
+
+        Args:
+            response_data: API response data
+
+        Returns:
+            "5min" or "1hour", defaults to "5min"
+        """
+        # Look for cache type indicators in response
+        cache_indicators = [
+            response_data.get('cache_type'),
+            response_data.get('usage', {}).get('cache_type'),
+            response_data.get('metadata', {}).get('cache_type')
+        ]
+
+        for indicator in cache_indicators:
+            if indicator:
+                if "1hour" in str(indicator).lower() or "60min" in str(indicator).lower():
+                    return "1hour"
+                elif "5min" in str(indicator).lower():
+                    return "5min"
+
+        # Default to 5min cache
+        return "5min"
+
+    def calculate_cost(self, usage_data: TokenUsageData,
+                      authoritative_cost: Optional[float] = None,
+                      tool_tokens: Optional[Dict[str, int]] = None) -> CostBreakdown:
+        """
+        Calculate detailed cost breakdown with Claude pricing compliance.
+
+        Args:
+            usage_data: Token usage information
+            authoritative_cost: SDK-provided cost (preferred when available)
+            tool_tokens: Dictionary of tool names to token counts for tool cost calculation
+
+        Returns:
+            Detailed cost breakdown for transparency
+        """
+        # Use authoritative cost if provided (most accurate)
+        if authoritative_cost is not None:
+            breakdown = CostBreakdown(
+                model_used=usage_data.model,
+                cache_type=usage_data.cache_type
+            )
+            breakdown.total_cost = authoritative_cost
+            return breakdown
+
+        # Get model pricing
+        model_pricing = self.pricing_config.MODEL_PRICING.get(
+            usage_data.model,
+            self.pricing_config.MODEL_PRICING["claude-3-5-sonnet"]
+        )
+
+        # Calculate base costs
+        input_cost = (usage_data.input_tokens / 1_000_000) * model_pricing["input"]
+        output_cost = (usage_data.output_tokens / 1_000_000) * model_pricing["output"]
+
+        # Calculate cache costs with correct multipliers
+        cache_read_cost = (usage_data.cache_read_tokens / 1_000_000) * \
+                         (model_pricing["input"] * self.pricing_config.CACHE_READ_MULTIPLIER)
+
+        # Cache creation cost depends on cache type
+        cache_multiplier = (self.pricing_config.CACHE_1HOUR_WRITE_MULTIPLIER
+                           if usage_data.cache_type == "1hour"
+                           else self.pricing_config.CACHE_5MIN_WRITE_MULTIPLIER)
+
+        cache_creation_cost = (usage_data.cache_creation_tokens / 1_000_000) * \
+                             (model_pricing["input"] * cache_multiplier)
+
+        # Calculate tool costs based on token usage
+        tool_cost = 0.0
+        if tool_tokens:
+            for tool_name, tokens in tool_tokens.items():
+                # Tool tokens are charged at the same rate as input tokens for the model
+                tool_cost += (tokens / 1_000_000) * model_pricing["input"]
+
+        return CostBreakdown(
+            input_cost=input_cost,
+            output_cost=output_cost,
+            cache_read_cost=cache_read_cost,
+            cache_creation_cost=cache_creation_cost,
+            tool_cost=tool_cost,
+            model_used=usage_data.model,
+            cache_type=usage_data.cache_type
+        )
+
+    def parse_claude_response(self, response_line: str) -> Optional[TokenUsageData]:
+        """
+        Parse token usage from Claude Code response line with model detection.
+
+        Args:
+            response_line: Single line from Claude Code output
+
+        Returns:
+            TokenUsageData if parsing successful, None otherwise
+        """
+        line = response_line.strip()
+        if not line.startswith('{'):
+            return None
+
+        try:
+            json_data = json.loads(line)
+
+            # Detect model and cache type
+            model = self.detect_model_from_response(json_data)
+            cache_type = self.detect_cache_type(json_data)
+
+            # Extract usage data
+            usage_data = None
+            if 'usage' in json_data:
+                usage_data = json_data['usage']
+            elif 'message' in json_data and isinstance(json_data['message'], dict):
+                usage_data = json_data['message'].get('usage')
+
+            if usage_data and isinstance(usage_data, dict):
+                return TokenUsageData(
+                    input_tokens=int(usage_data.get('input_tokens', 0)),
+                    output_tokens=int(usage_data.get('output_tokens', 0)),
+                    cache_read_tokens=int(usage_data.get('cache_read_input_tokens', 0)),
+                    cache_creation_tokens=int(usage_data.get('cache_creation_input_tokens', 0)),
+                    total_tokens=int(usage_data.get('total_tokens', 0)),
+                    model=model,
+                    cache_type=cache_type
+                )
+
+        except (json.JSONDecodeError, ValueError, KeyError) as e:
+            logger.debug(f"Failed to parse Claude response: {e}")
+
+        return None
+
+    def get_transparency_report(self, usage_data: TokenUsageData,
+                               cost_breakdown: CostBreakdown,
+                               tool_tokens: Optional[Dict[str, int]] = None) -> Dict[str, Any]:
+        """
+        Generate transparency report for token usage and costs.
+
+        Args:
+            usage_data: Token usage information
+            cost_breakdown: Detailed cost breakdown
+            tool_tokens: Tool-specific token usage
+
+        Returns:
+            Comprehensive transparency report
+        """
+        return {
+            "model_used": usage_data.model,
+            "cache_type": usage_data.cache_type,
+            "token_breakdown": {
+                "input_tokens": usage_data.input_tokens,
+                "output_tokens": usage_data.output_tokens,
+                "cache_read_tokens": usage_data.cache_read_tokens,
+                "cache_creation_tokens": usage_data.cache_creation_tokens,
+                "total_tokens": usage_data.total_tokens,
+                "tool_tokens": tool_tokens or {}
+            },
+            "cost_breakdown": {
+                "input_cost_usd": round(cost_breakdown.input_cost, 6),
+                "output_cost_usd": round(cost_breakdown.output_cost, 6),
+                "cache_read_cost_usd": round(cost_breakdown.cache_read_cost, 6),
+                "cache_creation_cost_usd": round(cost_breakdown.cache_creation_cost, 6),
+                "tool_cost_usd": round(cost_breakdown.tool_cost, 6),
+                "total_cost_usd": round(cost_breakdown.total_cost, 6)
+            },
+            "pricing_rates": {
+                "model_rates": self.pricing_config.MODEL_PRICING[usage_data.model],
+                "cache_read_multiplier": self.pricing_config.CACHE_READ_MULTIPLIER,
+                "cache_write_multiplier": (self.pricing_config.CACHE_1HOUR_WRITE_MULTIPLIER
+                                         if usage_data.cache_type == "1hour"
+                                         else self.pricing_config.CACHE_5MIN_WRITE_MULTIPLIER)
+            },
+            "compliance_info": {
+                "pricing_source": "https://docs.claude.com/en/docs/about-claude/pricing",
+                "last_updated": "2024-2025",
+                "model_detected": usage_data.model != "claude-3-5-sonnet"
+            }
+        }