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

levelapp/aspects/loader.py

@@ -111,7 +111,7 @@ class DynamicModelBuilder:
         """
         if isinstance(value, Mapping):
             nested_model = self.create_dynamic_model(model_name=f"{model_name}_{key}", data=value)
-            return nested_model, ...
+            return Optional[nested_model], None
 
         elif isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
             if not value:
@@ -119,15 +119,15 @@ class DynamicModelBuilder:
 
             elif isinstance(value[0], Mapping):
                 nested_model = self.create_dynamic_model(model_name=f"{model_name}_{key}", data=value[0])
-                return List[nested_model], ...
+                return Optional[List[nested_model]], None
 
             else:
                 field_type = type(value[0]) if value[0] is not None else Any
-                return List[field_type], ...
+                return Optional[List[field_type]], None
 
         else:
             field_type = Optional[type(value)] if value is not None else Optional[Any]
-            return field_type, ...
+            return field_type, None
 
     def create_dynamic_model(self, model_name: str, data: Any) -> Type[BaseModel]:
         """

levelapp/config/api_config.yaml

@@ -0,0 +1,156 @@
+# api_config.yaml
+# REST API Configuration Manager - Example Configuration
+
+endpoints:
+  # Example 1: Simple GET endpoint with authentication
+  - name: github-user
+    base_url: https://api.github.com
+    path: /users/octocat
+    method: GET
+    timeout: 15
+    retry_count: 2
+    retry_backoff: 0.5
+    headers:
+      - name: Accept
+        value: application/vnd.github.v3+json
+        secure: false
+      - name: Authorization
+        value: GITHUB_TOKEN  # Environment variable name
+        secure: true
+    request_schema: []
+    response_mapping:
+      - field_path: login
+        extract_as: username
+      - field_path: id
+        extract_as: user_id
+      - field_path: public_repos
+        extract_as: repo_count
+        default: 0
+
+  # Example 2: POST endpoint with nested payload
+  - name: user-creation-api
+    base_url: https://api.example.com
+    path: /v1/users
+    method: POST
+    timeout: 30
+    retry_count: 3
+    retry_backoff: 1.0
+    headers:
+      - name: Content-Type
+        value: application/json
+        secure: false
+      - name: X-API-Key
+        value: API_SECRET_KEY
+        secure: true
+      - name: X-Request-ID
+        value: unique-request-id-001
+        secure: false
+    request_schema:
+      - field_path: user.email
+        value: test@example.com
+        value_type: static
+        required: true
+      - field_path: user.name
+        value: user_name  # Will be taken from context
+        value_type: dynamic
+        required: true
+      - field_path: user.metadata.source
+        value: api-config-manager
+        value_type: static
+        required: false
+      - field_path: user.metadata.environment
+        value: ENVIRONMENT
+        value_type: env
+        required: false
+    response_mapping:
+      - field_path: data.user.id
+        extract_as: created_user_id
+      - field_path: data.user.status
+        extract_as: user_status
+        default: unknown
+      - field_path: data.created_at
+        extract_as: timestamp
+
+  # Example 3: Complex nested response extraction
+  - name: search-api
+    base_url: https://api.service.com
+    path: /search
+    method: GET
+    timeout: 20
+    retry_count: 2
+    retry_backoff: 1.5
+    headers:
+      - name: Authorization
+        value: Bearer your-token-here
+        secure: false
+    request_schema: []
+    response_mapping:
+      - field_path: results[0].id
+        extract_as: first_result_id
+        default: null
+      - field_path: results[0].title
+        extract_as: first_result_title
+        default: "No results"
+      - field_path: meta.total
+        extract_as: total_results
+        default: 0
+      - field_path: meta.page
+        extract_as: current_page
+        default: 1
+
+  # Example 4: Health check endpoint (minimal config)
+  - name: health-check
+    base_url: https://status.example.com
+    path: /health
+    method: GET
+    timeout: 5
+    retry_count: 1
+    retry_backoff: 0.5
+    headers: []
+    request_schema: []
+    response_mapping:
+      - field_path: status
+        extract_as: service_status
+        default: down
+      - field_path: version
+        extract_as: service_version
+
+  # Example 5: PUT endpoint with authentication
+  - name: update-resource
+    base_url: https://api.platform.io
+    path: /v2/resources/12345
+    method: PUT
+    timeout: 25
+    retry_count: 3
+    retry_backoff: 2.0
+    headers:
+      - name: Content-Type
+        value: application/json
+        secure: false
+      - name: Authorization
+        value: PLATFORM_API_TOKEN
+        secure: true
+      - name: X-Client-Version
+        value: "1.0.0"
+        secure: false
+    request_schema:
+      - field_path: resource.name
+        value: resource_name
+        value_type: dynamic
+        required: true
+      - field_path: resource.attributes.priority
+        value: high
+        value_type: static
+        required: false
+      - field_path: resource.attributes.updated_by
+        value: USER_EMAIL
+        value_type: env
+        required: false
+    response_mapping:
+      - field_path: data.id
+        extract_as: resource_id
+      - field_path: data.updated_at
+        extract_as: last_updated
+      - field_path: data.attributes.status
+        extract_as: resource_status
+        default: pending

levelapp/config/dashq_api.yaml

@@ -0,0 +1,94 @@
+# api_config.yaml
+# REST API Configuration Manager - Example Configuration
+
+endpoints:
+  - name: dashq
+    base_url: https://dashq-gateway-485vb8zi.uc.gateway.dev
+    path: /api/conversations/events
+    method: POST
+    timeout: 60
+    retry_count: 3
+    retry_backoff: 0.5
+    headers:
+      - name: model_id
+        value: meta-llama/Meta-Llama-3.1-8B-Instruct
+        secure: false
+      - name: x-api-key
+        value: AIzaSyAmL8blcS2hpPrEH2b84B8ugsVoV7AXrfc
+        secure: false  # change to true later and place the value in .env file
+    request_schema:
+      - field_path: eventType
+        value: newConversation
+        value_type: static
+        required: true
+      - field_path: conversationId
+        value: conversation_id
+        value_type: dynamic
+        required: true
+      - field_path: payload.messageType
+        value: newInquiry
+        value_type: static
+        required: true
+      - field_path: payload.communityId
+        value: 3310
+        value_type: static
+        required: true
+      - field_path: payload.accountId
+        value: 1440
+        value_type: static
+        required: true
+      - field_path: payload.prospectFirstName
+        value: Kanye
+        value_type: static
+        required: true
+      - field_path: payload.prospectLastName
+        value: West
+        value_type: static
+        required: true
+      - field_path: payload.message
+        value: user_message
+        value_type: dynamic
+        required: true
+      - field_path: payload.datetime
+        value: "2025-06-25T11:12:27.245Z"
+        value_type: static
+        required: true
+      - field_path: payload.inboundChannel
+        value: text
+        value_type: static
+        required: true
+      - field_path: payload.outboundChannel
+        value: text
+        value_type: static
+        required: true
+      - field_path: payload.inquirySource
+        value: test.com
+        value_type: static
+        required: true
+    response_mapping:
+      - field_path: eventType
+        extract_as: guardrail_flag
+#      - field_path: conversationId
+#        extract_as: conversation_id
+#      - field_path: payload.accountId
+#        extract_as: account_id
+#      - field_path: payload.messageType
+#        extract_as: message_type
+      - field_path: message
+        extract_as: agent_reply
+#      - field_path: payload.datetime
+#        extract_as: datetime
+      - field_path: metadata
+        extract_as: metadata
+#      - field_path: payload.metadata.inquirySource
+#        extract_as: inquiry_source
+#      - field_path: payload.metadata.booking
+#        extract_as: booking
+#      - field_path: payload.metadata.tasks
+#        extract_as: tasks
+#      - field_path: payload.metadata.communityId
+#        extract_as: community_id
+#      - field_path: payload.handoffMetadata
+#        extract_as: handoff_metadata
+#      - field_path: payload.isConversationOver
+#        extract_as: is_conversation_over

levelapp/config/endpoint_.py

@@ -1,15 +1,21 @@
-from abc import ABC
+import json
+import logging
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
 from enum import Enum
-from typing import Any, List
+from pathlib import Path
+from typing import Any, List, Dict
 
-from pydantic import BaseModel, Field
+import httpx
+import yaml
+from pydantic import BaseModel, Field, ValidationError
 
 
 class HttpMethod(str, Enum):
     GET = "GET"
     POST = "POST"
     PUT = "PUT"
-    Patch = "PATCH"
+    PATCH = "PATCH"
     DELETE = "DELETE"
 
 
@@ -59,4 +65,318 @@ class EndpointConfig(BaseModel):
 
 
 class PayloadBuilder(ABC):
-    """Abstract base for payload construction strategies."""
+    """Abstract base for payload construction strategies."""
+    @abstractmethod
+    def build(self, schema: List[RequestSchemaConfig], context: Dict[str, Any]) -> Dict[str, Any]:
+        """Build request payload from schema and context."""
+        pass
+
+
+class JsonPathPayloadBuilder(PayloadBuilder):
+    """Builds nested JSON payloads using dot-notation paths."""
+    def build(self, schema: List[RequestSchemaConfig], context: Dict[str, Any]) -> Dict[str, Any]:
+        payload = {}
+
+        for field_config in schema:
+            value = self._resolve_value(field_config, 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(payload, field_config.field_path, value)
+
+        return payload
+
+    @staticmethod
+    def _resolve_value(config: RequestSchemaConfig, context: Dict[str, Any]) -> Any:
+        """Resolve value based on type: statis, env, or dynamic."""
+        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":
+            print(f"config value: {config.field_path}")
+            print(f"context: {context}")
+            return context.get(config.field_path)
+
+        return config.value
+
+    @staticmethod
+    def _set_nested_value(obj: Dict, path: str, value: Any) -> None:
+        """Set value in nested dict using dot notation."""
+        parts = path.split('.')
+        for part in parts[:-1]:
+            obj = obj.setdefault(part, {})
+
+        obj[parts[-1]] = value
+
+
+class ResponseExtractor:
+    """Extracts data from API responses based on mapping config."""
+    def extract(
+            self,
+            response_data: Dict[str, Any],
+            mappings: List[ResponseMappingConfig]
+    ) -> Dict[str, Any]:
+        """Extract mapped fields from response data."""
+        result = {}
+
+        for mapping in mappings:
+            try:
+                value = self._extract_by_path(response_data, mapping.field_path)
+                result[mapping.extract_as] = value if value is not None else mapping.default
+
+            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: Any, path: str) -> Any:
+        """Extract value using JSONPath-like notation."""
+        parts = path.split('.')
+        current = obj
+
+        for part in parts:
+            if '[' in part and ']' in part:
+                key, idx = part.split('[')
+                idx = int(idx.rstrip(']'))
+                current = current[key][idx] if key else current[idx]
+            else:
+                current = current[part]
+
+        return current
+
+
+@dataclass
+class APIClient:
+    """HTTP client for REST API interactions."""
+    config: EndpointConfig
+    client: httpx.Client = field(init=False)
+    logger: logging.Logger = field(init=False)
+
+    def __post_init__(self):
+        self.logger = logging.getLogger(f"APIClient.{self.config.name}")
+        self.client = httpx.Client(
+            base_url=self.config.base_url,
+            timeout=self.config.timeout,
+            follow_redirects=True
+        )
+
+    def __del__(self):
+        if hasattr(self, "client"):
+            self.client.close()
+
+    def _build_headers(self) -> Dict[str, str]:
+        """Build headers with secure value resolution."""
+        headers = {}
+        import os
+
+        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
+
+    def execute(
+            self,
+            payload: Dict[str, Any] | None = None,
+            query_params: Dict[str, Any] | None = None
+    ) -> httpx.Response:
+        """Execute API request with retry logic."""
+        headers = self._build_headers()
+
+        for attempt in range(self.config.retry_count):
+            try:
+                response = 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.response.text}")
+                if attempt == self.config.retry_count:
+                    raise e
+
+            except httpx.RequestError as e:
+                self.logger.error(f"Request failed (attempt {attempt + 1}): {e}")
+                if attempt == self.config.retry_count - 1:
+                    raise
+
+                import time
+                time.sleep(self.config.retry_backoff * (attempt + 1))
+
+        raise RuntimeError("Max retries exceeded")
+
+
+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 = JsonPathPayloadBuilder()
+        self.response_extractor = ResponseExtractor()
+        self.logger = logging.getLogger(f"ConnectivityTester.{self.config.name}")
+
+    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:\n{json.dumps(payload, indent=2, default=str)}\n---")
+                self.logger.debug(f"Request payload:\n{payload}\n---")
+
+            response = self.client.execute(payload=payload)
+            self.logger.info(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_data
+            }
+
+        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__
+            }
+
+
+class ConfigurationManager:
+    """Manages endpoint configurations and creates testers."""
+    def __init__(self, config_path: Path):
+        self.config_path = config_path
+        self.endpoints: Dict[str, EndpointConfig] = {}
+        self.logger = logging.getLogger("ConfigurationManager")
+        self._load_config()
+
+    def _load_config(self) -> None:
+        """Load and validate YAML configuration."""
+        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 Exception as e:
+            self.logger.error(f"Failed to load endpoint config: {e}", exc_info=e)
+            raise
+
+    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
+
+    def extract_response_data(
+            self,
+            endpoint_name: str,
+            context: Dict[str, Any],
+            mappings: List[ResponseMappingConfig]
+    ) -> Dict[str, Any]:
+        if endpoint_name not in self.endpoints:
+            raise ValueError(f"Endpoint '{endpoint_name}' not found in configuration")
+
+        payload_builder = JsonPathPayloadBuilder()
+        client = APIClient(config=self.endpoints[endpoint_name])
+        extractor = ResponseExtractor()
+        payload = payload_builder.build(
+            schema=self.endpoints[endpoint_name].request_schema,
+            context=context
+        )
+        response = client.execute(payload=payload)
+        self.logger.info(f"Response status: {response.status_code}")
+        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
+
+
+if __name__ == '__main__':
+    # Example: Load configuration and test endpoint
+    config_manager = ConfigurationManager(Path("dashq_api.yaml"))
+
+    # # Test specific endpoint
+    # tester = config_manager.get_tester("dashq")
+    # result = tester.test(context={"conversationId": "439484ef-403b-43c5-9908-884486149d0b"})
+    #
+    # print(json.dumps(result, indent=2))
+
+    # # Test all endpoints
+    # all_results = config_manager.test_all(context={"environment": "production"})
+    # print(json.dumps(all_results, indent=2))
+
+    content_ = [
+        {
+            "field_path": "payload.message",
+            "extract_as": "agent_reply"
+        },
+        {
+            "field_path": "payload.metadata",
+            "extract_as": "generated_metadata"
+        },
+        {
+            "field_path": "payload.handoffMetadata",
+            "extract_as": "handoff_metadata"
+        }
+    ]
+
+    mappings_ = config_manager.build_response_mapping(content=content_)
+    response_data_ = config_manager.extract_response_data(
+        endpoint_name="dashq",
+        context={"conversationId": "439484ef-403b-43c5-9908-884486149d0b"},
+        mappings=mappings_
+    )
+
+    print(f"extracted response data:\n{response_data_}")

levelapp/config/endpoints.yaml

@@ -0,0 +1,47 @@
+endpoints:
+  - name: create-message
+    base_url: https://postman-echo.com
+    path: /post
+    method: POST
+    timeout: 15
+    retry_count: 2
+    retry_backoff: 0.5
+
+    headers:
+      - name: Content-Type
+        value: application/json
+        secure: false
+
+    request_schema:
+      # Static field
+      - field_path: message.source
+        value: system
+        value_type: static
+        required: true
+
+      # Dynamic field (from runtime context)
+      - field_path: message.user
+        value: user_name
+        value_type: dynamic
+        required: true
+
+      - field_path: message.text
+        value: message_text
+        value_type: dynamic
+        required: true
+
+      # Env-based field (from OS environment)
+      - field_path: metadata.env
+        value: ENVIRONMENT
+        value_type: env
+        required: false
+
+    response_mapping:
+      - field_path: json.message
+        extract_as: sent_message
+      - field_path: headers.content-type
+        extract_as: content_type
+      - field_path: url
+        extract_as: request_url
+
+

levelapp/core/session.py

@@ -1,4 +1,5 @@
 """levelapp/core/session.py"""
+import asyncio
 import threading
 
 from abc import ABC
@@ -226,6 +227,13 @@ class EvaluationSession:
         with self.step(step_name=f"{self.session_name}.collect_results", category=MetricType.RESULTS_COLLECTION):
             self.workflow.collect_results()
 
+    def run_connectivity_test(self, context: Dict[str, Any]) -> Dict[str, Any]:
+        if not self.workflow:
+            raise RuntimeError(f"{self._NAME} Workflow not initialized")
+
+        results = asyncio.run(self.workflow.test_connection(context=context))
+        return results
+
     def get_stats(self) -> Dict[str, Any]:
         if self.enable_monitoring:
             return {