commit ee5c6e3ef88a91b24ea61867bbb2db4695ce5f3e · dwn.poxiao-labs.work/atpasser

src/atpasser/model/__init__.py

···

       38
        
           ProcedureModel,

     

       39
        
           SubscriptionModel

     

       40
        
       )

     

       0
        
       
     

       41
        
       

     

       42
        
       __all__ = [

     

       43
        
           "DataModel",

     
···

       61
        
           "QueryModel",

     

       62
        
           "ProcedureModel",

     

       63
        
           "SubscriptionModel",

     

       0
        
       
     

       0
        
       
     

       64
        
           # Exceptions

     

       65
        
           "AtprotoModelError",

     

       66
        
           "ValidationError",

···

       38
        
           ProcedureModel,

     

       39
        
           SubscriptionModel

     

       40
        
       )

     

       41
       +
       from .converter import LexiconConverter

     

       42
        
       

     

       43
        
       __all__ = [

     

       44
        
           "DataModel",

     
···

       62
        
           "QueryModel",

     

       63
        
           "ProcedureModel",

     

       64
        
           "SubscriptionModel",

     

       65
       +
           # Converter

     

       66
       +
           "LexiconConverter",

     

       67
        
           # Exceptions

     

       68
        
           "AtprotoModelError",

     

       69
        
           "ValidationError",

+146

src/atpasser/model/converter.py

···

       1
       +
       """

     

       2
       +
       Lexicon JSON to Data Model Converter

     

       3
       +
       

     

       4
       +
       Provides bidirectional conversion between Lexicon JSON schemas and Python data models.

     

       5
       +
       """

     

       6
       +
       import json

     

       7
       +
       from typing import Any, Dict, Type, Union, TypeVar

     

       8
       +
       from pydantic import BaseModel

     

       9
       +
       from .exceptions import ValidationError, SerializationError

     

       10
       +
       from .types.primitive import NullModel, BooleanModel, IntegerModel

     

       11
       +
       from .types.string import StringModel

     

       12
       +
       from .types.complex import ArrayModel, ObjectModel, ParamsModel

     

       13
       +
       from .types.reference import TokenModel, RefModel, UnionModel

     

       14
       +
       from .types.special import (

     

       15
       +
           UnknownModel, RecordModel, QueryModel,

     

       16
       +
           ProcedureModel, SubscriptionModel

     

       17
       +
       )

     

       18
       +
       

     

       19
       +
       class LexiconConverter:

     

       20
       +
           """

     

       21
       +
           Bidirectional converter between Lexicon JSON and Python data models.

     

       22
       +
           

     

       23
       +
           Attributes:

     

       24
       +
               modelMap (Dict[str, Type[BaseModel]]): Mapping from Lexicon types to model classes

     

       25
       +
           """

     

       26
       +
           

     

       27
       +
           modelMap = {

     

       28
       +
               # Primitive types

     

       29
       +
               "null": NullModel,

     

       30
       +
               "boolean": BooleanModel,

     

       31
       +
               "integer": IntegerModel,

     

       32
       +
               "string": StringModel,

     

       33
       +
               

     

       34
       +
               # Complex types

     

       35
       +
               "array": ArrayModel,

     

       36
       +
               "object": ObjectModel,

     

       37
       +
               "params": ParamsModel,

     

       38
       +
               

     

       39
       +
               # Reference types

     

       40
       +
               "token": TokenModel,

     

       41
       +
               "ref": RefModel,

     

       42
       +
               "union": UnionModel,

     

       43
       +
               

     

       44
       +
               # Special types

     

       45
       +
               "unknown": UnknownModel,

     

       46
       +
               "record": RecordModel,

     

       47
       +
               "query": QueryModel,

     

       48
       +
               "procedure": ProcedureModel,

     

       49
       +
               "subscription": SubscriptionModel,

     

       50
       +
           }

     

       51
       +
           

     

       52
       +
           @classmethod

     

       53
       +
           def fromLexicon(cls, lexiconJson: Union[str, Dict[str, Any]]) -> BaseModel:

     

       54
       +
               """

     

       55
       +
               Convert Lexicon JSON to Python data model instance.

     

       56
       +
               

     

       57
       +
               Args:

     

       58
       +
                   lexiconJson: Lexicon JSON string or dict

     

       59
       +
                   

     

       60
       +
               Returns:

     

       61
       +
                   Instance of appropriate Pydantic model

     

       62
       +
                   

     

       63
       +
               Raises:

     

       64
       +
                   ValidationError: If JSON is invalid or doesn't match schema

     

       65
       +
                   SerializationError: If conversion fails

     

       66
       +
               """

     

       67
       +
               if isinstance(lexiconJson, str):

     

       68
       +
                   try:

     

       69
       +
                       data = json.loads(lexiconJson)

     

       70
       +
                   except json.JSONDecodeError as e:

     

       71
       +
                       raise ValidationError("lexiconJson", f"Invalid JSON: {e}")

     

       72
       +
               else:

     

       73
       +
                   data = lexiconJson

     

       74
       +
                   

     

       75
       +
               if not isinstance(data, dict):

     

       76
       +
                   raise ValidationError("lexiconJson", "Lexicon must be a JSON object")

     

       77
       +
                   

     

       78
       +
               if "type" not in data:

     

       79
       +
                   raise ValidationError("type", "Lexicon definition must have 'type' field")

     

       80
       +
                   

     

       81
       +
               typeName = data["type"]

     

       82
       +
               if typeName not in cls.modelMap:

     

       83
       +
                   raise ValidationError("type", f"Unknown Lexicon type: {typeName}")

     

       84
       +
                   

     

       85
       +
               try:

     

       86
       +
                   modelClass = cls.modelMap[typeName]

     

       87
       +
                   return modelClass(**data)

     

       88
       +
               except Exception as e:

     

       89
       +
                   raise SerializationError(typeName, f"Failed to create model: {e}")

     

       90
       +
           

     

       91
       +
           @classmethod

     

       92
       +
           def toLexicon(cls, modelInstance: BaseModel) -> Dict[str, Any]:

     

       93
       +
               """

     

       94
       +
               Convert Python model instance back to Lexicon JSON format.

     

       95
       +
               

     

       96
       +
               Args:

     

       97
       +
                   modelInstance: Instance of a Lexicon model

     

       98
       +
                   

     

       99
       +
               Returns:

     

       100
       +
                   Dictionary representing Lexicon JSON

     

       101
       +
                   

     

       102
       +
               Raises:

     

       103
       +
                   SerializationError: If conversion fails

     

       104
       +
               """

     

       105
       +
               if not isinstance(modelInstance, BaseModel):

     

       106
       +
                   raise SerializationError("modelInstance", "Input must be a Pydantic model")

     

       107
       +
                   

     

       108
       +
               try:

     

       109
       +
                   # Get the model's type name by reverse lookup

     

       110
       +
                   modelType = None

     

       111
       +
                   for typeName, modelClass in cls.modelMap.items():

     

       112
       +
                       if isinstance(modelInstance, modelClass):

     

       113
       +
                           modelType = typeName

     

       114
       +
                           break

     

       115
       +
                           

     

       116
       +
                   if modelType is None:

     

       117
       +
                       raise SerializationError("modelInstance", "Unknown model type")

     

       118
       +
                       

     

       119
       +
                   # Convert to dict and add type field

     

       120
       +
                   result = modelInstance.model_dump(exclude_unset=True)

     

       121
       +
                   result["type"] = modelType

     

       122
       +
                   

     

       123
       +
                   # Handle special cases

     

       124
       +
                   if modelType == "record" and "type" in result:

     

       125
       +
                       result["$type"] = result.pop("type")

     

       126
       +
                       

     

       127
       +
                   return result

     

       128
       +
               except Exception as e:

     

       129
       +
                   raise SerializationError("toLexicon", f"Failed to serialize model: {e}")

     

       130
       +
       

     

       131
       +
           @classmethod

     

       132
       +
           def validateLexicon(cls, lexiconJson: Union[str, Dict[str, Any]]) -> bool:

     

       133
       +
               """

     

       134
       +
               Validate Lexicon JSON against schema definitions.

     

       135
       +
               

     

       136
       +
               Args:

     

       137
       +
                   lexiconJson: Lexicon JSON to validate

     

       138
       +
                   

     

       139
       +
               Returns:

     

       140
       +
                   True if valid, False otherwise

     

       141
       +
               """

     

       142
       +
               try:

     

       143
       +
                   cls.fromLexicon(lexiconJson)

     

       144
       +
                   return True

     

       145
       +
               except (ValidationError, SerializationError):

     

       146
       +
                   return False