aiecs 1.5.1__py3-none-any.whl

aiecs/domain/knowledge_graph/schema/property_schema.py

@@ -0,0 +1,155 @@
+"""
+Property Schema Definition
+
+Defines the schema for properties that can be attached to entities and relations.
+"""
+
+from typing import Any, Optional, List
+from enum import Enum
+from pydantic import BaseModel, Field
+
+
+class PropertyType(str, Enum):
+    """Property data types"""
+
+    STRING = "string"
+    INTEGER = "integer"
+    FLOAT = "float"
+    BOOLEAN = "boolean"
+    DATE = "date"
+    DATETIME = "datetime"
+    LIST = "list"
+    DICT = "dict"
+    ANY = "any"
+
+
+class PropertySchema(BaseModel):
+    """
+    Property Schema Definition
+
+    Defines the schema for a single property that can be attached to
+    entities or relations in the knowledge graph.
+
+    Attributes:
+        name: Property name
+        property_type: Data type of the property
+        required: Whether the property is required
+        description: Human-readable description
+        default: Default value if not provided
+        allowed_values: List of allowed values (for enums)
+        min_value: Minimum value (for numeric types)
+        max_value: Maximum value (for numeric types)
+
+    Example:
+        ```python
+        prop = PropertySchema(
+            name="age",
+            property_type=PropertyType.INTEGER,
+            required=False,
+            description="Person's age in years",
+            min_value=0,
+            max_value=150
+        )
+        ```
+    """
+
+    name: str = Field(
+        ...,
+        description="Property name (must be unique within entity/relation type)",
+    )
+
+    property_type: PropertyType = Field(
+        default=PropertyType.STRING, description="Data type of the property"
+    )
+
+    required: bool = Field(default=False, description="Whether this property is required")
+
+    description: Optional[str] = Field(
+        default=None, description="Human-readable description of the property"
+    )
+
+    default: Optional[Any] = Field(
+        default=None, description="Default value if property is not provided"
+    )
+
+    allowed_values: Optional[List[Any]] = Field(
+        default=None,
+        description="List of allowed values (for enum-like properties)",
+    )
+
+    min_value: Optional[float] = Field(
+        default=None, description="Minimum value (for numeric types)"
+    )
+
+    max_value: Optional[float] = Field(
+        default=None, description="Maximum value (for numeric types)"
+    )
+
+    class Config:
+        use_enum_values = True
+
+    def validate_value(self, value: Any) -> bool:
+        """
+        Validate a value against this schema
+
+        Args:
+            value: Value to validate
+
+        Returns:
+            True if value is valid
+
+        Raises:
+            ValueError: If value doesn't match schema
+        """
+        if value is None:
+            if self.required:
+                raise ValueError(f"Property '{self.name}' is required but got None")
+            return True
+
+        # Type validation
+        if self.property_type == PropertyType.STRING:
+            if not isinstance(value, str):
+                raise ValueError(f"Property '{self.name}' must be string, got {type(value)}")
+
+        elif self.property_type == PropertyType.INTEGER:
+            if not isinstance(value, int) or isinstance(value, bool):
+                raise ValueError(f"Property '{self.name}' must be integer, got {type(value)}")
+
+        elif self.property_type == PropertyType.FLOAT:
+            if not isinstance(value, (int, float)) or isinstance(value, bool):
+                raise ValueError(f"Property '{self.name}' must be numeric, got {type(value)}")
+
+        elif self.property_type == PropertyType.BOOLEAN:
+            if not isinstance(value, bool):
+                raise ValueError(f"Property '{self.name}' must be boolean, got {type(value)}")
+
+        elif self.property_type == PropertyType.LIST:
+            if not isinstance(value, list):
+                raise ValueError(f"Property '{self.name}' must be list, got {type(value)}")
+
+        elif self.property_type == PropertyType.DICT:
+            if not isinstance(value, dict):
+                raise ValueError(f"Property '{self.name}' must be dict, got {type(value)}")
+
+        # Allowed values validation
+        if self.allowed_values is not None:
+            if value not in self.allowed_values:
+                raise ValueError(
+                    f"Property '{self.name}' value must be one of {self.allowed_values}, got {value}"
+                )
+
+        # Range validation for numeric types
+        if self.property_type in (PropertyType.INTEGER, PropertyType.FLOAT):
+            if self.min_value is not None and value < self.min_value:
+                raise ValueError(f"Property '{self.name}' must be >= {self.min_value}, got {value}")
+            if self.max_value is not None and value > self.max_value:
+                raise ValueError(f"Property '{self.name}' must be <= {self.max_value}, got {value}")
+
+        return True
+
+    def __str__(self) -> str:
+        required_str = " (required)" if self.required else ""
+        return f"PropertySchema(name='{self.name}', type={self.property_type}{required_str})"
+
+    def __repr__(self) -> str:
+        return self.__str__()

aiecs/domain/knowledge_graph/schema/relation_type.py

@@ -0,0 +1,171 @@
+"""
+Relation Type Schema Definition
+
+Defines the schema for relation types in the knowledge graph.
+"""
+
+from typing import Dict, List, Optional, Any
+from pydantic import BaseModel, Field
+from aiecs.domain.knowledge_graph.schema.property_schema import PropertySchema
+
+
+class RelationType(BaseModel):
+    """
+    Relation Type Schema
+
+    Defines the schema for a type of relation in the knowledge graph,
+    including source/target constraints and properties.
+
+    Attributes:
+        name: Relation type name (e.g., "WORKS_FOR", "KNOWS")
+        description: Human-readable description
+        properties: Dictionary of property schemas
+        source_entity_types: Allowed source entity types (None = any)
+        target_entity_types: Allowed target entity types (None = any)
+        is_symmetric: Whether the relation is symmetric (A->B implies B->A)
+        is_transitive: Whether the relation is transitive (A->B, B->C implies A->C)
+
+    Example:
+        ```python
+        works_for = RelationType(
+            name="WORKS_FOR",
+            description="Employment relationship",
+            source_entity_types=["Person"],
+            target_entity_types=["Company"],
+            properties={
+                "since": PropertySchema(name="since", property_type=PropertyType.DATE),
+                "role": PropertySchema(name="role", property_type=PropertyType.STRING),
+            }
+        )
+        ```
+    """
+
+    name: str = Field(..., description="Relation type name (must be unique)")
+
+    description: Optional[str] = Field(
+        default=None,
+        description="Human-readable description of this relation type",
+    )
+
+    properties: Dict[str, PropertySchema] = Field(
+        default_factory=dict,
+        description="Dictionary of property schemas (key=property name)",
+    )
+
+    source_entity_types: Optional[List[str]] = Field(
+        default=None,
+        description="Allowed source entity types (None = any type allowed)",
+    )
+
+    target_entity_types: Optional[List[str]] = Field(
+        default=None,
+        description="Allowed target entity types (None = any type allowed)",
+    )
+
+    is_symmetric: bool = Field(
+        default=False,
+        description="Whether relation is symmetric (A->B implies B->A)",
+    )
+
+    is_transitive: bool = Field(
+        default=False,
+        description="Whether relation is transitive (A->B, B->C implies A->C)",
+    )
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def add_property(self, prop: PropertySchema) -> None:
+        """
+        Add a property to this relation type
+
+        Args:
+            prop: Property schema to add
+        """
+        self.properties[prop.name] = prop
+
+    def remove_property(self, property_name: str) -> None:
+        """
+        Remove a property from this relation type
+
+        Args:
+            property_name: Name of property to remove
+        """
+        if property_name in self.properties:
+            del self.properties[property_name]
+
+    def get_property(self, property_name: str) -> Optional[PropertySchema]:
+        """
+        Get a property schema by name
+
+        Args:
+            property_name: Name of property to get
+
+        Returns:
+            Property schema or None if not found
+        """
+        return self.properties.get(property_name)
+
+    def validate_properties(self, properties: Dict[str, Any]) -> bool:
+        """
+        Validate a dictionary of properties against this schema
+
+        Args:
+            properties: Dictionary of properties to validate
+
+        Returns:
+            True if all properties are valid
+
+        Raises:
+            ValueError: If validation fails
+        """
+        # Check required properties
+        for prop_name, prop_schema in self.properties.items():
+            if prop_schema.required and prop_name not in properties:
+                raise ValueError(
+                    f"Required property '{prop_name}' missing for relation type '{self.name}'"
+                )
+
+        # Validate each provided property
+        for prop_name, prop_value in properties.items():
+            if prop_name in self.properties:
+                prop_schema = self.properties[prop_name]
+                prop_schema.validate_value(prop_value)
+
+        return True
+
+    def validate_entity_types(self, source_entity_type: str, target_entity_type: str) -> bool:
+        """
+        Validate that source and target entity types are allowed
+
+        Args:
+            source_entity_type: Source entity type name
+            target_entity_type: Target entity type name
+
+        Returns:
+            True if entity types are valid
+
+        Raises:
+            ValueError: If entity types are not allowed
+        """
+        if self.source_entity_types is not None:
+            if source_entity_type not in self.source_entity_types:
+                raise ValueError(
+                    f"Source entity type '{source_entity_type}' not allowed for "
+                    f"relation '{self.name}'. Allowed: {self.source_entity_types}"
+                )
+
+        if self.target_entity_types is not None:
+            if target_entity_type not in self.target_entity_types:
+                raise ValueError(
+                    f"Target entity type '{target_entity_type}' not allowed for "
+                    f"relation '{self.name}'. Allowed: {self.target_entity_types}"
+                )
+
+        return True
+
+    def __str__(self) -> str:
+        return f"RelationType(name='{self.name}', properties={len(self.properties)})"
+
+    def __repr__(self) -> str:
+        return self.__str__()