dwn.poxiao-labs.work
-5
src/atpasser/model/base.py
-5
src/atpasser/model/base.py
···
1
1
import base64
2
-
import re
3
-
from datetime import datetime
4
2
from typing import Any
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
-
from pydantic.fields import FieldInfo
9
5
from .exceptions import (
10
-
ValidationError,
11
6
SerializationError,
12
7
DeserializationError,
13
8
InvalidCIDError
+5
-5
src/atpasser/model/blob.py
+5
-5
src/atpasser/model/blob.py
···
1
1
from typing import Any
2
2
from pydantic import field_validator, ConfigDict
3
3
from .base import DataModel
4
-
from .exceptions import ValidationError, InvalidBlobError
4
+
from .exceptions import ValidationError
5
5
6
6
class BlobModel(DataModel):
7
7
"""
···
34
34
Validated size
35
35
36
36
Raises:
37
-
ValueError: If size is not positive
37
+
ValidationError: If size is not positive
38
38
"""
39
39
if v <= 0:
40
-
raise ValueError("Blob size must be positive and non-zero")
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
-
ValueError: If MIME type is empty
55
+
ValidationError: If MIME type is empty
56
56
"""
57
57
if not v:
58
-
raise ValueError("MIME type cannot be empty")
58
+
raise ValidationError(field="mimeType", message="cannot be empty")
59
59
return v
+4
-4
src/atpasser/model/converter.py
+4
-4
src/atpasser/model/converter.py
···
4
4
Provides bidirectional conversion between Lexicon JSON schemas and Python data models.
5
5
"""
6
6
import json
7
-
from typing import Any, Dict, Type, Union, TypeVar
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
-
def fromLexicon(cls, lexiconJson: Union[str, Dict[str, Any]]) -> BaseModel:
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
-
def toLexicon(cls, modelInstance: BaseModel) -> Dict[str, Any]:
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
-
def validateLexicon(cls, lexiconJson: Union[str, Dict[str, Any]]) -> bool:
132
+
def validateLexicon(cls, lexiconJson: str | dict[str, Any]) -> bool:
133
133
"""
134
134
Validate Lexicon JSON against schema definitions.
135
135
+1
-1
src/atpasser/model/types/complex.py
+1
-1
src/atpasser/model/types/complex.py