···

       
1
       
1
       
 
       
import base64

     

       
2
       
2
       
-
       
import re

     

       
3
       
3
       
-
       
from datetime import datetime

     

       
4
       
2
       
 
       
from typing import Any

     

       
5
       
5
       
-
       
from collections.abc import Mapping

     

       
6
       
3
       
 
       
from cid.cid import CIDv1, make_cid

     

       
7
       
4
       
 
       
from pydantic import BaseModel, field_serializer, field_validator, ConfigDict

     

       
8
       
8
       
-
       
from pydantic.fields import FieldInfo

     

       
9
       
5
       
 
       
from .exceptions import (

     

       
10
       
10
       
-
       
    ValidationError,

     

       
11
       
6
       
 
       
    SerializationError,

     

       
12
       
7
       
 
       
    DeserializationError,

     

       
13
       
8
       
 
       
    InvalidCIDError

     

···

       
1
       
1
       
 
       
from typing import Any

     

       
2
       
2
       
 
       
from pydantic import field_validator, ConfigDict

     

       
3
       
3
       
 
       
from .base import DataModel

     

       
4
       
4
       
-
       
from .exceptions import ValidationError, InvalidBlobError

     

       
4
       
4
       
+
       
from .exceptions import ValidationError

     

       
5
       
5
       
 
       


     

       
6
       
6
       
 
       
class BlobModel(DataModel):

     

       
7
       
7
       
 
       
    """

     
···

       
34
       
34
       
 
       
            Validated size

     

       
35
       
35
       
 
       


     

       
36
       
36
       
 
       
        Raises:

     

       
37
       
37
       
-
       
            ValueError: If size is not positive

     

       
37
       
37
       
+
       
            ValidationError: If size is not positive

     

       
38
       
38
       
 
       
        """

     

       
39
       
39
       
 
       
        if v <= 0:

     

       
40
       
40
       
-
       
            raise ValueError("Blob size must be positive and non-zero")

     

       
40
       
40
       
+
       
            raise ValidationError(field="size", message="must be positive and non-zero")

     

       
41
       
41
       
 
       
        return v

     

       
42
       
42
       
 
       


     

       
43
       
43
       
 
       
    @field_validator("mimeType")

     
···

       
52
       
52
       
 
       
            Validated MIME type

     

       
53
       
53
       
 
       


     

       
54
       
54
       
 
       
        Raises:

     

       
55
       
55
       
-
       
            ValueError: If MIME type is empty

     

       
55
       
55
       
+
       
            ValidationError: If MIME type is empty

     

       
56
       
56
       
 
       
        """

     

       
57
       
57
       
 
       
        if not v:

     

       
58
       
58
       
-
       
            raise ValueError("MIME type cannot be empty")

     

       
58
       
58
       
+
       
            raise ValidationError(field="mimeType", message="cannot be empty")

     

       
59
       
59
       
 
       
        return v
     

···

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

     

       
5
       
5
       
 
       
"""

     

       
6
       
6
       
 
       
import json

     

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

     

       
7
       
7
       
+
       
from typing import Any

     

       
8
       
8
       
 
       
from pydantic import BaseModel

     

       
9
       
9
       
 
       
from .exceptions import ValidationError, SerializationError

     

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

     
···

       
50
       
50
       
 
       
    }

     

       
51
       
51
       
 
       
    

     

       
52
       
52
       
 
       
    @classmethod

     

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

     

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

     

       
54
       
54
       
 
       
        """

     

       
55
       
55
       
 
       
        Convert Lexicon JSON to Python data model instance.

     

       
56
       
56
       
 
       
        

     
···

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

     

       
90
       
90
       
 
       
    

     

       
91
       
91
       
 
       
    @classmethod

     

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

     

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

     

       
93
       
93
       
 
       
        """

     

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

     

       
95
       
95
       
 
       
        

     
···

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

     

       
130
       
130
       
 
       


     

       
131
       
131
       
 
       
    @classmethod

     

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

     

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

     

       
133
       
133
       
 
       
        """

     

       
134
       
134
       
 
       
        Validate Lexicon JSON against schema definitions.

     

       
135
       
135
       
 
       
        

     

···

       
1
       
1
       
-
       
from typing import Any, Optional

     

       
1
       
1
       
+
       
from typing import Any

     

       
2
       
2
       
 
       
from pydantic import field_validator

     

       
3
       
3
       
 
       
from ..base import DataModel

     

       
4
       
4
       
 
       


     

···

       
1
       
1
       
 
       
from typing import Any

     

       
2
       
2
       
 
       
from cid.cid import CIDv1, make_cid

     

       
3
       
3
       
 
       
import base64

     

       
4
       
4
       
-
       
import re

     

       
5
       
5
       
-
       
from datetime import datetime

     

       
6
       
4
       
 
       


     

       
7
       
5
       
 
       
def validateAtprotoData(data: Any) -> bool:

     

       
8
       
6
       
 
       
    """