tapps-agents 3.5.40__py3-none-any.whl → 3.6.0__py3-none-any.whl

tapps_agents/core/export_schema.py

@@ -1,202 +1,202 @@
-"""
-Export Schema
-
-Defines and validates export data format.
-"""
-
-import json
-import logging
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-# Export schema version
-SCHEMA_VERSION = "1.0"
-
-
-@dataclass
-class ValidationResult:
-    """Schema validation result."""
-
-    valid: bool
-    errors: list[str]
-    warnings: list[str]
-    schema_version: str
-
-    def __post_init__(self):
-        """Initialize lists if None."""
-        if self.errors is None:
-            self.errors = []
-        if self.warnings is None:
-            self.warnings = []
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary."""
-        return {
-            "valid": self.valid,
-            "errors": self.errors,
-            "warnings": self.warnings,
-            "schema_version": self.schema_version,
-        }
-
-
-class ExportSchema:
-    """Defines and validates export data format."""
-
-    SCHEMA_VERSION = SCHEMA_VERSION
-
-    @staticmethod
-    def get_schema(version: str = "1.0") -> dict[str, Any]:
-        """
-        Get JSON schema for specified version.
-
-        Args:
-            version: Schema version (default: "1.0")
-
-        Returns:
-            JSON schema dictionary
-        """
-        if version == "1.0":
-            return {
-                "type": "object",
-                "required": ["export_metadata"],
-                "properties": {
-                    "export_metadata": {
-                        "type": "object",
-                        "required": [
-                            "export_timestamp",
-                            "framework_version",
-                            "export_version",
-                            "schema_version",
-                        ],
-                        "properties": {
-                            "export_timestamp": {"type": "string"},
-                            "framework_version": {"type": "string"},
-                            "export_version": {"type": "string"},
-                            "schema_version": {"type": "string"},
-                            "project_hash": {"type": "string"},
-                            "anonymization_applied": {"type": "boolean"},
-                            "privacy_notice": {"type": "string"},
-                        },
-                    },
-                    "capability_metrics": {"type": "object"},
-                    "pattern_statistics": {"type": "object"},
-                    "learning_effectiveness": {"type": "object"},
-                    "analytics_data": {"type": "object"},
-                },
-            }
-        else:
-            raise ValueError(f"Unknown schema version: {version}")
-
-    @staticmethod
-    def validate(
-        data: dict[str, Any], version: str = "1.0"
-    ) -> ValidationResult:
-        """
-        Validate export data against schema.
-
-        Args:
-            data: Export data dictionary
-            version: Schema version to validate against
-
-        Returns:
-            ValidationResult instance
-        """
-        errors: list[str] = []
-        warnings: list[str] = []
-
-        # Basic structure validation
-        if not isinstance(data, dict):
-            return ValidationResult(
-                valid=False,
-                errors=["Export data must be a dictionary"],
-                warnings=[],
-                schema_version=version,
-            )
-
-        # Check required fields
-        if "export_metadata" not in data:
-            errors.append("Missing required field: export_metadata")
-
-        # Validate export_metadata
-        if "export_metadata" in data:
-            metadata = data["export_metadata"]
-            if not isinstance(metadata, dict):
-                errors.append("export_metadata must be a dictionary")
-            else:
-                required_fields = [
-                    "export_timestamp",
-                    "framework_version",
-                    "export_version",
-                    "schema_version",
-                ]
-                for field in required_fields:
-                    if field not in metadata:
-                        errors.append(
-                            f"Missing required field in export_metadata: {field}"
-                        )
-
-        # Check optional fields (warn if missing but don't fail)
-        optional_fields = [
-            "capability_metrics",
-            "pattern_statistics",
-            "learning_effectiveness",
-            "analytics_data",
-        ]
-        for field in optional_fields:
-            if field not in data:
-                warnings.append(f"Optional field missing: {field}")
-
-        # Validate schema version matches
-        if "export_metadata" in data and isinstance(data["export_metadata"], dict):
-            if data["export_metadata"].get("schema_version") != version:
-                warnings.append(
-                    f"Schema version mismatch: expected {version}, "
-                    f"got {data['export_metadata'].get('schema_version')}"
-                )
-
-        valid = len(errors) == 0
-        return ValidationResult(
-            valid=valid, errors=errors, warnings=warnings, schema_version=version
-        )
-
-    @staticmethod
-    def migrate(
-        data: dict[str, Any], from_version: str, to_version: str
-    ) -> dict[str, Any]:
-        """
-        Migrate export data between schema versions.
-
-        Args:
-            data: Export data dictionary
-            from_version: Source schema version
-            to_version: Target schema version
-
-        Returns:
-            Migrated export data
-
-        Note:
-            Currently only version 1.0 is supported.
-            Migration logic will be added as new versions are introduced.
-        """
-        if from_version == to_version:
-            return data
-
-        if from_version == "1.0" and to_version == "1.0":
-            return data
-
-        raise ValueError(
-            f"Migration from {from_version} to {to_version} not yet supported"
-        )
-
-    @staticmethod
-    def get_latest_version() -> str:
-        """
-        Get latest schema version.
-
-        Returns:
-            Latest schema version string
-        """
-        return SCHEMA_VERSION
+"""
+Export Schema
+
+Defines and validates export data format.
+"""
+
+import json
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+# Export schema version
+SCHEMA_VERSION = "1.0"
+
+
+@dataclass
+class ValidationResult:
+    """Schema validation result."""
+
+    valid: bool
+    errors: list[str]
+    warnings: list[str]
+    schema_version: str
+
+    def __post_init__(self):
+        """Initialize lists if None."""
+        if self.errors is None:
+            self.errors = []
+        if self.warnings is None:
+            self.warnings = []
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "valid": self.valid,
+            "errors": self.errors,
+            "warnings": self.warnings,
+            "schema_version": self.schema_version,
+        }
+
+
+class ExportSchema:
+    """Defines and validates export data format."""
+
+    SCHEMA_VERSION = SCHEMA_VERSION
+
+    @staticmethod
+    def get_schema(version: str = "1.0") -> dict[str, Any]:
+        """
+        Get JSON schema for specified version.
+
+        Args:
+            version: Schema version (default: "1.0")
+
+        Returns:
+            JSON schema dictionary
+        """
+        if version == "1.0":
+            return {
+                "type": "object",
+                "required": ["export_metadata"],
+                "properties": {
+                    "export_metadata": {
+                        "type": "object",
+                        "required": [
+                            "export_timestamp",
+                            "framework_version",
+                            "export_version",
+                            "schema_version",
+                        ],
+                        "properties": {
+                            "export_timestamp": {"type": "string"},
+                            "framework_version": {"type": "string"},
+                            "export_version": {"type": "string"},
+                            "schema_version": {"type": "string"},
+                            "project_hash": {"type": "string"},
+                            "anonymization_applied": {"type": "boolean"},
+                            "privacy_notice": {"type": "string"},
+                        },
+                    },
+                    "capability_metrics": {"type": "object"},
+                    "pattern_statistics": {"type": "object"},
+                    "learning_effectiveness": {"type": "object"},
+                    "analytics_data": {"type": "object"},
+                },
+            }
+        else:
+            raise ValueError(f"Unknown schema version: {version}")
+
+    @staticmethod
+    def validate(
+        data: dict[str, Any], version: str = "1.0"
+    ) -> ValidationResult:
+        """
+        Validate export data against schema.
+
+        Args:
+            data: Export data dictionary
+            version: Schema version to validate against
+
+        Returns:
+            ValidationResult instance
+        """
+        errors: list[str] = []
+        warnings: list[str] = []
+
+        # Basic structure validation
+        if not isinstance(data, dict):
+            return ValidationResult(
+                valid=False,
+                errors=["Export data must be a dictionary"],
+                warnings=[],
+                schema_version=version,
+            )
+
+        # Check required fields
+        if "export_metadata" not in data:
+            errors.append("Missing required field: export_metadata")
+
+        # Validate export_metadata
+        if "export_metadata" in data:
+            metadata = data["export_metadata"]
+            if not isinstance(metadata, dict):
+                errors.append("export_metadata must be a dictionary")
+            else:
+                required_fields = [
+                    "export_timestamp",
+                    "framework_version",
+                    "export_version",
+                    "schema_version",
+                ]
+                for field in required_fields:
+                    if field not in metadata:
+                        errors.append(
+                            f"Missing required field in export_metadata: {field}"
+                        )
+
+        # Check optional fields (warn if missing but don't fail)
+        optional_fields = [
+            "capability_metrics",
+            "pattern_statistics",
+            "learning_effectiveness",
+            "analytics_data",
+        ]
+        for field in optional_fields:
+            if field not in data:
+                warnings.append(f"Optional field missing: {field}")
+
+        # Validate schema version matches
+        if "export_metadata" in data and isinstance(data["export_metadata"], dict):
+            if data["export_metadata"].get("schema_version") != version:
+                warnings.append(
+                    f"Schema version mismatch: expected {version}, "
+                    f"got {data['export_metadata'].get('schema_version')}"
+                )
+
+        valid = len(errors) == 0
+        return ValidationResult(
+            valid=valid, errors=errors, warnings=warnings, schema_version=version
+        )
+
+    @staticmethod
+    def migrate(
+        data: dict[str, Any], from_version: str, to_version: str
+    ) -> dict[str, Any]:
+        """
+        Migrate export data between schema versions.
+
+        Args:
+            data: Export data dictionary
+            from_version: Source schema version
+            to_version: Target schema version
+
+        Returns:
+            Migrated export data
+
+        Note:
+            Currently only version 1.0 is supported.
+            Migration logic will be added as new versions are introduced.
+        """
+        if from_version == to_version:
+            return data
+
+        if from_version == "1.0" and to_version == "1.0":
+            return data
+
+        raise ValueError(
+            f"Migration from {from_version} to {to_version} not yet supported"
+        )
+
+    @staticmethod
+    def get_latest_version() -> str:
+        """
+        Get latest schema version.
+
+        Returns:
+            Latest schema version string
+        """
+        return SCHEMA_VERSION

tapps_agents/core/external_feedback_models.py

@@ -1,102 +1,102 @@
-"""
-External feedback data models for TappsCodingAgents evaluation.
-
-These models define the structure for feedback submitted by external projects
-about TappsCodingAgents performance.
-"""
-
-from datetime import datetime, UTC
-from typing import Any
-from uuid import UUID, uuid4
-
-from pydantic import BaseModel, Field, field_validator, ConfigDict
-
-
-class FeedbackContext(BaseModel):
-    """Optional context information for feedback."""
-
-    workflow_id: str | None = Field(None, description="Workflow identifier")
-    agent_id: str | None = Field(None, description="Agent identifier")
-    task_type: str | None = Field(None, description="Task type (e.g., 'code-review')")
-    timestamp: datetime | None = Field(None, description="Context timestamp")
-
-
-class FeedbackMetrics(BaseModel):
-    """Optional performance metrics."""
-
-    execution_time_seconds: float | None = Field(None, description="Execution time in seconds")
-    quality_score: float | None = Field(None, description="Quality score")
-    code_lines_processed: int | None = Field(None, description="Lines of code processed")
-    additional: dict[str, Any] | None = Field(None, description="Additional metrics")
-
-
-class ExternalFeedbackData(BaseModel):
-    """External feedback data model for TappsCodingAgents evaluation."""
-
-    feedback_id: str = Field(
-        default_factory=lambda: str(uuid4()),
-        description="Unique feedback identifier (UUID)",
-    )
-    timestamp: datetime = Field(
-        default_factory=lambda: datetime.now(UTC),
-        description="Feedback submission timestamp",
-    )
-    performance_ratings: dict[str, float] = Field(
-        ...,
-        min_length=1,
-        description="Performance ratings (metric name -> rating, typically 1.0-10.0)",
-    )
-    suggestions: list[str] = Field(
-        ...,
-        min_length=1,
-        description="List of improvement suggestions",
-    )
-    context: FeedbackContext | None = Field(None, description="Optional context information")
-    metrics: FeedbackMetrics | None = Field(None, description="Optional performance metrics")
-    project_id: str | None = Field(None, description="Optional project identifier")
-
-    @field_validator("performance_ratings")
-    @classmethod
-    def validate_ratings(cls, v: dict[str, float]) -> dict[str, float]:
-        """Validate rating values are in reasonable range."""
-        for key, value in v.items():
-            if not isinstance(value, (int, float)):
-                raise ValueError(f"Rating '{key}' must be numeric, got {type(value).__name__}")
-            if value < 0.0 or value > 10.0:
-                raise ValueError(f"Rating '{key}' must be between 0.0 and 10.0, got {value}")
-        return v
-
-    @field_validator("suggestions")
-    @classmethod
-    def validate_suggestions(cls, v: list[str]) -> list[str]:
-        """Validate suggestions are non-empty strings."""
-        if not v:
-            raise ValueError("At least one suggestion is required")
-        for suggestion in v:
-            if not isinstance(suggestion, str) or not suggestion.strip():
-                raise ValueError("Suggestions must be non-empty strings")
-        return v
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary for JSON serialization."""
-        data = self.model_dump(mode="json")
-        # Ensure timestamp is ISO format string
-        if isinstance(data.get("timestamp"), datetime):
-            data["timestamp"] = data["timestamp"].isoformat()
-        return data
-
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> "ExternalFeedbackData":
-        """Create from dictionary (handles timestamp conversion)."""
-        # Convert timestamp string to datetime if needed
-        if "timestamp" in data and isinstance(data["timestamp"], str):
-            try:
-                data["timestamp"] = datetime.fromisoformat(data["timestamp"].replace("Z", "+00:00"))
-            except ValueError:
-                # Fallback: use current time
-                data["timestamp"] = datetime.now(UTC)
-        return cls(**data)
-
-    model_config = ConfigDict(
-        # JSON serialization handled by to_dict() method
-    )
+"""
+External feedback data models for TappsCodingAgents evaluation.
+
+These models define the structure for feedback submitted by external projects
+about TappsCodingAgents performance.
+"""
+
+from datetime import datetime, UTC
+from typing import Any
+from uuid import UUID, uuid4
+
+from pydantic import BaseModel, Field, field_validator, ConfigDict
+
+
+class FeedbackContext(BaseModel):
+    """Optional context information for feedback."""
+
+    workflow_id: str | None = Field(None, description="Workflow identifier")
+    agent_id: str | None = Field(None, description="Agent identifier")
+    task_type: str | None = Field(None, description="Task type (e.g., 'code-review')")
+    timestamp: datetime | None = Field(None, description="Context timestamp")
+
+
+class FeedbackMetrics(BaseModel):
+    """Optional performance metrics."""
+
+    execution_time_seconds: float | None = Field(None, description="Execution time in seconds")
+    quality_score: float | None = Field(None, description="Quality score")
+    code_lines_processed: int | None = Field(None, description="Lines of code processed")
+    additional: dict[str, Any] | None = Field(None, description="Additional metrics")
+
+
+class ExternalFeedbackData(BaseModel):
+    """External feedback data model for TappsCodingAgents evaluation."""
+
+    feedback_id: str = Field(
+        default_factory=lambda: str(uuid4()),
+        description="Unique feedback identifier (UUID)",
+    )
+    timestamp: datetime = Field(
+        default_factory=lambda: datetime.now(UTC),
+        description="Feedback submission timestamp",
+    )
+    performance_ratings: dict[str, float] = Field(
+        ...,
+        min_length=1,
+        description="Performance ratings (metric name -> rating, typically 1.0-10.0)",
+    )
+    suggestions: list[str] = Field(
+        ...,
+        min_length=1,
+        description="List of improvement suggestions",
+    )
+    context: FeedbackContext | None = Field(None, description="Optional context information")
+    metrics: FeedbackMetrics | None = Field(None, description="Optional performance metrics")
+    project_id: str | None = Field(None, description="Optional project identifier")
+
+    @field_validator("performance_ratings")
+    @classmethod
+    def validate_ratings(cls, v: dict[str, float]) -> dict[str, float]:
+        """Validate rating values are in reasonable range."""
+        for key, value in v.items():
+            if not isinstance(value, (int, float)):
+                raise ValueError(f"Rating '{key}' must be numeric, got {type(value).__name__}")
+            if value < 0.0 or value > 10.0:
+                raise ValueError(f"Rating '{key}' must be between 0.0 and 10.0, got {value}")
+        return v
+
+    @field_validator("suggestions")
+    @classmethod
+    def validate_suggestions(cls, v: list[str]) -> list[str]:
+        """Validate suggestions are non-empty strings."""
+        if not v:
+            raise ValueError("At least one suggestion is required")
+        for suggestion in v:
+            if not isinstance(suggestion, str) or not suggestion.strip():
+                raise ValueError("Suggestions must be non-empty strings")
+        return v
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        data = self.model_dump(mode="json")
+        # Ensure timestamp is ISO format string
+        if isinstance(data.get("timestamp"), datetime):
+            data["timestamp"] = data["timestamp"].isoformat()
+        return data
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "ExternalFeedbackData":
+        """Create from dictionary (handles timestamp conversion)."""
+        # Convert timestamp string to datetime if needed
+        if "timestamp" in data and isinstance(data["timestamp"], str):
+            try:
+                data["timestamp"] = datetime.fromisoformat(data["timestamp"].replace("Z", "+00:00"))
+            except ValueError:
+                # Fallback: use current time
+                data["timestamp"] = datetime.now(UTC)
+        return cls(**data)
+
+    model_config = ConfigDict(
+        # JSON serialization handled by to_dict() method
+    )