xlr-lib-types 0.1.1.dev9190__py3-none-any.whl

xlr_lib_types/deserializer.py

@@ -0,0 +1,316 @@
+"""
+Deserialization utilities for XLR nodes.
+Converts JSON strings back into proper XLR node objects.
+"""
+
+import json
+from typing import Any, Dict, Union
+from .nodes import (
+
+    # Simple types
+    AnyType, UnknownType, UndefinedType, NullType, VoidType, StringType,
+    NumberType, BooleanType, NeverType, TemplateLiteralType,
+
+    # Complex types
+    RefType, ObjectType, ArrayType, TupleType, AndType, OrType,
+    RecordType, FunctionType, ConditionalType,
+
+    # Helper classes
+    ObjectProperty, TupleMember, FunctionTypeParameters, ParamTypeNode,
+    NamedType, NamedTypeWithGenerics,
+
+    # Type unions
+    NodeType
+)
+
+
+def deserialize_xlr_node(json_string: str) -> NodeType:
+    """
+    Deserialize a JSON string into an XLR node object.
+    
+    Uses Python's built-in json library with the loads function and object_hook
+    parameter to pass in custom deserialization logic.
+    
+    Args:
+        json_string: JSON string representation of an XLR node
+        
+    Returns:
+        The deserialized XLR node object
+        
+    Raises:
+        ValueError: If the JSON cannot be deserialized or contains invalid node types
+        json.JSONDecodeError: If the JSON string is malformed
+    """
+    return json.loads(json_string, object_hook=_deserialize_object_hook)
+
+
+def _deserialize_object_hook(obj: Dict[str, Any]) -> Any:
+    """
+    Object hook function for JSON deserialization.
+    
+    This function is called for every JSON object during deserialization
+    and converts dictionaries with type information into appropriate XLR node objects.
+    
+    Args:
+        obj: Dictionary from JSON parsing
+        
+    Returns:
+        Either the original dict or a deserialized XLR node object
+    """
+    # Handle special helper classes first (they don't have a "type" field)
+    if _is_named_type(obj):
+        return _deserialize_named_type(obj)
+    elif _is_object_property(obj):
+        return _deserialize_object_property(obj)
+    elif _is_function_type_parameter(obj):
+        return _deserialize_function_type_parameter(obj)
+    elif _is_param_type_node(obj):
+        return _deserialize_param_type_node(obj)
+
+    # Handle main node types based on "type" field
+    node_type = obj.get("type")
+    if not node_type or not isinstance(node_type, str):
+        return obj  # Not an XLR node, return as-is
+
+    try:
+        return _deserialize_by_type(node_type, obj)
+    except Exception as e:
+        raise ValueError(f"Failed to deserialize node of type '{node_type}': {e}") from e
+
+
+def _deserialize_by_type(node_type: str, obj: Dict[str, Any]) -> NodeType:
+    """Deserialize based on the node type."""
+    type_map = {
+        "any": _deserialize_any_type,
+        "unknown": _deserialize_unknown_type,
+        "undefined": _deserialize_undefined_type,
+        "null": _deserialize_null_type,
+        "void": _deserialize_void_type,
+        "string": _deserialize_string_type,
+        "number": _deserialize_number_type,
+        "boolean": _deserialize_boolean_type,
+        "never": _deserialize_never_type,
+        "ref": _deserialize_ref_type,
+        "object": _deserialize_object_type,
+        "array": _deserialize_array_type,
+        "tuple": _deserialize_tuple_type,
+        "and": _deserialize_and_type,
+        "or": _deserialize_or_type,
+        "template": _deserialize_template_literal_type,
+        "record": _deserialize_record_type,
+        "function": _deserialize_function_type,
+        "conditional": _deserialize_conditional_type,
+    }
+
+    deserializer = type_map.get(node_type)
+    if not deserializer:
+        raise ValueError(f"Unknown node type: {node_type}")
+
+    return deserializer(obj)
+
+
+# Simple type deserializers
+def _deserialize_any_type(obj: Dict[str, Any]) -> AnyType:
+    return AnyType(**_extract_common_props(obj))
+
+def _deserialize_unknown_type(obj: Dict[str, Any]) -> UnknownType:
+    return UnknownType(**_extract_common_props(obj))
+
+def _deserialize_undefined_type(obj: Dict[str, Any]) -> UndefinedType:
+    return UndefinedType(**_extract_common_props(obj))
+
+def _deserialize_null_type(obj: Dict[str, Any]) -> NullType:
+    return NullType(**_extract_common_props(obj))
+
+def _deserialize_void_type(obj: Dict[str, Any]) -> VoidType:
+    return VoidType(**_extract_common_props(obj))
+
+def _deserialize_string_type(obj: Dict[str, Any]) -> StringType:
+    return StringType(**_extract_common_props(obj))
+
+def _deserialize_number_type(obj: Dict[str, Any]) -> NumberType:
+    return NumberType(**_extract_common_props(obj))
+
+def _deserialize_boolean_type(obj: Dict[str, Any]) -> BooleanType:
+    return BooleanType(**_extract_common_props(obj))
+
+def _deserialize_never_type(obj: Dict[str, Any]) -> NeverType:
+    return NeverType(**_extract_common_props(obj))
+
+
+# Complex type deserializers
+def _deserialize_ref_type(obj: Dict[str, Any]) -> RefType:
+    kwargs = _extract_annotation_props(obj)
+    kwargs['ref'] = obj['ref']
+    if 'genericArguments' in obj:
+        kwargs['genericArguments'] = obj['genericArguments']
+    if 'property' in obj:
+        kwargs['property'] = obj['property']
+    return RefType(**kwargs)
+
+def _deserialize_object_type(obj: Dict[str, Any]) -> ObjectType:
+    kwargs = _extract_common_props(obj)
+    kwargs['properties'] = obj.get('properties', {})
+    if 'extends' in obj:
+        kwargs['extends'] = obj['extends']
+    if 'additionalProperties' in obj:
+        kwargs['additionalProperties'] = obj['additionalProperties']
+    return ObjectType(**kwargs)
+
+def _deserialize_array_type(obj: Dict[str, Any]) -> ArrayType:
+    kwargs = _extract_common_props(obj)
+    kwargs['elementType'] = obj['elementType']
+    return ArrayType(**kwargs)
+
+def _deserialize_tuple_type(obj: Dict[str, Any]) -> TupleType:
+    kwargs = _extract_common_props(obj)
+    kwargs['elementTypes'] = obj['elementTypes']
+    kwargs['minItems'] = obj['minItems']
+    if 'additionalItems' in obj:
+        kwargs['additionalItems'] = obj['additionalItems']
+    return TupleType(**kwargs)
+
+def _deserialize_and_type(obj: Dict[str, Any]) -> AndType:
+    kwargs = _extract_annotation_props(obj)
+    kwargs['and_types'] = obj.get('and', obj.get('and_types', []))
+    return AndType(**kwargs)
+
+def _deserialize_or_type(obj: Dict[str, Any]) -> OrType:
+    kwargs = _extract_annotation_props(obj)
+    kwargs['or_types'] = obj.get('or', obj.get('or_types', []))
+    return OrType(**kwargs)
+
+def _deserialize_template_literal_type(obj: Dict[str, Any]) -> TemplateLiteralType:
+    kwargs = _extract_annotation_props(obj)
+    kwargs['format'] = obj['format']
+    return TemplateLiteralType(**kwargs)
+
+def _deserialize_record_type(obj: Dict[str, Any]) -> RecordType:
+    kwargs = _extract_annotation_props(obj)
+    kwargs['keyType'] = obj['keyType']
+    kwargs['valueType'] = obj['valueType']
+    return RecordType(**kwargs)
+
+def _deserialize_function_type(obj: Dict[str, Any]) -> FunctionType:
+    kwargs = _extract_annotation_props(obj)
+    kwargs['parameters'] = obj.get('parameters', [])
+    if 'returnType' in obj:
+        kwargs['returnType'] = obj['returnType']
+    return FunctionType(**kwargs)
+
+def _deserialize_conditional_type(obj: Dict[str, Any]) -> ConditionalType:
+    kwargs = _extract_annotation_props(obj)
+    kwargs['check'] = obj['check']
+    kwargs['value'] = obj['value']
+    return ConditionalType(**kwargs)
+
+
+# Helper class deserializers
+def _deserialize_object_property(obj: Dict[str, Any]) -> ObjectProperty:
+    return ObjectProperty(
+        required=obj['required'],
+        node=obj['node']
+    )
+
+def _deserialize_tuple_member(obj: Dict[str, Any]) -> TupleMember:
+    kwargs = {'type': obj['type']}
+    if 'name' in obj:
+        kwargs['name'] = obj['name']
+    if 'optional' in obj:
+        kwargs['optional'] = obj['optional']
+    return TupleMember(**kwargs)
+
+def _deserialize_function_type_parameter(obj: Dict[str, Any]) -> FunctionTypeParameters:
+    kwargs = {
+        'name': obj['name'],
+        'type': obj['type']
+    }
+    if 'optional' in obj:
+        kwargs['optional'] = obj['optional']
+    if 'default' in obj:
+        kwargs['default'] = obj['default']
+    return FunctionTypeParameters(**kwargs)
+
+def _deserialize_param_type_node(obj: Dict[str, Any]) -> ParamTypeNode:
+    kwargs = {'symbol': obj['symbol']}
+    if 'constraints' in obj:
+        kwargs['constraints'] = obj['constraints']
+    if 'default' in obj:
+        kwargs['default'] = obj['default']
+    return ParamTypeNode(**kwargs)
+
+def _deserialize_named_type(obj: Dict[str, Any]) -> Union[NamedType, NamedTypeWithGenerics]:
+    # Extract the base node data (everything except name, source, and genericTokens)
+    base_obj = {
+        k: v for k,
+        v in obj.items() if k not in ['name', 'typeName', 'source', 'genericTokens']
+    }
+
+    # Extract annotation properties for the NamedType wrapper
+    annotation_kwargs = _extract_annotation_props(obj)
+    name = obj.get('name', obj.get('typeName', annotation_kwargs.get('name', "")))
+    if 'name' in annotation_kwargs:
+        del annotation_kwargs['name']
+
+    source = obj['source']
+
+    # Deserialize the base node using the object hook recursively
+    # We need to be careful not to create infinite recursion
+    base_node = _deserialize_object_hook(base_obj)
+
+    if 'genericTokens' in obj:
+        return NamedTypeWithGenerics(
+            base_node,
+            name,
+            source,
+            obj['genericTokens'],
+            **annotation_kwargs
+        )
+    else:
+        return NamedType(base_node, name, source, **annotation_kwargs)
+
+
+# Helper functions for identifying object types
+def _is_object_property(obj: Dict[str, Any]) -> bool:
+    return 'required' in obj and 'node' in obj and 'type' not in obj
+
+def _is_tuple_member(obj: Dict[str, Any]) -> bool:
+    return 'type' in obj and \
+        ('name' in obj or 'optional' in obj) and \
+        not isinstance(obj.get('type'), str)
+
+def _is_function_type_parameter(obj: Dict[str, Any]) -> bool:
+    return 'name' in obj and 'type' in obj and \
+        ('optional' in obj or 'default' in obj) and \
+        not isinstance(obj.get('type'), str)
+
+def _is_param_type_node(obj: Dict[str, Any]) -> bool:
+    return 'symbol' in obj and ('constraints' in obj or 'default' in obj)
+
+def _is_named_type(obj: Dict[str, Any]) -> bool:
+    return 'name' in obj and 'source' in obj
+
+
+# Property extraction helpers
+def _extract_annotation_props(obj: Dict[str, Any]) -> Dict[str, Any]:
+    """Extract annotation properties from object."""
+    annotation_keys = [
+        'name',
+        'title',
+        'description',
+        'examples',
+        'default',
+        'see',
+        'comment',
+        'meta'
+    ]
+    return {k: v for k, v in obj.items() if k in annotation_keys}
+
+def _extract_common_props(obj: Dict[str, Any]) -> Dict[str, Any]:
+    """Extract common properties (annotations + const + enum) from object."""
+    props = _extract_annotation_props(obj)
+    if 'const' in obj:
+        props['const'] = obj['const']
+    if 'enum' in obj:
+        props['enum'] = obj['enum']
+    return props

xlr_lib_types/guards.py

@@ -0,0 +1,171 @@
+"""
+Type Guard Functions that provide type narrowing capabilities for TypeScript-like type checking
+"""
+
+from typing import TypeGuard, Any, Union
+from .nodes import (
+    AndType,
+    AnyType,
+    ArrayNode,
+    ArrayType,
+    BooleanType,
+    ConditionalNode,
+    ConditionalType,
+    FunctionType,
+    NamedType,
+    NamedTypeWithGenerics,
+    NeverType,
+    NodeType,
+    NullType,
+    NumberType,
+    ObjectNode,
+    ObjectType,
+    OrType,
+    PrimitiveTypes,
+    RecordType,
+    RefNode,
+    RefType,
+    StringType,
+    TemplateLiteralType,
+    TupleNode,
+    TupleType,
+    TypeNode,
+    UndefinedType,
+    UnknownType,
+    VoidType
+)
+
+
+def is_any_type(obj: Any) -> TypeGuard[AnyType]:
+    """Type guard for AnyType nodes."""
+    return isinstance(obj, AnyType)
+
+def is_unknown_type(obj: Any) -> TypeGuard[UnknownType]:
+    """Type guard for UnknownType nodes."""
+    return isinstance(obj, UnknownType)
+
+def is_undefined_type(obj: Any) -> TypeGuard[UndefinedType]:
+    """Type guard for UndefinedType nodes."""
+    return isinstance(obj, UndefinedType)
+
+def is_null_type(obj: Any) -> TypeGuard[NullType]:
+    """Type guard for NullType nodes."""
+    return isinstance(obj, NullType)
+
+def is_void_type(obj: Any) -> TypeGuard[VoidType]:
+    """Type guard for VoidType nodes."""
+    return isinstance(obj, VoidType)
+
+def is_string_type(obj: Any) -> TypeGuard[StringType]:
+    """Type guard for StringType nodes."""
+    return isinstance(obj, StringType)
+
+def is_number_type(obj: Any) -> TypeGuard[NumberType]:
+    """Type guard for NumberType nodes."""
+    return isinstance(obj, NumberType)
+
+def is_boolean_type(obj: Any) -> TypeGuard[BooleanType]:
+    """Type guard for BooleanType nodes."""
+    return isinstance(obj, BooleanType)
+
+def is_never_type(obj: Any) -> TypeGuard[NeverType]:
+    """Type guard for NeverType nodes."""
+    return isinstance(obj, NeverType)
+
+def is_ref_node(obj: Any) -> TypeGuard[RefNode]:
+    """Type guard for RefNode nodes."""
+    return isinstance(obj, RefNode)
+
+def is_ref_type(obj: Any) -> TypeGuard[RefType]:
+    """Type guard for RefType nodes."""
+    return isinstance(obj, RefType)
+
+def is_object_node(obj: Any) -> TypeGuard[ObjectNode]:
+    """Type guard for ObjectNode nodes."""
+    return isinstance(obj, ObjectNode)
+
+def is_object_type(obj: Any) -> TypeGuard[ObjectType]:
+    """Type guard for ObjectType nodes."""
+    return isinstance(obj, ObjectType) or (is_named_type(obj) and is_object_type(obj.base_node))
+
+def is_array_node(obj: Any) -> TypeGuard[ArrayNode]:
+    """Type guard for ArrayNode nodes."""
+    return isinstance(obj, ArrayNode)
+
+def is_array_type(obj: Any) -> TypeGuard[ArrayType]:
+    """Type guard for ArrayType nodes."""
+    return isinstance(obj, ArrayType) or (is_named_type(obj) and is_array_type(obj.base_node))
+
+def is_conditional_node(obj: Any) -> TypeGuard[ConditionalNode]:
+    """Type guard for ConditionalNode nodes."""
+    return isinstance(obj, ConditionalNode)
+
+def is_conditional_type(obj: Any) -> TypeGuard[ConditionalType]:
+    """Type guard for ConditionalType nodes."""
+    return isinstance(obj, ConditionalType)
+
+def is_tuple_node(obj: Any) -> TypeGuard[TupleNode]:
+    """Type guard for TupleNode nodes."""
+    return isinstance(obj, TupleNode)
+
+def is_tuple_type(obj: Any) -> TypeGuard[TupleType]:
+    """Type guard for TupleType nodes."""
+    return isinstance(obj, TupleType)
+
+def is_and_type(obj: Any) -> TypeGuard[AndType]:
+    """Type guard for AndType (intersection) nodes."""
+    return isinstance(obj, AndType)
+
+def is_or_type(obj: Any) -> TypeGuard[OrType]:
+    """Type guard for OrType (union) nodes."""
+    return isinstance(obj, OrType) or (is_named_type(obj) and is_or_type(obj.base_node))
+
+def is_template_literal_type(obj: Any) -> TypeGuard[TemplateLiteralType]:
+    """Type guard for TemplateLiteralType nodes."""
+    return isinstance(obj, TemplateLiteralType)
+
+def is_record_type(obj: Any) -> TypeGuard[RecordType]:
+    """Type guard for RecordType nodes."""
+    return isinstance(obj, RecordType)
+
+def is_function_type(obj: Any) -> TypeGuard[FunctionType]:
+    """Type guard for FunctionType nodes."""
+    return isinstance(obj, FunctionType)
+
+def is_type_node(obj: Any) -> TypeGuard[TypeNode]:
+    """Type guard for any TypeNode (base class)."""
+    return isinstance(obj, TypeNode)
+
+def is_node_type(obj: Any) -> TypeGuard[NodeType]:
+    """Type guard for any NodeType union member."""
+    return (is_any_type(obj) or is_unknown_type(obj) or is_undefined_type(obj) or
+            is_null_type(obj) or is_never_type(obj) or is_string_type(obj) or
+            is_template_literal_type(obj) or is_number_type(obj) or is_boolean_type(obj) or
+            is_object_type(obj) or is_array_type(obj) or is_tuple_type(obj) or
+            is_record_type(obj) or is_and_type(obj) or is_or_type(obj) or
+            is_ref_type(obj) or is_function_type(obj) or is_conditional_type(obj) or
+            is_void_type(obj))
+
+def is_named_type(obj: Any) -> TypeGuard[NamedType]:
+    """ Type guard for NamedType nodes."""
+    return isinstance(obj, NamedType) or isinstance(obj, NamedTypeWithGenerics)
+
+def is_named_type_with_generics(obj:Any) -> TypeGuard[NamedTypeWithGenerics]:
+    """ Type guard for NamedTypeWithGeneric nodes."""
+    return isinstance(obj, NamedTypeWithGenerics)
+
+def is_primitive_type(obj:Any) -> TypeGuard[PrimitiveTypes]:
+    """ Type guard for Primitive nodes."""
+    return is_never_type(obj) or \
+        is_null_type(obj) or \
+        is_string_type(obj) or \
+        is_number_type(obj) or \
+        is_boolean_type(obj) or \
+        is_any_type(obj) or \
+        is_unknown_type(obj) or \
+        is_undefined_type(obj) or \
+        is_void_type(obj)
+
+def is_primitive_const(obj:Any) -> TypeGuard[Union[StringType, NumberType, BooleanType]]:
+    """ Type guard for Primitive nodes with const values."""
+    return is_primitive_type(obj) and obj.const is not None

xlr_lib_types/nodes.py

@@ -0,0 +1,895 @@
+"""
+Python equivalent of TypeScript interfaces for XLR Nodes
+"""
+
+from typing import Any, Dict, List, Mapping, Optional, Union, Generic, TypeVar
+
+T = TypeVar('T', bound='TypeNode')
+
+class Annotations:
+    """The name used to reference this type"""
+
+    def __init__(self,
+                 name: Optional[str] = None,
+                 title: Optional[str] = None,
+                 description: Optional[str] = None,
+                 examples: Optional[Union[str, List[str]]] = None,
+                 default: Optional[str] = None,
+                 see: Optional[Union[str, List[str]]] = None,
+                 comment: Optional[str] = None,
+                 meta: Optional[Dict[str, str]] = None):
+        self._name = name
+        self._title = title
+        self._description = description
+        self._examples = examples
+        self._default = default
+        self._see = see
+        self._comment = comment
+        self._meta = meta
+
+    @property
+    def name(self) -> Optional[str]:
+        """The name used to reference this type"""
+        return self._name
+
+    @name.setter
+    def name(self, value: Optional[str]) -> None:
+        self._name = value
+
+    @property
+    def title(self) -> Optional[str]:
+        """The path within a type to this type (may be the same as `name`)"""
+        return self._title
+
+    @title.setter
+    def title(self, value: Optional[str]) -> None:
+        self._title = value
+
+    @property
+    def description(self) -> Optional[str]:
+        """The JSDoc string for this type"""
+        return self._description
+
+    @description.setter
+    def description(self, value: Optional[str]) -> None:
+        self._description = value
+
+    @property
+    def examples(self) -> Optional[Union[str, List[str]]]:
+        """The JSDoc `@example` string for this type"""
+        return self._examples
+
+    @examples.setter
+    def examples(self, value: Optional[Union[str, List[str]]]) -> None:
+        self._examples = value
+
+    @property
+    def default(self) -> Optional[str]:
+        """The JSDoc `@default` string for this type"""
+        return self._default
+
+    @default.setter
+    def default(self, value: Optional[str]) -> None:
+        self._default = value
+
+    @property
+    def see(self) -> Optional[Union[str, List[str]]]:
+        """The JSDoc `@see` string for this type"""
+        return self._see
+
+    @see.setter
+    def see(self, value: Optional[Union[str, List[str]]]) -> None:
+        self._see = value
+
+    @property
+    def comment(self) -> Optional[str]:
+        """The Typescript comment associated with the type"""
+        return self._comment
+
+    @comment.setter
+    def comment(self, value: Optional[str]) -> None:
+        self._comment = value
+
+    @property
+    def meta(self) -> Optional[Dict[str, str]]:
+        """The JSDoc `@meta` string for this type"""
+        return self._meta
+
+    @meta.setter
+    def meta(self, value: Optional[Dict[str, str]]) -> None:
+        self._meta = value
+
+
+class Const:
+    """Generic const interface"""
+
+    def __init__(self, const: Optional[Any] = None):
+        self._const = const
+
+    @property
+    def const(self) -> Optional[Any]:
+        """The literal value for the node"""
+        return self._const
+
+    @const.setter
+    def const(self, value: Optional[Any]) -> None:
+        self._const = value
+
+
+class Enum:
+    """Generic enum interface"""
+
+    def __init__(self, enum: Optional[List[Any]] = None):
+        self._enum = enum
+
+    @property
+    def enum(self) -> Optional[List[Any]]:
+        """The list of enums for the node"""
+        return self._enum
+
+    @enum.setter
+    def enum(self, value: Optional[List[Any]]) -> None:
+        self._enum = value
+
+
+class CommonTypeInfo(Const, Enum):
+    """Common type information combining Const and Enum"""
+
+    def __init__(self, const: Optional[Any] = None, enum: Optional[List[Any]] = None):
+        Const.__init__(self, const)
+        Enum.__init__(self, enum)
+
+
+class TypeNode:
+    """Base type node with type identifier"""
+
+    def __init__(self, type_name: str):
+        self._type = type_name
+
+    @property
+    def type(self) -> str:
+        """The type of Node"""
+        return self._type
+
+    @type.setter
+    def type(self, value: str) -> None:
+        self._type = value
+
+
+class AnyType(TypeNode, CommonTypeInfo, Annotations):
+    """Any type implementation"""
+
+    def __init__(self, **kwargs):
+        TypeNode.__init__(self, "any")
+        CommonTypeInfo.__init__(self, kwargs.get('const'), kwargs.get('enum'))
+        Annotations.__init__(self,
+                             **{k: v for k, v in kwargs.items() if k not in ['const', 'enum']}
+                            )
+
+
+class UnknownType(TypeNode, CommonTypeInfo, Annotations):
+    """Unknown type implementation"""
+
+    def __init__(self, **kwargs):
+        TypeNode.__init__(self, "unknown")
+        CommonTypeInfo.__init__(self, kwargs.get('const'), kwargs.get('enum'))
+        Annotations.__init__(self,
+                             **{k: v for k, v in kwargs.items() if k not in ['const', 'enum']}
+                            )
+
+
+class UndefinedType(TypeNode, CommonTypeInfo, Annotations):
+    """Undefined type implementation"""
+
+    def __init__(self, **kwargs):
+        TypeNode.__init__(self, "undefined")
+        CommonTypeInfo.__init__(self, kwargs.get('const'), kwargs.get('enum'))
+        Annotations.__init__(self,
+                             **{k: v for k, v in kwargs.items() if k not in ['const', 'enum']}
+                            )
+
+
+class NullType(TypeNode, CommonTypeInfo, Annotations):
+    """Null type implementation"""
+
+    def __init__(self, **kwargs):
+        TypeNode.__init__(self, "null")
+        CommonTypeInfo.__init__(self, kwargs.get('const'), kwargs.get('enum'))
+        Annotations.__init__(self,
+                             **{k: v for k, v in kwargs.items() if k not in ['const', 'enum']}
+                            )
+
+
+class VoidType(TypeNode, CommonTypeInfo, Annotations):
+    """Void type implementation"""
+
+    def __init__(self, **kwargs):
+        TypeNode.__init__(self, "void")
+        CommonTypeInfo.__init__(self, kwargs.get('const'), kwargs.get('enum'))
+        Annotations.__init__(self,
+                             **{k: v for k, v in kwargs.items() if k not in ['const', 'enum']}
+                            )
+
+
+class StringType(TypeNode, CommonTypeInfo, Annotations):
+    """String type implementation"""
+
+    def __init__(self, **kwargs):
+        TypeNode.__init__(self, "string")
+        CommonTypeInfo.__init__(self, kwargs.get('const'), kwargs.get('enum'))
+        Annotations.__init__(self,
+                             **{k: v for k, v in kwargs.items() if k not in ['const', 'enum']}
+                            )
+
+
+class NumberType(TypeNode, CommonTypeInfo, Annotations):
+    """Number type implementation"""
+
+    def __init__(self, **kwargs):
+        TypeNode.__init__(self, "number")
+        CommonTypeInfo.__init__(self, kwargs.get('const'), kwargs.get('enum'))
+        Annotations.__init__(self,
+                             **{k: v for k, v in kwargs.items() if k not in ['const', 'enum']}
+                            )
+
+
+class BooleanType(TypeNode, CommonTypeInfo, Annotations):
+    """Boolean type implementation"""
+
+    def __init__(self, **kwargs):
+        TypeNode.__init__(self, "boolean")
+        CommonTypeInfo.__init__(self, kwargs.get('const'), kwargs.get('enum'))
+        Annotations.__init__(self,
+                             **{k: v for k, v in kwargs.items() if k not in ['const', 'enum']}
+                            )
+
+
+class NeverType(TypeNode, CommonTypeInfo, Annotations):
+    """Never type implementation"""
+
+    def __init__(self, **kwargs):
+        TypeNode.__init__(self, "never")
+        CommonTypeInfo.__init__(self, kwargs.get('const'), kwargs.get('enum'))
+        Annotations.__init__(self,
+                             **{k: v for k, v in kwargs.items() if k not in ['const', 'enum']}
+                            )
+
+
+class RefNode(TypeNode):
+    """Reference node implementation"""
+
+    def __init__(
+            self,
+            ref: str,
+            genericArguments: Optional[List['NodeType']] = None,
+            property: Optional[str] = None
+        ):
+        super().__init__("ref")
+        self._ref = ref
+        self._genericArguments = genericArguments
+        self._property = property
+
+    @property
+    def ref(self) -> str:
+        """Name of the referenced Type"""
+        return self._ref
+
+    @ref.setter
+    def ref(self, value: str) -> None:
+        self._ref = value
+
+    @property
+    def genericArguments(self) -> Optional[List['NodeType']]:
+        """Parameters to potentially fill in a generic when it is resolved"""
+        return self._genericArguments
+
+    @genericArguments.setter
+    def genericArguments(self, value: Optional[List['NodeType']]) -> None:
+        self._genericArguments = value
+
+    @property
+    def property(self) -> Optional[str]:
+        """Optional property to access when the reference is resolved"""
+        return self._property
+
+    @property.setter
+    def property(self, value: Optional[str]) -> None:
+        self._property = value
+
+
+class RefType(RefNode, Annotations):
+    """Reference type with annotations"""
+
+    def __init__(
+            self,
+            ref: str,
+            genericArguments: Optional[List['NodeType']] = None,
+            property: Optional[str] = None,
+            **kwargs
+        ):
+        RefNode.__init__(self, ref, genericArguments, property)
+        Annotations.__init__(self, **kwargs)
+
+
+class ObjectProperty:
+    """Object property definition"""
+
+    def __init__(self, required: bool, node: 'NodeType'):
+        self._required = required
+        self._node = node
+
+    @property
+    def required(self) -> bool:
+        """If this property is required"""
+        return self._required
+
+    @required.setter
+    def required(self, value: bool) -> None:
+        self._required = value
+
+    @property
+    def node(self) -> 'NodeType':
+        """The type of the property"""
+        return self._node
+
+    @node.setter
+    def node(self, value: 'NodeType') -> None:
+        self._node = value
+
+
+class ObjectNode(TypeNode):
+    """Object node implementation"""
+
+    def __init__(
+            self,
+            properties: Dict[str, ObjectProperty],
+            extends: Optional[RefType] = None,
+            additionalProperties: Union[bool, 'NodeType'] = False
+        ):
+        super().__init__("object")
+        self._properties = properties
+        self._extends = extends
+        self._additionalProperties = additionalProperties
+
+    @property
+    def properties(self) -> Dict[str, ObjectProperty]:
+        """The properties associated with an object"""
+        return self._properties
+
+    @properties.setter
+    def properties(self, value: Dict[str, ObjectProperty]) -> None:
+        self._properties = value
+
+    @property
+    def extends(self) -> Optional[RefType]:
+        """A custom primitive that this object extends that is to be resolved when used"""
+        return self._extends
+
+    @extends.setter
+    def extends(self, value: Optional[RefType]) -> None:
+        self._extends = value
+
+    @property
+    def additionalProperties(self) -> Union[bool, 'NodeType']:
+        """What type, if any, of additional properties are allowed on the object"""
+        return self._additionalProperties
+
+    @additionalProperties.setter
+    def additionalProperties(self, value: Union[bool, 'NodeType']) -> None:
+        self._additionalProperties = value
+
+
+class ObjectType(ObjectNode, CommonTypeInfo, Annotations):
+    """Object type with annotations"""
+
+    def __init__(
+            self,
+            properties: Dict[str, ObjectProperty],
+            extends: Optional[RefType] = None,
+            additionalProperties: Union[bool, 'NodeType'] = False,
+            **kwargs
+        ):
+        ObjectNode.__init__(self, properties, extends, additionalProperties)
+        CommonTypeInfo.__init__(self, kwargs.get('const'), kwargs.get('enum'))
+        Annotations.__init__(self,
+                             **{k: v for k, v in kwargs.items() if k not in ['const', 'enum']}
+                            )
+
+
+class ArrayNode(TypeNode):
+    """Array node implementation"""
+
+    def __init__(self, elementType: 'NodeType'):
+        super().__init__("array")
+        self._elementType = elementType
+
+    @property
+    def elementType(self) -> 'NodeType':
+        """What types are allowed in the array"""
+        return self._elementType
+
+    @elementType.setter
+    def elementType(self, value: 'NodeType') -> None:
+        self._elementType = value
+
+
+class ArrayType(ArrayNode, CommonTypeInfo, Annotations):
+    """Array type with annotations"""
+
+    def __init__(self, elementType: 'NodeType', **kwargs):
+        ArrayNode.__init__(self, elementType)
+        CommonTypeInfo.__init__(self, kwargs.get('const'), kwargs.get('enum'))
+        Annotations.__init__(self,
+                             **{k: v for k, v in kwargs.items() if k not in ['const', 'enum']}
+                            )
+
+
+class ConditionalNode(TypeNode):
+    """Conditional node implementation"""
+
+    def __init__(self, check: Mapping[str, 'NodeType'], value: Mapping[str, 'NodeType']):
+        super().__init__("conditional")
+        self._check = check
+        self._value = value
+
+    @property
+    def check(self) -> Mapping[str, 'NodeType']:
+        """The check arguments"""
+        return self._check
+
+    @check.setter
+    def check(self, value: Mapping[str, 'NodeType']) -> None:
+        self._check = value
+
+    @property
+    def value(self) -> Mapping[str, 'NodeType']:
+        """The resulting values to use"""
+        return self._value
+
+    @value.setter
+    def value(self, value: Mapping[str, 'NodeType']) -> None:
+        self._value = value
+
+
+class ConditionalType(ConditionalNode, Annotations):
+    """Conditional type with annotations"""
+
+    def __init__(self, check: Mapping[str, 'NodeType'], value: Mapping[str, 'NodeType'], **kwargs):
+        ConditionalNode.__init__(self, check, value)
+        Annotations.__init__(self, **kwargs)
+
+
+class TupleMember:
+    """Tuple member definition"""
+
+    def __init__(
+            self,
+            type: 'NodeType',
+            name: Optional[str] = None,
+            optional: Optional[bool] = None
+        ):
+        self._name = name
+        self._type = type
+        self._optional = optional
+
+    @property
+    def name(self) -> Optional[str]:
+        """Optional Name of the Tuple Member"""
+        return self._name
+
+    @name.setter
+    def name(self, value: Optional[str]) -> None:
+        self._name = value
+
+    @property
+    def type(self) -> 'NodeType':
+        """Type constraint of the Tuple Member"""
+        return self._type
+
+    @type.setter
+    def type(self, value: 'NodeType') -> None:
+        self._type = value
+
+    @property
+    def optional(self) -> Optional[bool]:
+        """Is the Tuple Member Optional"""
+        return self._optional
+
+    @optional.setter
+    def optional(self, value: Optional[bool]) -> None:
+        self._optional = value
+
+
+class TupleNode(TypeNode):
+    """Tuple node implementation"""
+
+    def __init__(
+            self,
+            elementTypes: List[TupleMember],
+            minItems: int,
+            additionalItems: Union[bool, 'NodeType'] = False
+        ):
+        super().__init__("tuple")
+        self._elementTypes = elementTypes
+        self._minItems = minItems
+        self._additionalItems = additionalItems
+
+    @property
+    def elementTypes(self) -> List[TupleMember]:
+        """The types in the tuple"""
+        return self._elementTypes
+
+    @elementTypes.setter
+    def elementTypes(self, value: List[TupleMember]) -> None:
+        self._elementTypes = value
+
+    @property
+    def minItems(self) -> int:
+        """The minimum number of items"""
+        return self._minItems
+
+    @minItems.setter
+    def minItems(self, value: int) -> None:
+        self._minItems = value
+
+    @property
+    def additionalItems(self) -> Union[bool, 'NodeType']:
+        """What, if any, additional types can be provided"""
+        return self._additionalItems
+
+    @additionalItems.setter
+    def additionalItems(self, value: Union[bool, 'NodeType']) -> None:
+        self._additionalItems = value
+
+
+class TupleType(TupleNode, CommonTypeInfo, Annotations):
+    """Tuple type with annotations"""
+
+    def __init__(
+            self,
+            elementTypes: List[TupleMember],
+            minItems: int,
+            additionalItems: Union[bool, 'NodeType'] = False,
+            **kwargs
+        ):
+        TupleNode.__init__(self, elementTypes, minItems, additionalItems)
+        CommonTypeInfo.__init__(self, kwargs.get('const'), kwargs.get('enum'))
+        Annotations.__init__(self,
+                             **{k: v for k, v in kwargs.items() if k not in ['const', 'enum']}
+                            )
+
+
+class AndType(TypeNode, Annotations):
+    """And/Intersection type"""
+
+    def __init__(self, and_types: List['NodeType'], **kwargs):
+        super().__init__("and")
+        self._and = and_types
+        Annotations.__init__(self, **kwargs)
+
+    @property
+    def and_types(self) -> List['NodeType']:
+        """Nodes in intersection"""
+        return self._and
+
+    @and_types.setter
+    def and_types(self, value: List['NodeType']) -> None:
+        self._and = value
+
+
+class OrType(TypeNode, Annotations):
+    """Or/Union type"""
+
+    def __init__(self, or_types: List['NodeType'], **kwargs):
+        super().__init__("or")
+        self._or = or_types
+        Annotations.__init__(self, **kwargs)
+
+    @property
+    def or_types(self) -> List['NodeType']:
+        """Nodes in the union"""
+        return self._or
+
+    @or_types.setter
+    def or_types(self, value: List['NodeType']) -> None:
+        self._or = value
+
+
+class TemplateLiteralType(TypeNode, Annotations):
+    """Template literal type"""
+
+    def __init__(self, format: str, **kwargs):
+        super().__init__("template")
+        self._format = format
+        Annotations.__init__(self, **kwargs)
+
+    @property
+    def format(self) -> str:
+        """String version of regex used to validate template"""
+        return self._format
+
+    @format.setter
+    def format(self, value: str) -> None:
+        self._format = value
+
+
+class RecordType(TypeNode, Annotations):
+    """Record type"""
+
+    def __init__(self, keyType: 'NodeType', valueType: 'NodeType', **kwargs):
+        super().__init__("record")
+        self._keyType = keyType
+        self._valueType = valueType
+        Annotations.__init__(self, **kwargs)
+
+    @property
+    def keyType(self) -> 'NodeType':
+        """Key types for the Record"""
+        return self._keyType
+
+    @keyType.setter
+    def keyType(self, value: 'NodeType') -> None:
+        self._keyType = value
+
+    @property
+    def valueType(self) -> 'NodeType':
+        """Value types for the Record"""
+        return self._valueType
+
+    @valueType.setter
+    def valueType(self, value: 'NodeType') -> None:
+        self._valueType = value
+
+
+class FunctionTypeParameters:
+    """Function type parameters"""
+
+    def __init__(
+            self,
+            name: str,
+            type: 'NodeType',
+            optional: Optional[bool] = None,
+            default: Optional['NodeType'] = None
+        ):
+        self._name = name
+        self._type = type
+        self._optional = optional
+        self._default = default
+
+    @property
+    def name(self) -> str:
+        """String name of the function parameter"""
+        return self._name
+
+    @name.setter
+    def name(self, value: str) -> None:
+        self._name = value
+
+    @property
+    def type(self) -> 'NodeType':
+        """The type constraint of the parameter"""
+        return self._type
+
+    @type.setter
+    def type(self, value: 'NodeType') -> None:
+        self._type = value
+
+    @property
+    def optional(self) -> Optional[bool]:
+        """Indicates that the parameter is optional"""
+        return self._optional
+
+    @optional.setter
+    def optional(self, value: Optional[bool]) -> None:
+        self._optional = value
+
+    @property
+    def default(self) -> Optional['NodeType']:
+        """Default value for the parameter if nothing is supplied"""
+        return self._default
+
+    @default.setter
+    def default(self, value: Optional['NodeType']) -> None:
+        self._default = value
+
+
+class FunctionType(TypeNode, Annotations):
+    """Function type"""
+
+    def __init__(
+            self,
+            parameters: List[FunctionTypeParameters],
+            returnType: Optional['NodeType'] = None,
+            **kwargs
+        ):
+        super().__init__("function")
+        self._parameters = parameters
+        self._returnType = returnType
+        Annotations.__init__(self, **kwargs)
+
+    @property
+    def parameters(self) -> List[FunctionTypeParameters]:
+        """Types for the parameters, in order, for the function"""
+        return self._parameters
+
+    @parameters.setter
+    def parameters(self, value: List[FunctionTypeParameters]) -> None:
+        self._parameters = value
+
+    @property
+    def returnType(self) -> Optional['NodeType']:
+        """Return type of the function"""
+        return self._returnType
+
+    @returnType.setter
+    def returnType(self, value: Optional['NodeType']) -> None:
+        self._returnType = value
+
+
+class NamedType(Generic[T], Annotations):
+    """Named type that can wrap any base XLR node with name and source information"""
+
+    def __init__(self, base_node: T, name: str, source: str, **kwargs):
+        super().__init__(**kwargs)
+        self._base_node = base_node
+        self._name = name  # Using _name to avoid conflict with Annotations.name
+        self._source = source
+
+    def __getattribute__(self, attr):
+        try:
+            return object.__getattribute__(self, attr)
+        except AttributeError:
+            return self.base_node.__getattribute__(attr)
+
+    @property
+    def base_node(self) -> T:
+        """The underlying XLR node that this named type wraps"""
+        return self._base_node
+
+    @base_node.setter
+    def base_node(self, value: T) -> None:
+        self._base_node = value
+
+    @property
+    def name(self) -> str:
+        """Name of the exported interface/type"""
+        return self._name
+
+    @name.setter
+    def name(self, value: str) -> None: # type: ignore
+        self._name = value
+
+    @property
+    def source(self) -> str:
+        """File the type was exported from"""
+        return self._source
+
+    @source.setter
+    def source(self, value: str) -> None:
+        self._source = value
+
+    # Delegate type property to base_node for compatibility
+    @property
+    def type(self) -> str:
+        """The type of the underlying node"""
+        return self._base_node.type if hasattr(self._base_node, 'type') else ''
+
+
+class ParamTypeNode:
+    """Parameter type node for generics"""
+
+    def __init__(
+            self,
+            symbol: str,
+            constraints: Optional['NodeType'] = None,
+            default: Optional['NodeType'] = None
+        ):
+        self._symbol = symbol
+        self._constraints = constraints
+        self._default = default
+
+    @property
+    def symbol(self) -> str:
+        """Symbol used to identify the generic in the interface/type"""
+        return self._symbol
+
+    @symbol.setter
+    def symbol(self, value: str) -> None:
+        self._symbol = value
+
+    @property
+    def constraints(self) -> Optional['NodeType']:
+        """The type constraint for the generic"""
+        return self._constraints
+
+    @constraints.setter
+    def constraints(self, value: Optional['NodeType']) -> None:
+        self._constraints = value
+
+    @property
+    def default(self) -> Optional['NodeType']:
+        """The default value for the generic if no value is provided"""
+        return self._default
+
+    @default.setter
+    def default(self, value: Optional['NodeType']) -> None:
+        self._default = value
+
+
+class NamedTypeWithGenerics(NamedType[T]):
+    """Named type with generics that can wrap any base XLR node"""
+
+    def __init__(
+            self,
+            base_node: T,
+            name: str,
+            source: str,
+            genericTokens: List[ParamTypeNode],
+            **kwargs
+        ):
+        super().__init__(base_node, name, source, **kwargs)
+        self._genericTokens = genericTokens
+
+    @property
+    def genericTokens(self) -> List[ParamTypeNode]:
+        """Generics for the Named Type that need to be filled in"""
+        return self._genericTokens
+
+    @genericTokens.setter
+    def genericTokens(self, value: List[ParamTypeNode]) -> None:
+        self._genericTokens = value
+
+
+class NodeTypeWithGenerics:
+    """Node type with generics mixin"""
+
+    def __init__(self, genericTokens: List[ParamTypeNode]):
+        self._genericTokens = genericTokens
+
+    @property
+    def genericTokens(self) -> List[ParamTypeNode]:
+        """Generics for the Node that need to be filled in"""
+        return self._genericTokens
+
+    @genericTokens.setter
+    def genericTokens(self, value: List[ParamTypeNode]) -> None:
+        self._genericTokens = value
+
+
+# Type aliases for union types
+PrimitiveTypes = Union[
+    NeverType,
+    NullType,
+    StringType,
+    NumberType,
+    BooleanType,
+    AnyType,
+    UnknownType,
+    UndefinedType,
+    VoidType
+]
+
+NodeType = Union[
+    AnyType, UnknownType, UndefinedType, NullType, NeverType, StringType, TemplateLiteralType,
+    NumberType, BooleanType, ObjectType, ArrayType, TupleType, RecordType, AndType, OrType,
+    RefType, FunctionType, ConditionalType, VoidType
+]
+
+# Update forward references
+ObjectProperty.__annotations__['node'] = NodeType
+RefNode.__annotations__['genericArguments'] = Optional[List[NodeType]]
+ObjectNode.__annotations__['additionalProperties'] = Union[bool, NodeType]
+ArrayNode.__annotations__['elementType'] = NodeType
+ConditionalNode.__annotations__['check'] = Dict[str, NodeType]
+ConditionalNode.__annotations__['value'] = Dict[str, NodeType]
+TupleMember.__annotations__['type'] = NodeType
+TupleNode.__annotations__['additionalItems'] = Union[bool, NodeType]
+AndType.__annotations__['and_types'] = List[NodeType]
+OrType.__annotations__['or_types'] = List[NodeType]
+RecordType.__annotations__['keyType'] = NodeType
+RecordType.__annotations__['valueType'] = NodeType
+FunctionTypeParameters.__annotations__['type'] = NodeType
+FunctionTypeParameters.__annotations__['default'] = Optional[NodeType]
+FunctionType.__annotations__['returnType'] = Optional[NodeType]
+ParamTypeNode.__annotations__['constraints'] = Optional[NodeType]
+ParamTypeNode.__annotations__['default'] = Optional[NodeType]

xlr_lib_types-0.1.1.dev9190.dist-info/METADATA

@@ -0,0 +1,5 @@
+Metadata-Version: 2.1
+Name: xlr_lib_types
+Version: 0.1.1.dev9190
+
+UNKNOWN

xlr_lib_types-0.1.1.dev9190.dist-info/RECORD

@@ -0,0 +1,7 @@
+xlr_lib_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xlr_lib_types/deserializer.py,sha256=rfh-xlUxO2V0Ispf7UJBEvwfu1lncSN0hWeZXu4yXjA,10969
+xlr_lib_types/guards.py,sha256=d23bAKwPX6IqV1OSpfJlbWUMceqgsO7YJMyY3oJ003Q,5888
+xlr_lib_types/nodes.py,sha256=qWgNjdzegJGMc8u7DXoZWY8CBzShwKT7O5VjQry8hxQ,26534
+xlr_lib_types-0.1.1.dev9190.dist-info/WHEEL,sha256=sobxWSyDDkdg_rinUth-jxhXHqoNqlmNMJY3aTZn2Us,91
+xlr_lib_types-0.1.1.dev9190.dist-info/METADATA,sha256=4HQ-0Ob7Aks-fsNIOhEXLh4xIWU1XT620Slq_aJOH7A,74
+xlr_lib_types-0.1.1.dev9190.dist-info/RECORD,,

xlr_lib_types-0.1.1.dev9190.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: bazel-wheelmaker 1.0
+Root-Is-Purelib: true
+Tag: py3-none-any