···
2
+
AT Protocol Lexicon Type Models
4
+
Combined implementation of all AT Protocol Lexicon data types including:
5
+
- Primitive types (boolean, integer, string, null)
6
+
- Complex types (array, object, params)
7
+
- Reference types (ref, union, token)
8
+
- Special types (record, query, procedure, subscription)
9
+
- Binary types (bytes, CID links)
12
+
from typing import Any
15
+
from datetime import datetime
16
+
from pydantic import field_validator, field_serializer
17
+
from cid.cid import CIDv1, make_cid
19
+
from .base import DataModel
20
+
from .exceptions import ValidationError, SerializationError, InvalidCIDError
23
+
class BooleanModel(DataModel):
24
+
"""Model for AT Protocol boolean type."""
29
+
default: bool | None = None
30
+
"""Default value if not provided"""
32
+
const: bool | None = None
33
+
"""Fixed constant value if specified"""
35
+
def __init__(self, **data: Any) -> None:
37
+
Initialize boolean model with validation.
40
+
**data: Input data containing boolean value
43
+
ValueError: If value doesn't match const or is not boolean
45
+
super().__init__(**data)
46
+
if self.const is not None and self.value != self.const:
47
+
raise ValueError(f"Boolean value must be {self.const}")
49
+
@field_validator("value", mode="before")
50
+
def validateBoolean(cls, v: Any) -> bool:
52
+
Validate and convert input to boolean.
55
+
v: Value to validate
58
+
Validated boolean value
61
+
ValueError: If value cannot be converted to boolean
63
+
if isinstance(v, bool):
65
+
if isinstance(v, str):
66
+
if v.lower() in ("true", "1"):
68
+
if v.lower() in ("false", "0"):
70
+
raise ValueError("Value must be a boolean")
73
+
class IntegerModel(DataModel):
74
+
"""Model for AT Protocol integer type."""
79
+
minimum: int | None = None
80
+
"""Minimum acceptable value"""
82
+
maximum: int | None = None
83
+
"""Maximum acceptable value"""
85
+
enum: list[int] | None = None
86
+
"""Closed set of allowed values"""
88
+
default: int | None = None
89
+
"""Default value if not provided"""
91
+
const: int | None = None
92
+
"""Fixed constant value if specified"""
94
+
def __init__(self, **data: Any) -> None:
96
+
Initialize integer model with validation.
99
+
**data: Input data containing integer value
102
+
ValueError: If value violates constraints
104
+
super().__init__(**data)
105
+
if self.const is not None and self.value != self.const:
106
+
raise ValueError(f"Integer value must be {self.const}")
108
+
@field_validator("value", mode="before")
109
+
def validateInteger(cls, v: Any) -> int:
111
+
Validate and convert input to integer.
114
+
v: Value to validate
117
+
Validated integer value
120
+
ValueError: If value violates constraints
122
+
if not isinstance(v, int):
125
+
except (TypeError, ValueError):
126
+
raise ValueError("Value must be an integer")
128
+
if cls.enum and v not in cls.enum:
129
+
raise ValueError(f"Value must be one of {cls.enum}")
131
+
if cls.minimum is not None and v < cls.minimum:
132
+
raise ValueError(f"Value must be >= {cls.minimum}")
134
+
if cls.maximum is not None and v > cls.maximum:
135
+
raise ValueError(f"Value must be <= {cls.maximum}")
140
+
# String Types (from string.py)
141
+
class StringModel(DataModel):
142
+
"""Model for AT Protocol string type."""
147
+
format: str | None = None
148
+
"""String format restriction"""
150
+
maxLength: int | None = None
151
+
"""Maximum length in UTF-8 bytes"""
153
+
minLength: int | None = None
154
+
"""Minimum length in UTF-8 bytes"""
156
+
knownValues: list[str] | None = None
157
+
"""Suggested/common values"""
159
+
enum: list[str] | None = None
160
+
"""Closed set of allowed values"""
162
+
default: str | None = None
163
+
"""Default value if not provided"""
165
+
const: str | None = None
166
+
"""Fixed constant value if specified"""
168
+
def __init__(self, **data: Any) -> None:
170
+
Initialize string model with validation.
173
+
**data: Input data containing string value
176
+
ValueError: If value violates constraints
178
+
super().__init__(**data)
179
+
if self.const is not None and self.value != self.const:
180
+
raise ValueError(f"String value must be {self.const}")
182
+
@field_validator("value", mode="before")
183
+
def validateString(cls, v: Any) -> str:
185
+
Validate and convert input to string.
188
+
v: Value to validate
191
+
Validated string value
194
+
ValueError: If value violates constraints
196
+
if not isinstance(v, str):
199
+
if cls.minLength is not None and len(v.encode()) < cls.minLength:
200
+
raise ValueError(f"String must be at least {cls.minLength} bytes")
202
+
if cls.maxLength is not None and len(v.encode()) > cls.maxLength:
203
+
raise ValueError(f"String must be at most {cls.maxLength} bytes")
205
+
if cls.enum and v not in cls.enum:
206
+
raise ValueError(f"Value must be one of {cls.enum}")
209
+
cls._validateFormat(v)
214
+
def _validateFormat(cls, v: str) -> None:
215
+
"""Validate string format based on specified format type."""
216
+
if cls.format == "datetime":
217
+
cls._validateDatetime(v)
218
+
elif cls.format == "uri":
219
+
cls._validateUri(v)
220
+
elif cls.format == "did":
221
+
cls._validateDid(v)
222
+
elif cls.format == "handle":
223
+
cls._validateHandle(v)
224
+
elif cls.format == "at-identifier":
225
+
cls._validateAtIdentifier(v)
226
+
elif cls.format == "at-uri":
227
+
cls._validateAtUri(v)
228
+
elif cls.format == "cid":
229
+
cls._validateCid(v)
230
+
elif cls.format == "nsid":
231
+
cls._validateNsid(v)
232
+
elif cls.format == "tid":
233
+
cls._validateTid(v)
234
+
elif cls.format == "record-key":
235
+
cls._validateRecordKey(v)
236
+
elif cls.format == "language":
237
+
cls._validateLanguage(v)
240
+
def _validateDid(cls, v: str) -> None:
241
+
"""Validate DID format"""
243
+
raise ValueError("DID too long")
244
+
if not re.match(r"^did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$", v):
245
+
raise ValueError("Invalid DID format")
248
+
def _validateHandle(cls, v: str) -> None:
249
+
"""Validate handle format"""
251
+
r"^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$",
254
+
raise ValueError("Handle contains invalid characters")
256
+
raise ValueError("Handle too long")
259
+
def _validateAtIdentifier(cls, v: str) -> None:
260
+
"""Validate at-identifier format (DID or handle)"""
262
+
if v.startswith("did:"):
263
+
cls._validateDid(v)
265
+
cls._validateHandle(v)
266
+
except ValueError as e:
267
+
raise ValueError(f"Invalid at-identifier: {e}")
270
+
def _validateAtUri(cls, v: str) -> None:
271
+
"""Validate AT-URI format"""
272
+
if not v.startswith("at://"):
273
+
raise ValueError("AT-URI must start with 'at://'")
275
+
raise ValueError("AT-URI too long")
276
+
if v.endswith("/"):
277
+
raise ValueError("AT-URI cannot have trailing slash")
279
+
parts = v[5:].split("/")
280
+
authority = parts[0]
283
+
raise ValueError("AT-URI must have authority")
285
+
if authority.startswith("did:"):
286
+
if len(authority) > 2048:
287
+
raise ValueError("DID too long")
288
+
if ":" not in authority[4:]:
289
+
raise ValueError("Invalid DID format")
291
+
if not re.match(r"^[a-z0-9.-]+$", authority):
292
+
raise ValueError("Invalid handle characters")
293
+
if len(authority) > 253:
294
+
raise ValueError("Handle too long")
298
+
raise ValueError("AT-URI path too deep")
300
+
collection = parts[1]
301
+
if not re.match(r"^[a-zA-Z0-9.-]+$", collection):
302
+
raise ValueError("Invalid collection NSID")
307
+
raise ValueError("Record key cannot be empty")
308
+
if not re.match(r"^[a-zA-Z0-9._:%-~]+$", rkey):
309
+
raise ValueError("Invalid record key characters")
312
+
def _validateCid(cls, v: str) -> None:
313
+
"""Validate CID string format"""
315
+
raise ValueError("CID too long")
316
+
if not re.match(r"^[a-zA-Z]+$", v):
317
+
raise ValueError("CID contains invalid characters")
320
+
def _validateNsid(cls, v: str) -> None:
321
+
"""Validate NSID format"""
323
+
raise ValueError("NSID too long")
325
+
r"^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(\.[a-zA-Z]([a-zA-Z0-9]{0,62})?)$",
328
+
raise ValueError("NSID contains invalid characters")
331
+
def _validateTid(cls, v: str) -> None:
332
+
"""Validate TID format"""
334
+
raise ValueError("TID too long")
336
+
r"^[234567abcdefghij][234567abcdefghijklmnopqrstuvwxyz]{12}$", v
338
+
raise ValueError("TID contains invalid characters")
341
+
def _validateRecordKey(cls, v: str) -> None:
342
+
"""Validate record-key format"""
344
+
raise ValueError("Record key too long")
345
+
if v == "." or v == "..":
346
+
raise ValueError(f"Record key is {v}, which is not allowed")
347
+
if not re.match(r"^[a-zA-Z0-9._:%-~]+$", v):
348
+
raise ValueError("Record key contains invalid characters")
351
+
def _validateLanguage(cls, v: str) -> None:
352
+
"""Validate BCP 47 language tag"""
353
+
if not re.match(r"^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$", v):
354
+
raise ValueError("Invalid language tag format")
355
+
cls._validateDatetime(v)
356
+
elif cls.format == "uri":
357
+
cls._validateUri(v)
358
+
elif cls.format == "did":
359
+
cls._validateDid(v)
360
+
elif cls.format == "handle":
361
+
cls._validateHandle(v)
362
+
elif cls.format == "at-identifier":
363
+
cls._validateAtIdentifier(v)
364
+
elif cls.format == "at-uri":
365
+
cls._validateAtUri(v)
366
+
elif cls.format == "cid":
367
+
cls._validateCid(v)
368
+
elif cls.format == "nsid":
369
+
cls._validateNsid(v)
370
+
elif cls.format == "tid":
371
+
cls._validateTid(v)
372
+
elif cls.format == "record-key":
373
+
cls._validateRecordKey(v)
374
+
elif cls.format == "language":
375
+
cls._validateLanguage(v)
378
+
def _validateDatetime(cls, v: str) -> None:
379
+
"""Validate RFC 3339 datetime format"""
381
+
datetime.fromisoformat(v.replace("Z", "+00:00"))
383
+
raise ValueError("Invalid datetime format")
386
+
def _validateUri(cls, v: str) -> None:
387
+
"""Validate URI format"""
389
+
raise ValueError("URI too long")
390
+
if not re.match(r"^[a-zA-Z][a-zA-Z0-9+.-]*:.+", v):
391
+
raise ValueError("Invalid URI format")
393
+
# ... (other validation methods remain the same)
396
+
# Binary Types (from binary.py)
397
+
class BytesModel(DataModel):
398
+
"""Model for AT Protocol bytes type."""
401
+
"""Raw binary data"""
403
+
minLength: int | None = None
404
+
"""Minimum size in bytes"""
406
+
maxLength: int | None = None
407
+
"""Maximum size in bytes"""
409
+
def __init__(self, **data: Any) -> None:
411
+
Initialize bytes model with validation.
414
+
**data: Input data containing bytes value and constraints
417
+
ValidationError: If length constraints are violated
419
+
super().__init__(**data)
421
+
@field_validator("value")
422
+
def validateLength(cls, v: bytes, info: Any) -> bytes:
424
+
Validate bytes length against constraints.
427
+
v: Bytes value to validate
428
+
info: Validation info containing field values
434
+
ValidationError: If length constraints are violated
436
+
minLen = info.data.get("minLength")
437
+
maxLen = info.data.get("maxLength")
439
+
if minLen is not None and len(v) < minLen:
440
+
raise ValidationError(
442
+
message=f"Bytes length {len(v)} is less than minimum {minLen}",
445
+
if maxLen is not None and len(v) > maxLen:
446
+
raise ValidationError(
447
+
field="value", message=f"Bytes length {len(v)} exceeds maximum {maxLen}"
452
+
@field_serializer("value")
453
+
def serializeBytes(self, v: bytes) -> dict[str, str]:
455
+
Serialize bytes to JSON format with base64 encoding.
458
+
v: Bytes to serialize
461
+
Dictionary with base64 encoded bytes
464
+
SerializationError: If encoding fails
467
+
return {"$bytes": base64.b64encode(v).decode()}
468
+
except Exception as e:
469
+
raise SerializationError("value", f"Failed to encode bytes: {e}")
472
+
class CidLinkModel(DataModel):
473
+
"""Model for AT Protocol CID link type."""
476
+
"""CID reference to linked content"""
478
+
def __init__(self, **data: Any) -> None:
480
+
Initialize CID link model with validation.
483
+
**data: Input data containing CID link
486
+
InvalidCIDError: If CID is invalid
488
+
if isinstance(data.get("link"), str):
490
+
data["link"] = make_cid(data["link"])
491
+
except ValueError as e:
492
+
raise InvalidCIDError(f"Invalid CID: {e}")
494
+
super().__init__(**data)
496
+
@field_serializer("link")
497
+
def serializeCid(self, v: CIDv1) -> dict[str, str]:
499
+
Serialize CID to JSON format.
502
+
v: CID to serialize
505
+
Dictionary with string CID representation
507
+
return {"$link": str(v)}
510
+
# Complex Types (from complex.py)
511
+
class ArrayModel(DataModel):
512
+
"""Model for AT Protocol array type."""
515
+
"""Schema definition for array elements"""
517
+
minLength: int | None = None
518
+
"""Minimum number of elements"""
520
+
maxLength: int | None = None
521
+
"""Maximum number of elements"""
526
+
def __init__(self, **data: Any) -> None:
528
+
Initialize array model with validation.
531
+
**data: Input data containing array values
534
+
ValueError: If array violates constraints
536
+
super().__init__(**data)
538
+
@field_validator("value", mode="before")
539
+
def validateArray(cls, v: Any) -> list[Any]:
541
+
Validate array structure and elements.
544
+
v: Value to validate
550
+
ValueError: If array violates constraints
552
+
if not isinstance(v, list):
553
+
raise ValueError("Value must be an array")
555
+
if cls.minLength is not None and len(v) < cls.minLength:
556
+
raise ValueError(f"Array must have at least {cls.minLength} items")
558
+
if cls.maxLength is not None and len(v) > cls.maxLength:
559
+
raise ValueError(f"Array must have at most {cls.maxLength} items")
564
+
class ObjectModel(DataModel):
565
+
"""Model for AT Protocol object type."""
567
+
properties: dict[str, Any]
568
+
"""Map of property names to their schema definitions"""
570
+
required: list[str] | None = None
571
+
"""List of required property names"""
573
+
nullable: list[str] | None = None
574
+
"""List of properties that can be null"""
576
+
value: dict[str, Any]
577
+
"""Object property values"""
579
+
def __init__(self, **data: Any) -> None:
581
+
Initialize object model with validation.
584
+
**data: Input data containing object properties
587
+
ValueError: If object violates constraints
589
+
super().__init__(**data)
591
+
@field_validator("value", mode="before")
592
+
def validateObject(cls, v: Any) -> dict[str, Any]:
594
+
Validate object structure and properties.
597
+
v: Value to validate
603
+
ValueError: If object violates constraints
605
+
if not isinstance(v, dict):
606
+
raise ValueError("Value must be an object")
609
+
for field in cls.required:
611
+
raise ValueError(f"Missing required field: {field}")
614
+
for field, value in v.items():
615
+
if field not in cls.nullable and value is None:
616
+
raise ValueError(f"Field {field} cannot be null")
621
+
class ParamsModel(DataModel):
622
+
"""Model for AT Protocol params type."""
624
+
required: list[str] | None = None
625
+
"""List of required parameter names"""
627
+
properties: dict[str, Any]
628
+
"""Map of parameter names to their schema definitions"""
630
+
value: dict[str, Any]
631
+
"""Parameter values"""
633
+
def __init__(self, **data: Any) -> None:
635
+
Initialize params model with validation.
638
+
**data: Input data containing parameter values
641
+
ValueError: If parameters violate constraints
643
+
super().__init__(**data)
645
+
@field_validator("value", mode="before")
646
+
def validateParams(cls, v: Any) -> dict[str, Any]:
648
+
Validate parameters structure and values.
651
+
v: Value to validate
654
+
Validated parameters dictionary
657
+
ValueError: If parameters violate constraints
659
+
if not isinstance(v, dict):
660
+
raise ValueError("Value must be a dictionary of parameters")
662
+
validated = dict(v)
665
+
for param in cls.required:
666
+
if param not in validated:
667
+
raise ValueError(f"Missing required parameter: {param}")
669
+
for param, value in validated.items():
670
+
if param in cls.properties:
671
+
propType = cls.properties[param].get("type")
672
+
if propType == "boolean" and not isinstance(value, bool):
673
+
raise ValueError(f"Parameter {param} must be boolean")
674
+
elif propType == "integer" and not isinstance(value, int):
675
+
raise ValueError(f"Parameter {param} must be integer")
676
+
elif propType == "string" and not isinstance(value, str):
677
+
raise ValueError(f"Parameter {param} must be string")
678
+
elif propType == "array":
679
+
if not isinstance(value, list):
680
+
raise ValueError(f"Parameter {param} must be array")
681
+
if "items" in cls.properties[param]:
682
+
itemType = cls.properties[param]["items"].get("type")
684
+
if itemType == "boolean" and not isinstance(item, bool):
686
+
f"Array item in {param} must be boolean"
688
+
elif itemType == "integer" and not isinstance(item, int):
690
+
f"Array item in {param} must be integer"
692
+
elif itemType == "string" and not isinstance(item, str):
694
+
f"Array item in {param} must be string"
696
+
elif itemType == "unknown" and not isinstance(item, dict):
698
+
f"Array item in {param} must be object"
700
+
elif propType == "unknown" and not isinstance(value, dict):
701
+
raise ValueError(f"Parameter {param} must be object")
dwn.poxiao-labs.work