levelapp 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

levelapp/endpoint/client.py

@@ -0,0 +1,102 @@
+"""levelapp/endpoint/client.py"""
+import os
+import httpx
+import asyncio
+import logging
+
+from dataclasses import dataclass, field
+from typing import List, Dict, Any
+from pydantic import BaseModel, Field
+
+from levelapp.endpoint.schemas import HttpMethod, HeaderConfig, RequestSchemaConfig, ResponseMappingConfig
+
+
+class EndpointConfig(BaseModel):
+    """Complete endpoint configuration."""
+    name: str
+    base_url: str
+    path: str
+    method: HttpMethod
+    headers: List[HeaderConfig] = Field(default_factory=list)
+    request_schema: List[RequestSchemaConfig] = Field(default_factory=list)
+    response_mapping: List[ResponseMappingConfig] = Field(default_factory=list)
+    timeout: int = Field(default=30)
+    retry_count: int = Field(default=3)
+    retry_backoff: float = Field(default=1.0)
+
+    @classmethod
+    def validate_path(cls, v: str) -> str:
+        if not v.startswith('/'):
+            return f"/{v}"
+        return v
+
+
+@dataclass
+class APIClient:
+    """HTTP client for REST API interactions"""
+    config: EndpointConfig
+    client: httpx.AsyncClient = field(init=False)
+    logger: logging.Logger = field(init=False)
+
+    def __post_init__(self):
+        self.logger = logging.getLogger(f"AsyncAPIClient.{self.config.name}")
+        self.client = httpx.AsyncClient(
+            base_url=self.config.base_url,
+            timeout=self.config.timeout,
+            follow_redirects=True
+        )
+
+    async def __aenter__(self) -> "APIClient":
+        return self
+
+    async def __aexit__(self, *args) -> None:
+        await self.client.aclose()
+
+    def _build_headers(self) -> Dict[str, str]:
+        """Build headers with secure value resolution."""
+        headers = {}
+
+        for header in self.config.headers:
+            if header.secure:
+                value = os.getenv(header.value)
+                if value is None:
+                    self.logger.warning(f"Secure header '{header.name}' env var '{header.value}' not found")
+                    continue
+                headers[header.name] = value
+            else:
+                headers[header.name] = header.value
+
+        return headers
+
+    async def execute(
+            self,
+            payload: Dict[str, Any] | None = None,
+            query_params: Dict[str, Any] | None = None,
+    ) -> httpx.Response:
+        """Execute asynchronous REST API request with retry logic."""
+        headers = self._build_headers()
+
+        for attempt in range(self.config.retry_count):
+            try:
+                response = await self.client.request(
+                    method=self.config.method.value,
+                    url=self.config.path,
+                    json=payload,
+                    params=query_params,
+                    headers=headers,
+                )
+                response.raise_for_status()
+                return response
+
+            except httpx.HTTPStatusError as e:
+                self.logger.error(f"HTTP {e.response.status_code}: {e}")
+                if attempt == self.config.retry_count - 1:
+                    raise
+
+            except httpx.RequestError as e:
+                self.logger.error(f"Request failed (attempt {attempt + 1}): {e}")
+                if attempt == self.config.retry_count - 1:
+                    raise
+                await asyncio.sleep(delay=self.config.retry_backoff * (attempt + 1))
+
+        raise RuntimeError("Max retries exceeded")

levelapp/endpoint/manager.py

@@ -0,0 +1,114 @@
+"""levelapp/endpoint/manager.py"""
+import httpx
+import yaml
+import logging
+
+from pathlib import Path
+from typing import Dict, List, Any
+from pydantic import ValidationError
+
+from levelapp.endpoint.schemas import ResponseMappingConfig
+from levelapp.endpoint.tester import ConnectivityTester
+from levelapp.endpoint.client import EndpointConfig, APIClient
+from levelapp.endpoint.parsers import RequestPayloadBuilder, ResponseDataExtractor
+
+
+class EndpointConfigManager:
+    """Manages endpoint configurations and creates testers."""
+    def __init__(self, config_path: Path | None = None):
+        self.config_path = config_path
+        self.endpoints: Dict[str, EndpointConfig] = {}
+        self.logger = logging.getLogger("ConfigurationManager")
+
+        if config_path:
+            self._load_config()
+
+    def _load_config(self) -> None:
+        """Load and validate YAML configuration file."""
+        try:
+            with open(self.config_path, "r") as f:
+                data = yaml.safe_load(f)
+
+            for endpoint_data in data.get("endpoints", []):
+                config = EndpointConfig.model_validate(endpoint_data)
+                self.endpoints[config.name] = config
+                self.logger.info(f"Loaded endpoint config: {config.name}")
+
+        except ValidationError as e:
+            self.logger.error(f"Failed to load endpoint config: {e}")
+
+        except Exception as e:
+            self.logger.error(f"Failed to load endpoint config: {e}", exc_info=e)
+            raise RuntimeError("Failed to extract endpoints data from YAML file:\n{e}")
+
+    def set_endpoints(self, endpoints_config: List[EndpointConfig]):
+        for endpoint in endpoints_config:
+            try:
+                config = EndpointConfig.model_validate(endpoint)
+                self.endpoints[config.name] = config
+
+            except ValidationError as e:
+                self.logger.error(f"Failed to load endpoint config: {e}", exc_info=e)
+                continue
+
+    def build_response_mapping(self, content: List[Dict[str, Any]]) -> List[ResponseMappingConfig]:
+        mappings = []
+        for el in content:
+            try:
+                mappings.append(ResponseMappingConfig.model_validate(el))
+            except ValidationError as e:
+                self.logger.error(f"Failed to validate response mapping: {e}", exc_info=e)
+
+        return mappings
+
+    async def send_request(
+            self,
+            endpoint_config: EndpointConfig,
+            context: Dict[str, Any],
+            contextual_mode: bool = False
+    ) -> httpx.Response:
+        payload_builder = RequestPayloadBuilder()
+        client = APIClient(config=endpoint_config)
+
+        if not contextual_mode:
+            context = payload_builder.build(
+                schema=endpoint_config.request_schema,
+                context=context,
+            )
+
+        async with client:
+            response = await client.execute(payload=context)
+
+        self.logger.info(f"Response status: {response.status_code}")
+
+        return response
+
+    @staticmethod
+    def extract_response_data(
+            response: httpx.Response,
+            mappings: List[ResponseMappingConfig],
+    ) -> Dict[str, Any]:
+        extractor = ResponseDataExtractor()
+        response_data = response.json() if response.text else {}
+        extracted = extractor.extract(
+            response_data=response_data,
+            mappings=mappings
+        )
+
+        return extracted
+
+    def get_tester(self, endpoint_name: str) -> ConnectivityTester:
+        """Factory method: create connectivity tester for endpoint."""
+        if endpoint_name not in self.endpoints:
+            raise KeyError(f"Endpoint '{endpoint_name}' not found in configuration")
+
+        return ConnectivityTester(self.endpoints[endpoint_name])
+
+    def test_all(self, context: Dict[str, Any] | None = None) -> Dict[str, Dict[str, Any]]:
+        """Test all configured endpoints."""
+        results = {}
+        for name in self.endpoints:
+            tester = self.get_tester(name)
+            results[name] = tester.test(context)
+
+        return results

levelapp/endpoint/parsers.py

@@ -0,0 +1,120 @@
+"""levelapp/endpoint/parsers.py"""
+from typing import List, Dict, Any
+
+from levelapp.config.endpoint_ import ResponseMappingConfig
+from levelapp.endpoint.schemas import RequestSchemaConfig
+
+
+class RequestPayloadBuilder:
+    def build(self, schema: List[RequestSchemaConfig], context: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Builds nested JSON payloads using dot-notation paths.
+
+        Args:
+            schema (List[RequestSchemaConfig]): List of request schema configurations.
+            context (Dict[str, Any]): Context for building the payload.
+
+        Returns:
+            payload (Dict[str, Any]): Request payload.
+        """
+        payload = {}
+
+        for field_config in schema:
+            value = self._resolve_value(config=field_config, context=context)
+            if value is None and field_config.required:
+                raise ValueError(f"Required field '{field_config.field_path}' has no value")
+
+            self._set_nested_value(obj=payload, path=field_config.field_path, value=value)
+
+        return payload
+
+    @staticmethod
+    def _resolve_value(config: RequestSchemaConfig, context: Dict[str, Any]) -> Any:
+        """
+        Resolve value based on type: static, env, or dynamic.
+
+        Args:
+            config (RequestSchemaConfig): Request schema configuration.
+            context (Dict[str, Any]): Context for building the payload.
+
+        Returns:
+            Any: Value resolved.
+        """
+        if config.value_type == "static":
+            return config.value
+        elif config.value_type == "env":
+            import os
+            return os.getenv(config.value)
+        elif config.value_type == "dynamic":
+            return context.get(config.value, None)
+
+        return config.value
+
+    @staticmethod
+    def _set_nested_value(obj: Dict, path: str, value: Any) -> None:
+        parts: List[str] = path.split(".")
+        for part in parts[:-1]:
+            obj = obj.setdefault(part, {})
+
+        obj[parts[-1]] = value
+
+
+class ResponseDataExtractor:
+    """Extracts data from API response using mapping-based config."""
+    def extract(
+            self,
+            response_data: Dict[str, Any],
+            mappings: List[ResponseMappingConfig]
+    ) -> Dict[str, Any]:
+        """
+        Extracts data from API response using mapping-based config.
+
+        Args:
+            response_data (Dict[str, Any]): API response data.
+            mappings (List[ResponseMappingConfig]): List of response mappings.
+
+        Returns:
+            Dict[str, Any]: Extracted data.
+        """
+        result: Dict[str, Any] = {}
+
+        for mapping in mappings:
+            try:
+                value = self._extract_by_path(obj=response_data, path=mapping.field_path, default=mapping.default)
+                result[mapping.extract_as] = value
+
+            except Exception as e:
+                print(f"Failed to extract '{mapping.field_path}':\n{e}")
+                result[mapping.extract_as] = mapping.default
+
+        return result
+
+    @staticmethod
+    def _extract_by_path(obj: Dict, path: str, default: Any = "N/A") -> Any:
+        """
+        Extracts value using JSON path-like notation.
+        """
+        parts = path.split(".")
+        current = obj
+
+        for part in parts:
+            if not isinstance(current, dict):
+                print("[extract_by_path][WARNING] the response data is not a dict.")
+                return default
+
+            try:
+                if '[' in part and ']' in part:
+                    key, idx = part.split('[')
+                    idx = int(idx.rstrip(']'))
+                    current = current[key][idx] if key else current[idx]
+                else:
+                    if part not in current:
+                        print(f"[extract_by_path][WARNING] Key '{part}' is missing from response.")
+                        return default
+                    current = current.get(part)
+
+            except (KeyError, IndexError, TypeError, AttributeError) as e:
+                print(f"[extract_by_path][ERROR] Error type <{e.__class__.__name__}> : {e.args[0]}")
+                return default
+
+        return current

levelapp/endpoint/schemas.py

@@ -0,0 +1,38 @@
+"""levelapp/endpoint/schemas.py"""
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class HttpMethod(str, Enum):
+    GET = "GET"
+    POST = "POST"
+    PUT = "PUT"
+    PATCH = "PATCH"
+    DELETE = "DELETE"
+
+
+class HeaderConfig(BaseModel):
+    """Secure header configuration with environment variables support."""
+    name: str
+    value: str
+    secure: bool = False
+
+    class Config:
+        frozen = True
+
+
+class RequestSchemaConfig(BaseModel):
+    """Schema Definition for request payload population."""
+    field_path: str  # JSON path-like: "data.user.id"
+    value: Any
+    value_type: str = "static"
+    required: bool = True
+
+
+class ResponseMappingConfig(BaseModel):
+    """Response data extraction mapping."""
+    field_path: str
+    extract_as: str
+    default: Any = None

levelapp/endpoint/tester.py

@@ -0,0 +1,53 @@
+"""levelapp/endpoint/tester.py"""
+import logging
+from typing import Dict, Any
+
+from levelapp.config.endpoint_ import ResponseExtractor
+from levelapp.endpoint.client import EndpointConfig, APIClient
+from levelapp.endpoint.parsers import RequestPayloadBuilder
+
+
+class ConnectivityTester:
+    """Tests REST endpoint connectivity with configurable behavior."""
+    def __init__(self, config: EndpointConfig):
+        self.config = config
+        self.client = APIClient(config=config)
+        self.payload_builder = RequestPayloadBuilder()
+        self.response_extractor = ResponseExtractor()
+        self.logger = logging.getLogger(f"ConnectivityTester.{self.config.name}")
+
+    async def test(self, context: Dict[str, Any] = None) -> Dict[str, Any]:
+        """Execute connectivity test (template method)."""
+        context = context or {}
+
+        self.logger.info(f"Starting connectivity test for '{self.config.name}'")
+
+        try:
+            payload = None
+            if self.config.request_schema:
+                payload = self.payload_builder.build(schema=self.config.request_schema, context=context)
+                self.logger.debug(f"Request payload: {payload}")
+
+            response = await self.client.execute(payload=payload)
+            self.logger.debug(f"Response status: {response.status_code}")
+
+            response_data = response.json() if response.text else {}
+            extracted = self.response_extractor.extract(
+                response_data=response_data,
+                mappings=self.config.response_mapping,
+            )
+
+            return {
+                "success": True,
+                "status_code": response.status_code,
+                "extracted_data": extracted,
+                "raw_response": response,
+            }
+
+        except Exception as e:
+            self.logger.error(f"Connectivity test failed: {e}", exc_info=e)
+            return {
+                "success": False,
+                "error": str(e),
+                "error_type": type(e).__name__,
+            }

levelapp/endpoint/usage_example.py

@@ -0,0 +1,39 @@
+import asyncio
+import os
+from pathlib import Path
+from levelapp.endpoint.manager import EndpointConfig
+
+
+async def main():
+    manager = EndpointConfig(config_path=Path("../config/dashq_api.yaml"))
+
+    mappings = manager.build_response_mapping(
+        [
+            {"field_path": "payload.message", "extract_as": "agent_reply"},
+            {"field_path": "payload.metadata", "extract_as": "metadata"},
+            {"field_path": "eventType", "extract_as": "event_type"},
+            {"field_path": "payload.handoffMetadata", "extract_as": "handoff_metadata"},
+        ]
+    )
+
+    print(f"Generated Mappings:\n{mappings}\n---")
+
+    context = {
+        "conversation_id": "238484ef-403b-43c5-9908-884486149d0b",
+        "user_message": "Hello, world!"
+    }
+
+    tester = manager.get_tester(endpoint_name="dashq")
+    os.environ["ENVIRONMENT"] = "test"
+    results = await tester.test(context=context)
+    print(f"Test results:\n{results}\n---")
+
+    extracted_data = await manager.extract_response_data(
+        endpoint_name="dashq",
+        context=context,
+        mappings=mappings,
+    )
+    print(f"Extracted Data:\n{extracted_data}\n---")
+
+if __name__ == '__main__':
+    asyncio.run(main())

levelapp/evaluator/evaluator.py

@@ -279,7 +279,15 @@ class MetadataEvaluator(BaseEvaluator):
         for k, v in output.items():
             field = v.get("field_name", "N/A")
             score = v.get("set_scores", -1)
-            results[field] = int(score[0]) if isinstance(score, list) else int(score)
+
+            if score is None:
+                results[field] = -1
+
+                try:
+                    results[field] = int(score[0]) if isinstance(score, list) else int(score)
+
+                except (TypeError, ValueError):
+                    results[field] = -1
 
         return results
 

levelapp/repository/filesystem.py

@@ -0,0 +1,203 @@
+import json
+from pathlib import Path
+
+from typing import List, Dict, Any, Type, TYPE_CHECKING
+
+from pydantic.v1 import ValidationError
+
+from levelapp.core.base import BaseRepository, Model
+from levelapp.aspects import logger
+
+if TYPE_CHECKING:
+    from levelapp.workflow.config import WorkflowConfig
+
+
+class FileSystemRepository(BaseRepository):
+    """
+    File-system implementation of BaseRepository.
+    Persists Pydantic model data as JSON files under the configured base path.
+    """
+    def __init__(self, config: "WorkflowConfig | None" = None):
+        self._CLASS_NAME = self.__class__.__name__
+
+        self.config = config
+        base_path = getattr(config.repository, "base_path", "./data") if config else "./data"
+        self.base_path = Path(base_path).resolve()
+        self.base_path.mkdir(parents=True, exist_ok=True)
+        logger.info(f"[{self.__class__.__name__}] Base path: {base_path}")
+
+    def connect(self) -> None:
+        """No-op for local storage."""
+        if not self.base_path.exists():
+            self.base_path.mkdir(parents=True, exist_ok=True)
+        logger.info(f"[{self._CLASS_NAME}] connected to {self.base_path}")
+
+    def close(self) -> None:
+        """No-op for local storage."""
+        logger.info(f"[{self._CLASS_NAME}] Closed (no active connections)")
+
+    def _compose_path(
+            self,
+            collection_id: str,
+            section_id: str,
+            sub_collection_id: str,
+            document_id: str,
+    ) -> Path:
+        """
+        Compose the hierarchical path for a document.
+
+        Args:
+            collection_id (str): the ID for the whole collection.
+            section_id (str): the ID for the section.
+            sub_collection_id (str): the ID for the sub collection.
+            document_id (str): the ID for the document.
+
+        Returns:
+            Path: the composed path.
+        """
+        path = self.base_path / collection_id / section_id / sub_collection_id
+        path.mkdir(parents=True, exist_ok=True)
+        return path / f"{document_id}.json"
+
+    def retrieve_document(
+            self,
+            collection_id: str,
+            section_id: str,
+            sub_collection_id: str,
+            document_id: str,
+            model_type: Type[Model]
+    ) -> Model | None:
+        """
+        Retrieve a document from the local JSON file system.
+
+        Args:
+            collection_id (str): the ID for the whole collection.
+            section_id (str): the ID for the section.
+            sub_collection_id (str): the ID for the sub collection.
+            document_id (str): the ID for the document.
+            model_type (Type[Model]): Pydantic model for parsing.
+
+        Returns:
+            Model | None: An instance of the provided model.
+        """
+        path = self._compose_path(collection_id, section_id, sub_collection_id, document_id)
+        if not path.exists():
+            logger.warning(f"[{self._CLASS_NAME}] Document '{path}' no found")
+            return None
+
+        try:
+            with path.open("r", encoding="utf-8") as f:
+                data = json.load(f)
+
+            return model_type.model_validate(data)
+
+        except json.JSONDecodeError as e:
+            logger.error(f"[{self._CLASS_NAME}] Failed to load the JSON file '{document_id}':\n{e}")
+            return None
+
+        except ValidationError as e:
+            logger.error(f"[{self._CLASS_NAME}] Failed to instantiate a Pydantic model for file '{document_id}':\n{e}")
+            return None
+
+        except Exception as e:
+            logger.exception(f"[{self._CLASS_NAME}] Unexpected error retrieving file '{document_id}':\n{e}")
+            return None
+
+    def store_document(
+            self,
+            collection_id: str,
+            section_id: str,
+            sub_collection_id: str,
+            document_id: str,
+            data: Model
+    ) -> None:
+        """
+        Store a document as JSON file locally.
+
+        Args:
+            collection_id (str): the ID for the whole collection.
+            section_id (str): the ID for the section.
+            sub_collection_id (str): the ID for the sub collection.
+            document_id (str): the ID for the document.
+            data (Model): Pydantic model for parsing.
+        """
+        path = self._compose_path(collection_id, section_id, sub_collection_id, document_id)
+
+        try:
+            with path.open("w", encoding="utf-8") as f:
+                json.dump(data.model_dump(), f, ensure_ascii=False, indent=2)
+            logger.info(f"[{self._CLASS_NAME}] Stored document '{document_id}' in '{path}'")
+
+        except Exception as e:
+            logger.exception(f"[{self._CLASS_NAME}] Failed to store document '{document_id}' in '{path}':\n{e}'")
+
+    def query_collection(
+            self,
+            collection_id: str,
+            section_id: str,
+            sub_collection_id: str,
+            filters: Dict[str, Any],
+            model_type: Type[Model]
+    ) -> List[Model]:
+        """
+        Query all document in a sub collection, applying simple equality filters.
+
+        Args:
+            collection_id (str): the ID for the whole collection.
+            section_id (str): the ID for the section.
+            sub_collection_id (str): the ID for the sub collection.
+            filters (Dict[str, Any]): Pydantic model for parsing.
+            model_type (Type[Model]): Pydantic model for parsing.
+
+        Returns:
+            List[Model]: List of deserialized models that match the query.
+        """
+        path = self.base_path / collection_id / section_id / sub_collection_id
+
+        if not path.exists():
+            logger.warning(f"[{self._CLASS_NAME}] Sub-collection '{path}' not found")
+            return []
+
+        results = []
+        try:
+            for file in path.glob("*.json"):
+                with file.open("r", encoding="utf-8") as f:
+                    data = json.load(f)
+
+                if all(data.get(k) == v for k, v in filters.items()):
+                    results.append(model_type.model_validate(data))
+
+        except json.JSONDecodeError as e:
+            logger.error(f"[{self._CLASS_NAME}] Failed to read JSON files content:\n{e}")
+
+        except ValidationError as e:
+            logger.error(f"[{self._CLASS_NAME}] Failed to parse JSON files content:\n{e}")
+
+        return results
+
+    def delete_document(
+            self,
+            collection_id: str,
+            section_id: str,
+            sub_collection_id: str,
+            document_id: str
+    ) -> bool:
+        """Delete a JSON document from the local file system."""
+        path = self._compose_path(collection_id, section_id, sub_collection_id, document_id)
+
+        if not path.exists():
+            logger.warning(f"[{self._CLASS_NAME}] Document '{path}' not found")
+            return False
+
+        try:
+            path.unlink()
+            logger.info(f"[{self._CLASS_NAME}] Deleted document '{document_id}'")
+            return True
+
+        except FileNotFoundError:
+            logger.warning(f"[{self._CLASS_NAME}] Document '{document_id}' not found")
+            return False
+
+        except Exception as e:
+            logger.exception(f"[{self._CLASS_NAME}] Failed to delete document '{document_id}':\n{e}")
+            return False