+1

.gitignore

reviewed

··· 1 1 + /.venv

+62

README.md

reviewed

··· 1 1 + # `atplex` 2 2 + 3 3 + Name open for discussion; I just needed one but didn't want to think, so i took something where you don't need to think much. 4 4 + 5 5 + ## Idea 6 6 + 7 7 + A low-level python package for interacting with atproto data, 8 8 + enableing you to use typed python to communicate with XRPC endpoints 9 9 + using custom lexicons found on the web. 10 10 + 11 11 + ## What I want it to look in the end 12 12 + 13 13 + something like this 14 14 + (except I don't know yet if I want to make it sync or asnyc) 15 15 + 16 16 + ```bash 17 17 + python -m atplex pull com.example.getProfile 18 18 + ``` 19 19 + 20 20 + ```python 21 21 + import atplex 22 22 + import lex 23 23 + 24 24 + client = atplex.Client() 25 25 + 26 26 + data = await client.exec(lex.com.example.getProfile(user="jojojux.de")) 27 27 + print(data) # com.example.getProfile#main/output(did=DID("did:plc:f3f3dvty36ztjdqqyxfqhw3p"), name="jojojux.de", displayName=None) 28 28 + ``` 29 29 + 30 30 + ## Roadmap 31 31 + 32 32 + - [ ] Implement lexicon string formats as custom types 33 33 + - [x] NSID 34 34 + - [x] TID 35 35 + - [x] DID 36 36 + - [ ] CID 37 37 + - [ ] All the others 38 38 + - [x] Object based representation of lexicons 39 39 + - [x] Read lexicons into correct object representation 40 40 + - [x] Codegen from lexicon object representation 41 41 + - [x] `None` (partial, but wont-fix) (specifically: cannot be top-level type of a fragment) 42 42 + - [x] `bool`, `int`, `str`, `bytes` 43 43 + - [ ] `object` (partial) 44 44 + - [ ] `list` (partial) 45 45 + - [ ] `query` 46 46 + - [ ] `procedure` 47 47 + - [ ] `params` 48 48 + - [ ] `record` 49 49 + - [ ] `subscription` 50 50 + - [ ] Cache lexicon object representation for codegen-ed lexicons 51 51 + - [ ] Validate data against a lexicon object representation 52 52 + - [ ] Read data from known lexicons 53 53 + - [ ] Read data from unknown lexicons 54 54 + Decide: 55 55 + - Generate lexicon object representation on the fly? 56 56 + - Auto resolve lexicons? 57 57 + - [ ] CLI Tool to resolve & pull lexicons, do codegen, and more 58 58 + Idea is essentially sth like a package manager for lexicons 59 59 + - [ ] Basic XRPC Client 60 60 + - [ ] Figure out how to best store data that has to conform to the data model without all these fancy-custom types that lexicons have. 61 61 + - [ ] Improve all of the before 62 62 + - [ ] I don't know what

+2

lex/__init__.py

reviewed

··· 1 1 + from . import com 2 2 + __all__ = ['com']

+2

lex/com/__init__.py

reviewed

··· 1 1 + from . import example 2 2 + __all__ = ['example']

+2

lex/com/example/__init__.py

reviewed

··· 1 1 + from .getProfile import getProfile 2 2 + __all__ = ['getProfile']

+36

lex/com/example/getProfile.py

reviewed

··· 1 1 + from src.lexicon.model import BaseFragment, BaseExport 2 2 + 3 3 + 4 4 + class _meta_other2(BaseFragment): 5 5 + __lexicon__ = "com.example.getProfile" 6 6 + __fragment__ = "other" 7 7 + 8 8 + 9 9 + class _frag_other2(object, metaclass=_meta_other2): 10 10 + __qualname__ = "other" 11 11 + int: "_frag_other" 12 12 + 13 13 + class _meta_other(BaseFragment): 14 14 + __lexicon__ = "com.example.getProfile" 15 15 + __fragment__ = "other" 16 16 + 17 17 + 18 18 + class _frag_other(object, metaclass=_meta_other): 19 19 + __qualname__ = "other" 20 20 + int: "int" 21 21 + 22 22 + 23 23 + class _meta_main(BaseFragment): 24 24 + __lexicon__ = "com.example.getProfile" 25 25 + __fragment__ = "main" 26 26 + other2 = _frag_other2 27 27 + other = _frag_other 28 28 + 29 29 + 30 30 + class _frag_main(object, metaclass=_meta_main): 31 31 + __qualname__ = "main" 32 32 + test: "_frag_other" 33 33 + test2: "list | None" 34 34 + 35 35 + 36 36 + getProfile = _frag_main

+46

lexicon.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "com.example.getProfile", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "parameters": { 8 8 + "type": "params", 9 9 + "required": [ 10 10 + "user" 11 11 + ], 12 12 + "properties": { 13 13 + "user": { 14 14 + "type": "string" 15 15 + } 16 16 + } 17 17 + }, 18 18 + "output": { 19 19 + "encoding": "application/json", 20 20 + "schema": { 21 21 + "type": "object", 22 22 + "required": [ 23 23 + "did", 24 24 + "name" 25 25 + ], 26 26 + "properties": { 27 27 + "did": { 28 28 + "type": "string" 29 29 + }, 30 30 + "name": { 31 31 + "type": "string" 32 32 + }, 33 33 + "displayName": { 34 34 + "type": "string", 35 35 + "maxLength": 64 36 36 + }, 37 37 + "description": { 38 38 + "type": "string", 39 39 + "maxLength": 256 40 40 + } 41 41 + } 42 42 + } 43 43 + } 44 44 + } 45 45 + } 46 46 + }

+678

old_lexicon.py

reviewed

··· 1 1 + import abc 2 2 + import base64 3 3 + from typing import Any 4 4 + from ..id.cid import CIDLink 5 5 + from ..id import NSID, TID, DID 6 6 + 7 7 + 8 8 + class _Empty: ... 9 9 + 10 10 + 11 11 + Empty = _Empty() 12 12 + 13 13 + type JSONObject = ( 14 14 + None | int | bool | str | list[JSONObject] | dict[str, JSONObject] | Empty 15 15 + ) 16 16 + 17 17 + 18 18 + class SchemaObject[T: Any](abc.ABC): 19 19 + @abc.abstractmethod 20 20 + def __init__(self, obj: dict[str, JSONObject]): ... 21 21 + 22 22 + @abc.abstractmethod 23 23 + def serialize(self, obj: T) -> JSONObject: ... 24 24 + 25 25 + @abc.abstractmethod 26 26 + def deserialize(self, obj: JSONObject) -> T: ... 27 27 + 28 28 + @abc.abstractmethod 29 29 + def validate_json(self, obj: JSONObject) -> bool: ... 30 30 + 31 31 + @abc.abstractmethod 32 32 + def validate(self, obj: T) -> bool: ... 33 33 + 34 34 + 35 35 + class LNull(SchemaObject[None]): 36 36 + __lexicon_type__: str = "null" 37 37 + 38 38 + def __init__(self, obj: dict[str, JSONObject]): 39 39 + if not isinstance(obj, dict): 40 40 + raise TypeError("Lexicon typedef must be object") 41 41 + assert obj.get("type") == "null" 42 42 + 43 43 + def serialize(self, obj: None) -> JSONObject: 44 44 + return None 45 45 + 46 46 + def deserialize(self, obj: JSONObject) -> None: 47 47 + return None 48 48 + 49 49 + def validate_json(self, obj: JSONObject) -> bool: 50 50 + return obj is None 51 51 + 52 52 + def validate(self, obj: None) -> bool: 53 53 + return obj is None 54 54 + 55 55 + 56 56 + class LBoolean(SchemaObject[bool]): 57 57 + __lexicon_type__: str = "boolean" 58 58 + default: bool | None = None 59 59 + const: bool | None = None 60 60 + 61 61 + def __init__(self, obj: dict[str, JSONObject]): 62 62 + if not isinstance(obj, dict): 63 63 + raise TypeError("Lexicon typedef must be object") 64 64 + assert obj.get("type") == "boolean" 65 65 + # Default is bool or None 66 66 + default = obj.get("default") 67 67 + assert isinstance(default, bool) or default is None 68 68 + self.default = default 69 69 + # Const is bool or None 70 70 + const = obj.get("const") 71 71 + assert isinstance(const, bool) or const is None 72 72 + self.const = const 73 73 + 74 74 + def serialize(self, obj: bool | None) -> JSONObject: 75 75 + # Const -> Empty 76 76 + if self.const is not None: 77 77 + assert self.const == obj 78 78 + return Empty 79 79 + # None -> Default 80 80 + if obj is None: 81 81 + assert self.default is not None 82 82 + return self.default 83 83 + assert isinstance(obj, bool) 84 84 + return obj 85 85 + 86 86 + def deserialize(self, obj: JSONObject) -> bool: 87 87 + # Const -> VALUE 88 88 + if self.const is not None: 89 89 + return self.const 90 90 + # None -> Default 91 91 + if obj is None: 92 92 + assert self.default is not None 93 93 + return self.default 94 94 + assert isinstance(obj, bool) 95 95 + return obj 96 96 + 97 97 + def validate_json(self, obj: JSONObject) -> bool: 98 98 + # Const: Must be empty 99 99 + if self.const is not None: 100 100 + # TODO: Must obj be Empty or can it opt be eq const? 101 101 + return obj is Empty 102 102 + # Empty: Must have default 103 103 + if obj is Empty: 104 104 + return self.default is not None 105 105 + # Must be bool 106 106 + return isinstance(obj, bool) 107 107 + 108 108 + def validate(self, obj: bool | None) -> bool: 109 109 + # Const: Must be eq to const 110 110 + if self.const is not None: 111 111 + return obj == self.const 112 112 + # Must be bool or opt None if default exists 113 113 + return isinstance(obj, bool) or (self.default is not None and obj is None) 114 114 + 115 115 + 116 116 + class LInteger(SchemaObject[int]): 117 117 + __lexicon_type__: str = "integer" 118 118 + minimum: int | None = None 119 119 + maximum: int | None = None 120 120 + enum: list[int] | None = None 121 121 + default: int | None = None 122 122 + const: int | None = None 123 123 + 124 124 + def __init__(self, obj: dict[str, JSONObject]): 125 125 + if not isinstance(obj, dict): 126 126 + raise TypeError("Lexicon typedef must be object") 127 127 + assert obj.get("type") == "integer" 128 128 + # Default is int or None 129 129 + default = obj.get("default") 130 130 + assert isinstance(default, int) or default is None 131 131 + self.default = default 132 132 + # Const is int or None 133 133 + const = obj.get("const") 134 134 + assert isinstance(const, int) or const is None 135 135 + self.const = const 136 136 + # Enum is list[int] or None 137 137 + enum = obj.get("enum") 138 138 + assert ( 139 139 + isinstance(enum, list) and all(isinstance(element, int) for element in enum) 140 140 + ) or enum is None 141 141 + # Minimum is int or None 142 142 + minimum = obj.get("minimum") 143 143 + assert isinstance(minimum, int) or minimum is None 144 144 + self.minimum = minimum 145 145 + # Maximum is int or None 146 146 + maximum = obj.get("maximum") 147 147 + assert isinstance(maximum, int) or maximum is None 148 148 + self.maximum = maximum 149 149 + self.enum = enum # type: ignore # Linter does not see: all(isinstance(element, int) for element in enum) 150 150 + 151 151 + def serialize(self, obj: int | None) -> JSONObject: 152 152 + # Const -> Empty 153 153 + if self.const is not None: 154 154 + assert self.const == obj 155 155 + return Empty 156 156 + # None -> Default 157 157 + if obj is None: 158 158 + assert self.default is not None 159 159 + return self.default 160 160 + assert self.validate(obj) 161 161 + assert isinstance(obj, int) 162 162 + return obj 163 163 + 164 164 + def deserialize(self, obj: JSONObject) -> int: 165 165 + # Const -> VALUE 166 166 + if self.const: 167 167 + return self.const 168 168 + # None -> Default 169 169 + if obj is None: 170 170 + assert self.default is not None 171 171 + return self.default 172 172 + assert self.validate_json(obj) 173 173 + assert isinstance(obj, int) 174 174 + return obj 175 175 + 176 176 + def validate_json(self, obj: JSONObject) -> bool: 177 177 + # Const: Must be Empty 178 178 + if self.const is not None: 179 179 + return obj is Empty 180 180 + # Empty: Must have default 181 181 + if obj is Empty: 182 182 + return self.default is not None 183 183 + # If enum, must be included 184 184 + if self.enum and obj not in self.enum: 185 185 + return False 186 186 + # Must be int 187 187 + if not isinstance(obj, int): 188 188 + return False 189 189 + # May not be out of bounds 190 190 + if self.minimum is not None and obj < self.minimum: 191 191 + return False 192 192 + if self.maximum is not None and obj > self.maximum: 193 193 + return False 194 194 + return True 195 195 + 196 196 + def validate(self, obj: int | None) -> bool: 197 197 + # Const: Must be eq to const 198 198 + if self.const is not None: 199 199 + return obj == self.const 200 200 + # If enum, must be in enum 201 201 + if self.enum and obj not in self.enum: 202 202 + return False 203 203 + # None: Must have default 204 204 + if obj is None: 205 205 + return self.default is not None 206 206 + # Must be int 207 207 + if not isinstance(obj, int): 208 208 + return False 209 209 + # May not be out of bounds 210 210 + if self.minimum is not None and obj < self.minimum: 211 211 + return False 212 212 + if self.maximum is not None and obj > self.maximum: 213 213 + return False 214 214 + return True 215 215 + 216 216 + 217 217 + type StringFormatable = TID | NSID 218 218 + STRING_FORMATABLE = (TID, NSID) 219 219 + STRING_FORMATS = { 220 220 + "at-identifier": ..., 221 221 + "at-uri": ..., 222 222 + "cid": ..., 223 223 + "datetime": ..., 224 224 + "did": DID, 225 225 + "handle": ..., 226 226 + "nsid": NSID, 227 227 + "tid": TID, 228 228 + "record-key": ..., 229 229 + "uri": ..., 230 230 + "language": ..., 231 231 + } 232 232 + 233 233 + 234 234 + class LString(SchemaObject[str | StringFormatable]): 235 235 + __lexicon_type__: str = "string" 236 236 + description: str | None = None 237 237 + format: str | None = None 238 238 + max_length: int | None = None 239 239 + min_length: int | None = None 240 240 + maxGraphemes: int | None = None 241 241 + minGraphemes: int | None = None 242 242 + known_values: list[str] | None = None 243 243 + enum: list[str] | None = None 244 244 + default: str | None = None 245 245 + const: str | None = None 246 246 + 247 247 + def __init__(self, obj: dict[str, JSONObject]): 248 248 + if not isinstance(obj, dict): 249 249 + raise TypeError("Lexicon typedef must be object") 250 250 + assert obj.get("type") == "string" 251 251 + # Default is str or None 252 252 + default = obj.get("default") 253 253 + assert isinstance(default, str) or default is None 254 254 + self.default = default 255 255 + # Const is str or None 256 256 + const = obj.get("const") 257 257 + assert isinstance(const, str) or const is None 258 258 + self.const = const 259 259 + # Format is str or None 260 260 + format_ = obj.get("format") 261 261 + assert isinstance(format_, str) or format_ is None 262 262 + self.format = format_ 263 263 + # Enum is list[str] or None 264 264 + enum = obj.get("enum") 265 265 + assert ( 266 266 + isinstance(enum, list) and all(isinstance(element, int) for element in enum) 267 267 + ) or enum is None 268 268 + self.enum = enum # type: ignore # Linter does not see: all(isinstance(element, str) for element in enum) 269 269 + # minLength is int or None 270 270 + min_length = obj.get("minLength") 271 271 + assert isinstance(min_length, int) or min_length is None 272 272 + self.min_length = min_length 273 273 + # maxLength is int or None 274 274 + max_length = obj.get("maxLength") 275 275 + assert isinstance(max_length, int) or max_length is None 276 276 + self.max_length = max_length 277 277 + 278 278 + def serialize(self, obj: StringFormatable | str | None) -> JSONObject: 279 279 + # Const -> Empty 280 280 + if self.const is not None: 281 281 + assert self.const == obj 282 282 + return Empty 283 283 + # None -> Default 284 284 + if obj is None: 285 285 + assert self.default is not None 286 286 + return self.default 287 287 + assert self.validate(obj) 288 288 + if self.format is not None: 289 289 + assert isinstance(obj, STRING_FORMATS[self.format]) 290 290 + obj = str(obj) 291 291 + assert isinstance(obj, str) 292 292 + return obj 293 293 + 294 294 + def deserialize(self, obj: JSONObject) -> str | StringFormatable: 295 295 + # Const -> VALUE 296 296 + if self.const: 297 297 + return self.const 298 298 + # None -> Default 299 299 + if obj is None: 300 300 + assert self.default is not None 301 301 + return self.default 302 302 + assert self.validate_json(obj) 303 303 + assert isinstance(obj, str) 304 304 + if self.format is not None: 305 305 + obj = STRING_FORMATS[self.format](obj) 306 306 + return obj 307 307 + 308 308 + def validate_json(self, obj: JSONObject) -> bool: 309 309 + # Const: Must be Empty 310 310 + if self.const is not None: 311 311 + return obj is Empty 312 312 + # Empty: Must have default 313 313 + if obj is Empty: 314 314 + return self.default is not None 315 315 + # If enum, must be included 316 316 + if self.enum and obj not in self.enum: 317 317 + return False 318 318 + # Must be str 319 319 + if not isinstance(obj, str): 320 320 + return False 321 321 + # May not be out of bounds 322 322 + if self.min_length is not None and len(obj) < self.min_length: 323 323 + return False 324 324 + if self.max_length is not None and len(obj) > self.max_length: 325 325 + return False 326 326 + # Can be formatable 327 327 + if self.format is not None: 328 328 + # try: 329 329 + # TODO: Improve this ugly thind 330 330 + STRING_FORMATS[self.format](obj) 331 331 + # except Exception: 332 332 + # return False 333 333 + return True 334 334 + 335 335 + def validate(self, obj: StringFormatable | str | None) -> bool: 336 336 + # Const: Must be eq to const 337 337 + if self.const is not None: 338 338 + return obj == self.const 339 339 + # If enum, must be in enum 340 340 + if self.enum and obj not in self.enum: 341 341 + return False 342 342 + # None: Must have default 343 343 + if obj is None: 344 344 + return self.default is not None 345 345 + # Can be formatable 346 346 + if self.format is not None: 347 347 + if not isinstance(obj, STRING_FORMATS[self.format]): 348 348 + return False 349 349 + obj = str(obj) 350 350 + # Must be str 351 351 + if not isinstance(obj, str): 352 352 + return False 353 353 + # May not be out of bounds 354 354 + if self.min_length is not None and len(obj) < self.min_length: 355 355 + return False 356 356 + if self.max_length is not None and len(obj) > self.max_length: 357 357 + return False 358 358 + return True 359 359 + 360 360 + 361 361 + class LBytes(SchemaObject[bytes]): 362 362 + __lexicon_type__: str = "bytes" 363 363 + description: str | None = None 364 364 + format: str | None = None 365 365 + max_length: int | None = None 366 366 + min_length: int | None = None 367 367 + 368 368 + def __init__(self, obj: dict[str, JSONObject]): 369 369 + if not isinstance(obj, dict): 370 370 + raise TypeError("Lexicon typedef must be object") 371 371 + assert obj.get("type") == "bytes" 372 372 + # minLength is int or None 373 373 + min_length = obj.get("minLength") 374 374 + assert isinstance(min_length, int) or min_length is None 375 375 + self.min_length = min_length 376 376 + # maxLength is int or None 377 377 + max_length = obj.get("maxLength") 378 378 + assert isinstance(max_length, int) or max_length is None 379 379 + self.max_length = max_length 380 380 + 381 381 + def serialize(self, obj: bytes) -> JSONObject: 382 382 + assert self.min_length is None or len(obj) >= self.min_length 383 383 + assert self.max_length is None or len(obj) <= self.max_length 384 384 + return {"$bytes": base64.b64encode(obj).decode("ascii")} 385 385 + 386 386 + def deserialize(self, obj: JSONObject) -> bytes: 387 387 + assert isinstance(obj, dict) 388 388 + assert len(obj.keys()) == 1 389 389 + vobj = obj.get("$bytes") 390 390 + assert isinstance(vobj, str) 391 391 + bobj = base64.b64decode(vobj) 392 392 + # May not be out of bounds 393 393 + assert self.min_length is None or len(bobj) >= self.min_length 394 394 + assert self.max_length is None or len(bobj) <= self.max_length 395 395 + return bobj 396 396 + 397 397 + def validate_json(self, obj: JSONObject) -> bool: 398 398 + if not isinstance(obj, dict): 399 399 + return False 400 400 + if len(obj.keys()) != 1: 401 401 + return False 402 402 + vobj = obj.get("$bytes") 403 403 + if not isinstance(vobj, str): 404 404 + return False 405 405 + bobj = base64.b64decode(vobj) 406 406 + # May not be out of bounds 407 407 + if self.min_length is not None and len(bobj) < self.min_length: 408 408 + return False 409 409 + if self.max_length is not None and len(bobj) > self.max_length: 410 410 + return False 411 411 + return True 412 412 + 413 413 + def validate(self, obj: bytes | None) -> bool: 414 414 + if not isinstance(obj, bytes): 415 415 + return False 416 416 + # May not be out of bounds 417 417 + if self.min_length is not None and len(obj) < self.min_length: 418 418 + return False 419 419 + if self.max_length is not None and len(obj) > self.max_length: 420 420 + return False 421 421 + return True 422 422 + 423 423 + 424 424 + class LArray[T](SchemaObject[list[SchemaObject[T]]]): 425 425 + __lexicon_type__: str = "array" 426 426 + items: SchemaObject[T] 427 427 + description: str | None = None 428 428 + min_length: int | None = None 429 429 + max_length: int | None = None 430 430 + 431 431 + def __init__(self, obj: dict[str, JSONObject]): 432 432 + if not isinstance(obj, dict): 433 433 + raise TypeError("Lexicon typedef must be object") 434 434 + assert obj.get("type") == "array" 435 435 + # minLength is int or None 436 436 + min_length = obj.get("minLength") 437 437 + assert isinstance(min_length, int) or min_length is None 438 438 + self.min_length = min_length 439 439 + # maxLength is int or None 440 440 + max_length = obj.get("maxLength") 441 441 + assert isinstance(max_length, int) or max_length is None 442 442 + self.max_length = max_length 443 443 + # items_obj is SchemaObject 444 444 + items = obj.get("items") 445 445 + assert isinstance(items, dict) 446 446 + items_obj = LexiconObject(items) 447 447 + self.items = items_obj # type: ignore # Type Hinter is dumb 448 448 + 449 449 + def serialize(self, obj: list | None) -> JSONObject: 450 450 + assert isinstance(obj, list) 451 451 + assert self.validate(obj) 452 452 + return [self.items.serialize(element) for element in obj] 453 453 + 454 454 + def deserialize(self, obj: JSONObject) -> list: 455 455 + assert self.validate_json(obj) 456 456 + assert isinstance(obj, list) 457 457 + return [self.items.deserialize(element) for element in obj] 458 458 + 459 459 + def validate_json(self, obj: JSONObject) -> bool: 460 460 + # Must be list 461 461 + if not isinstance(obj, list): 462 462 + return False 463 463 + # validate childs 464 464 + if not all(self.items.validate_json(element) for element in obj): 465 465 + return False 466 466 + # May not be out of bounds 467 467 + if self.min_length is not None and len(obj) < self.min_length: 468 468 + return False 469 469 + if self.max_length is not None and len(obj) > self.max_length: 470 470 + return False 471 471 + return True 472 472 + 473 473 + def validate(self, obj: list) -> bool: 474 474 + # Must be str 475 475 + if not isinstance(obj, list): 476 476 + return False 477 477 + # validate childs 478 478 + if not all(self.items.validate(element) for element in obj): 479 479 + return False 480 480 + # May not be out of bounds 481 481 + if self.min_length is not None and len(obj) < self.min_length: 482 482 + return False 483 483 + if self.max_length is not None and len(obj) > self.max_length: 484 484 + return False 485 485 + return True 486 486 + 487 487 + 488 488 + class LObject[T](SchemaObject[dict[str, SchemaObject[T]]]): 489 489 + __lexicon_type__: str = "object" 490 490 + properties: dict[str, "SchemaObject[T]"] 491 491 + description: str | None = None 492 492 + required: list[str] | None = None 493 493 + nullable: list[str] | None = None 494 494 + 495 495 + def __init__(self, obj: dict[str, JSONObject]): 496 496 + if not isinstance(obj, dict): 497 497 + raise TypeError("Lexicon typedef must be object") 498 498 + assert obj.get("type") == "object" 499 499 + # required is list[str] or None 500 500 + required = obj.get("required") 501 501 + if required is not None: 502 502 + assert isinstance(required, list) 503 503 + assert all(isinstance(key, str) for key in required) 504 504 + self.required = required # type: ignore # Again 505 505 + # nullable is list[str] or None 506 506 + nullable = obj.get("nullable") 507 507 + if nullable is not None: 508 508 + assert isinstance(nullable, list) 509 509 + assert all(isinstance(key, str) for key in nullable) 510 510 + self.nullable = nullable # type: ignore # And once again 511 511 + # properties_obj is dict[str, SchemaObject] 512 512 + properties = obj.get("properties") 513 513 + assert isinstance(properties, dict) 514 514 + assert all( 515 515 + isinstance(key, str) and isinstance(value, dict) 516 516 + for key, value in properties.items() 517 517 + ) 518 518 + properties_obj = { 519 519 + key: LexiconObject(value) # type: ignore # I hate this 520 520 + for key, value in properties.items() 521 521 + } 522 522 + self.properties = properties_obj 523 523 + 524 524 + def serialize(self, obj: dict | None) -> JSONObject: 525 525 + assert isinstance(obj, dict) 526 526 + assert self.validate(obj) 527 527 + return { 528 528 + key: None 529 529 + if value is None and self.nullable is not None and key in self.nullable 530 530 + else self.properties[key].serialize(value) 531 531 + for key, value in obj.items() 532 532 + } 533 533 + 534 534 + def deserialize(self, obj: JSONObject) -> dict: 535 535 + assert isinstance(obj, dict) 536 536 + assert self.validate_json(obj) 537 537 + return { 538 538 + key: None 539 539 + if value is None and self.nullable is not None and key in self.nullable 540 540 + else self.properties[key].deserialize(value) 541 541 + for key, value in obj.items() 542 542 + } 543 543 + 544 544 + def validate_json(self, obj: JSONObject) -> bool: 545 545 + # Must be dict 546 546 + if not isinstance(obj, dict): 547 547 + return False 548 548 + if self.required is not None: 549 549 + for key in self.required: 550 550 + if obj.get("key", Empty) is Empty: 551 551 + return False 552 552 + for key in self.properties: 553 553 + if obj.get(key, Empty) is Empty: 554 554 + continue 555 555 + if self.nullable is not None and key in self.nullable and obj[key] is None: 556 556 + continue 557 557 + 558 558 + if not self.properties[key].validate_json(obj[key]): 559 559 + return False 560 560 + return True 561 561 + 562 562 + def validate(self, obj: dict) -> bool: 563 563 + # Must be dict 564 564 + if not isinstance(obj, dict): 565 565 + return False 566 566 + if self.required is not None: 567 567 + for key in self.required: 568 568 + if key not in obj: 569 569 + return False 570 570 + for key in self.properties: 571 571 + if key not in obj: 572 572 + continue 573 573 + if self.nullable is not None and key in self.nullable and obj[key] is None: 574 574 + continue 575 575 + 576 576 + if not self.properties[key].validate(obj[key]): 577 577 + print(key, "is invalid") 578 578 + return False 579 579 + return True 580 580 + 581 581 + 582 582 + class LParams[T](SchemaObject[dict[str, SchemaObject[T]]]): 583 583 + __lexicon_type__: str = "params" 584 584 + properties: dict[str, "SchemaObject[T]"] 585 585 + description: str | None = None 586 586 + required: list[str] | None = None 587 587 + 588 588 + def __init__(self, obj: dict[str, JSONObject]): 589 589 + if not isinstance(obj, dict): 590 590 + raise TypeError("Lexicon typedef must be object") 591 591 + assert obj.get("type") == "params" 592 592 + # required is list[str] or None 593 593 + required = obj.get("required") 594 594 + if required is not None: 595 595 + assert isinstance(required, list) 596 596 + assert all(isinstance(key, str) for key in required) 597 597 + self.required = required # type: ignore # Again 598 598 + # properties_obj is dict[str, SchemaObject] 599 599 + properties = obj.get("properties") 600 600 + assert isinstance(properties, dict) 601 601 + assert all( 602 602 + isinstance(key, str) 603 603 + and isinstance(value, dict) 604 604 + and value.get("type") 605 605 + in ("string", "integer", "boolean", "unknown") # TODO: array 606 606 + for key, value in properties.items() 607 607 + ) 608 608 + properties_obj = { 609 609 + key: LexiconObject(value) # type: ignore # I hate this 610 610 + for key, value in properties.items() 611 611 + } 612 612 + self.properties = properties_obj 613 613 + 614 614 + def serialize(self, obj: dict | None) -> JSONObject: 615 615 + assert isinstance(obj, dict) 616 616 + assert self.validate(obj) 617 617 + return { 618 618 + key: self.properties[key].serialize(value) for key, value in obj.items() 619 619 + } 620 620 + 621 621 + def deserialize(self, obj: JSONObject) -> dict: 622 622 + assert isinstance(obj, dict) 623 623 + assert self.validate_json(obj) 624 624 + return { 625 625 + key: self.properties[key].deserialize(value) for key, value in obj.items() 626 626 + } 627 627 + 628 628 + def validate_json(self, obj: JSONObject) -> bool: 629 629 + # Must be dict 630 630 + if not isinstance(obj, dict): 631 631 + return False 632 632 + if self.required is not None: 633 633 + for key in self.required: 634 634 + if obj.get("key", Empty) is Empty: 635 635 + return False 636 636 + for key in self.properties: 637 637 + if obj.get(key, Empty) is Empty: 638 638 + continue 639 639 + 640 640 + if not self.properties[key].validate_json(obj[key]): 641 641 + return False 642 642 + return True 643 643 + 644 644 + def validate(self, obj: dict) -> bool: 645 645 + # Must be dict 646 646 + if not isinstance(obj, dict): 647 647 + return False 648 648 + if self.required is not None: 649 649 + for key in self.required: 650 650 + if key not in obj: 651 651 + return False 652 652 + for key in self.properties: 653 653 + if key not in obj: 654 654 + continue 655 655 + 656 656 + if not self.properties[key].validate(obj[key]): 657 657 + print(key, "is invalid") 658 658 + return False 659 659 + return True 660 660 + 661 661 + 662 662 + TYPE_MAP: dict[str, type[SchemaObject]] = { 663 663 + "null": LNull, 664 664 + "boolean": LBoolean, 665 665 + "integer": LInteger, 666 666 + "string": LString, 667 667 + "bytes": LBytes, 668 668 + "array": LArray, 669 669 + "object": LObject, 670 670 + "params": LParams, 671 671 + } 672 672 + 673 673 + 674 674 + def LexiconObject(obj: dict[str, JSONObject]): 675 675 + type_ = obj.get("type") 676 676 + if type_ not in TYPE_MAP: 677 677 + raise TypeError(f"Cannot find lexcion type '{type_}'") 678 678 + return TYPE_MAP[type_](obj)

+94

poetry.lock

reviewed

··· 1 1 + # This file is automatically @generated by Poetry 2.0.1 and should not be changed by hand. 2 2 + 3 3 + [[package]] 4 4 + name = "dataclasses-json" 5 5 + version = "0.6.7" 6 6 + description = "Easily serialize dataclasses to and from JSON." 7 7 + optional = false 8 8 + python-versions = "<4.0,>=3.7" 9 9 + groups = ["main"] 10 10 + files = [ 11 11 + {file = "dataclasses_json-0.6.7-py3-none-any.whl", hash = "sha256:0dbf33f26c8d5305befd61b39d2b3414e8a407bedc2834dea9b8d642666fb40a"}, 12 12 + {file = "dataclasses_json-0.6.7.tar.gz", hash = "sha256:b6b3e528266ea45b9535223bc53ca645f5208833c29229e847b3f26a1cc55fc0"}, 13 13 + ] 14 14 + 15 15 + [package.dependencies] 16 16 + marshmallow = ">=3.18.0,<4.0.0" 17 17 + typing-inspect = ">=0.4.0,<1" 18 18 + 19 19 + [[package]] 20 20 + name = "marshmallow" 21 21 + version = "3.26.1" 22 22 + description = "A lightweight library for converting complex datatypes to and from native Python datatypes." 23 23 + optional = false 24 24 + python-versions = ">=3.9" 25 25 + groups = ["main"] 26 26 + files = [ 27 27 + {file = "marshmallow-3.26.1-py3-none-any.whl", hash = "sha256:3350409f20a70a7e4e11a27661187b77cdcaeb20abca41c1454fe33636bea09c"}, 28 28 + {file = "marshmallow-3.26.1.tar.gz", hash = "sha256:e6d8affb6cb61d39d26402096dc0aee12d5a26d490a121f118d2e81dc0719dc6"}, 29 29 + ] 30 30 + 31 31 + [package.dependencies] 32 32 + packaging = ">=17.0" 33 33 + 34 34 + [package.extras] 35 35 + dev = ["marshmallow[tests]", "pre-commit (>=3.5,<5.0)", "tox"] 36 36 + docs = ["autodocsumm (==0.2.14)", "furo (==2024.8.6)", "sphinx (==8.1.3)", "sphinx-copybutton (==0.5.2)", "sphinx-issues (==5.0.0)", "sphinxext-opengraph (==0.9.1)"] 37 37 + tests = ["pytest", "simplejson"] 38 38 + 39 39 + [[package]] 40 40 + name = "mypy-extensions" 41 41 + version = "1.1.0" 42 42 + description = "Type system extensions for programs checked with the mypy type checker." 43 43 + optional = false 44 44 + python-versions = ">=3.8" 45 45 + groups = ["main"] 46 46 + files = [ 47 47 + {file = "mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505"}, 48 48 + {file = "mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558"}, 49 49 + ] 50 50 + 51 51 + [[package]] 52 52 + name = "packaging" 53 53 + version = "25.0" 54 54 + description = "Core utilities for Python packages" 55 55 + optional = false 56 56 + python-versions = ">=3.8" 57 57 + groups = ["main"] 58 58 + files = [ 59 59 + {file = "packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484"}, 60 60 + {file = "packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f"}, 61 61 + ] 62 62 + 63 63 + [[package]] 64 64 + name = "typing-extensions" 65 65 + version = "4.15.0" 66 66 + description = "Backported and Experimental Type Hints for Python 3.9+" 67 67 + optional = false 68 68 + python-versions = ">=3.9" 69 69 + groups = ["main"] 70 70 + files = [ 71 71 + {file = "typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548"}, 72 72 + {file = "typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466"}, 73 73 + ] 74 74 + 75 75 + [[package]] 76 76 + name = "typing-inspect" 77 77 + version = "0.9.0" 78 78 + description = "Runtime inspection utilities for typing module." 79 79 + optional = false 80 80 + python-versions = "*" 81 81 + groups = ["main"] 82 82 + files = [ 83 83 + {file = "typing_inspect-0.9.0-py3-none-any.whl", hash = "sha256:9ee6fc59062311ef8547596ab6b955e1b8aa46242d854bfc78f4f6b0eff35f9f"}, 84 84 + {file = "typing_inspect-0.9.0.tar.gz", hash = "sha256:b23fc42ff6f6ef6954e4852c1fb512cdd18dbea03134f91f856a95ccc9461f78"}, 85 85 + ] 86 86 + 87 87 + [package.dependencies] 88 88 + mypy-extensions = ">=0.3.0" 89 89 + typing-extensions = ">=3.7.4" 90 90 + 91 91 + [metadata] 92 92 + lock-version = "2.1" 93 93 + python-versions = ">=3.13,<4.0" 94 94 + content-hash = "1dcfeebefe3b4358a15c0e5838093c68d46706f10bcf224eb9d49d1fa951af60"

+15

pyproject.toml

reviewed

··· 1 1 + [project] 2 2 + name = "atplex" 3 3 + version = "0.1.0" 4 4 + description = "" 5 5 + authors = [ 6 6 + { name = "JoJoJux", email = "80523427+J0J0HA@users.noreply.github.com" }, 7 7 + ] 8 8 + readme = "README.md" 9 9 + requires-python = ">=3.13,<4.0" 10 10 + dependencies = ["dataclasses-json (>=0.6.7,<0.7.0)"] 11 11 + 12 12 + 13 13 + [build-system] 14 14 + requires = ["poetry-core>=2.0.0,<3.0.0"] 15 15 + build-backend = "poetry.core.masonry.api"

+168

result.py

reviewed

··· 1 1 + import abc 2 2 + from typing import Any, Callable, NoReturn 3 3 + 4 4 + # This file is not in any way related to the project, 5 5 + # I just wanted to built Rust's error handling in python so here it is. 6 6 + 7 7 + 8 8 + class Result[T: Any, E: Exception](abc.ABC): 9 9 + @abc.abstractmethod 10 10 + def expect(self, message: str) -> T | NoReturn: ... 11 11 + 12 12 + @abc.abstractmethod 13 13 + def unwrap(self) -> T | NoReturn: ... 14 14 + 15 15 + @abc.abstractmethod 16 16 + def unwrap_or(self, value: T) -> T: ... 17 17 + 18 18 + @abc.abstractmethod 19 19 + def unwrap_or_else(self, func: Callable[..., T]) -> T: ... 20 20 + 21 21 + @abc.abstractmethod 22 22 + def unwrap_unchecked(self) -> T | E: ... 23 23 + 24 24 + @abc.abstractmethod 25 25 + def expect_err(self, message: str) -> E | NoReturn: ... 26 26 + 27 27 + @abc.abstractmethod 28 28 + def unwrap_err(self) -> E | NoReturn: ... 29 29 + 30 30 + @abc.abstractmethod 31 31 + def unwrap_err_unchecked(self) -> E | T: ... 32 32 + 33 33 + @abc.abstractmethod 34 34 + def is_err(self) -> bool: ... 35 35 + 36 36 + @abc.abstractmethod 37 37 + def is_ok(self) -> bool: ... 38 38 + 39 39 + def ok(self) -> T | None: 40 40 + if self.is_ok(): 41 41 + return ~self 42 42 + return None 43 43 + 44 44 + def err(self) -> E | None: 45 45 + if self.is_err(): 46 46 + return -self 47 47 + return None 48 48 + 49 49 + def transpose(self) -> "Result[T, E] | None": 50 50 + if self.is_ok() and self.ok() is None: 51 51 + return None 52 52 + return self 53 53 + 54 54 + def __invert__(self) -> T | NoReturn: 55 55 + return self.unwrap() 56 56 + 57 57 + def __neg__(self) -> E: 58 58 + return self.unwrap_err() 59 59 + 60 60 + def __and__(self, other: "Result") -> "Result[T, E]": 61 61 + return self if self.is_err() else other 62 62 + 63 63 + def __or__(self, other: "Result") -> "Result[T, E]": 64 64 + return self if self.is_ok() else other 65 65 + 66 66 + def __rshift__(self, func: Callable[..., "Result[T, E]"]) -> "Result[T, E]": 67 67 + if self.is_err(): 68 68 + return self 69 69 + return func() 70 70 + 71 71 + def __floordiv__(self, func: Callable[..., "Result[T, E]"]) -> "Result[T, E]": 72 72 + if self.is_ok(): 73 73 + return self 74 74 + return func() 75 75 + 76 76 + 77 77 + class Ok[T: Any, E: Exception](Result[T, E]): 78 78 + __match_args__ = ("value",) 79 79 + value: Any 80 80 + 81 81 + def __init__(self, value: T): 82 82 + self.value = value 83 83 + 84 84 + def expect(self, message: str) -> T: 85 85 + return self.value 86 86 + 87 87 + def unwrap(self) -> T: 88 88 + return self.value 89 89 + 90 90 + def unwrap_or(self, value: T) -> T: 91 91 + return self.value 92 92 + 93 93 + def unwrap_or_else(self, func: Callable[[], T]) -> T: 94 94 + return self.value 95 95 + 96 96 + def unwrap_unchecked(self) -> T: 97 97 + return self.value 98 98 + 99 99 + def expect_err(self, message: str) -> NoReturn: 100 100 + raise RuntimeError(message) 101 101 + 102 102 + def unwrap_err(self) -> NoReturn: 103 103 + raise RuntimeError(self.value) 104 104 + 105 105 + def unwrap_err_unchecked(self) -> T: 106 106 + return self.value 107 107 + 108 108 + def is_err(self) -> bool: 109 109 + return False 110 110 + 111 111 + def is_ok(self) -> bool: 112 112 + return True 113 113 + 114 114 + def __repr__(self) -> str: 115 115 + return f"Ok({repr(self.value)})" 116 116 + 117 117 + 118 118 + class Err[T: Any, E: Exception](Result[T, E]): 119 119 + __match_args__ = ("message",) 120 120 + message: E 121 121 + 122 122 + def __init__(self, message: E): 123 123 + self.message = message 124 124 + 125 125 + def expect(self, message: str) -> NoReturn: 126 126 + raise RuntimeError(message) 127 127 + 128 128 + def unwrap(self) -> NoReturn: 129 129 + raise self.message 130 130 + 131 131 + def unwrap_or(self, value: T) -> T: 132 132 + return value 133 133 + 134 134 + def unwrap_or_else(self, func: Callable[[], T]) -> T: 135 135 + return func() 136 136 + 137 137 + def unwrap_unchecked(self) -> E: 138 138 + return self.message 139 139 + 140 140 + def expect_err(self, message: str) -> E: 141 141 + return self.message 142 142 + 143 143 + def unwrap_err(self) -> E: 144 144 + return self.message 145 145 + 146 146 + def unwrap_err_unchecked(self) -> E: 147 147 + return self.message 148 148 + 149 149 + def is_ok(self) -> bool: 150 150 + return False 151 151 + 152 152 + def is_err(self) -> bool: 153 153 + return True 154 154 + 155 155 + def __repr__(self) -> str: 156 156 + return f"Err({repr(self.message)})" 157 157 + 158 158 + 159 159 + result_a = Ok(10) 160 160 + result_b = Err(Exception("hello")) 161 161 + 162 162 + match result_b: 163 163 + case Ok(result): 164 164 + print("+", result) 165 165 + case Err(error): 166 166 + print("-", error) 167 167 + 168 168 + print(result_a & result_b)

src/__init__.py

reviewed

This is a binary file and will not be displayed.

src/coding/__init__.py

reviewed

This is a binary file and will not be displayed.

+22

src/coding/base32_sortable.py

reviewed

··· 1 1 + ALPHABET = "234567abcdefghijklmnopqrstuvwxyz" 2 2 + DECODING_MAP = {v: k for k, v in enumerate(ALPHABET)} 3 3 + 4 4 + 5 5 + def encode_int(data: int, length: int) -> str: 6 6 + encoded = "" 7 7 + for i in range(0, length, 5): 8 8 + c = data & 0b11111 9 9 + data >>= 5 10 10 + encoded += ALPHABET[c] 11 11 + return "".join(reversed(encoded)) 12 12 + 13 13 + 14 14 + def decode_int(data: str) -> int: 15 15 + decoded = 0 16 16 + for letter in data: 17 17 + if letter not in DECODING_MAP: 18 18 + raise ValueError("Non-base32-sortable digit found") 19 19 + 20 20 + decoded <<= 5 21 21 + decoded += DECODING_MAP[letter] 22 22 + return decoded

+7

src/id/__init__.py

reviewed

··· 1 1 + from .did import DID 2 2 + from .nsid import NSID, NSIDGlob 3 3 + from .tid import TID 4 4 + 5 5 + type StringableIdentifier = DID | NSID | TID 6 6 + 7 7 + __all__ = ["DID", "NSID", "NSIDGlob", "TID", "StringableIdentifier"]

+5

src/id/cid.py

reviewed

··· 1 1 + class CIDLink: 2 2 + link: str 3 3 + 4 4 + def __init__(self, link: str): 5 5 + self.link = link

+58

src/id/did.py

reviewed

··· 1 1 + import enum 2 2 + import re 3 3 + from typing import overload 4 4 + 5 5 + 6 6 + class DIDMethod(enum.StrEnum): 7 7 + WEB = "web" 8 8 + PLC = "plc" 9 9 + 10 10 + 11 11 + class DID: 12 12 + __lexicon_string_format__ = "did" 13 13 + 14 14 + PATTERN = re.compile(r"^did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$") 15 15 + METHOD_PATTERN = re.compile(r"^[a-z]+$") 16 16 + VALUE_PATTERN = re.compile(r"^[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$") 17 17 + 18 18 + __method: DIDMethod 19 19 + __value: str 20 20 + 21 21 + @overload 22 22 + def __init__(self, did: str, /): ... 23 23 + @overload 24 24 + def __init__(self, method: str | DIDMethod, value: str, /): ... 25 25 + 26 26 + def __init__(self, did_or_method: str | DIDMethod, value: str | None = None, /): 27 27 + if value is None: 28 28 + if not self.PATTERN.match(did_or_method): 29 29 + raise ValueError("Invalid DID: does not match pattern") 30 30 + did_or_method, value = did_or_method[4:].split(":", 1) 31 31 + else: 32 32 + if not ( 33 33 + isinstance(did_or_method, DIDMethod) 34 34 + or self.METHOD_PATTERN.match(did_or_method) 35 35 + ): 36 36 + raise ValueError("Invalid DID: method does not match pattern") 37 37 + if not self.VALUE_PATTERN.match(value): 38 38 + raise ValueError("Invalid DID: value does not match pattern") 39 39 + self.__method = ( 40 40 + DIDMethod(did_or_method) 41 41 + if not isinstance(did_or_method, DIDMethod) 42 42 + else did_or_method 43 43 + ) 44 44 + self.__value = value 45 45 + 46 46 + @property 47 47 + def method(self) -> str: 48 48 + return self.__method 49 49 + 50 50 + @property 51 51 + def value(self) -> str: 52 52 + return self.__value 53 53 + 54 54 + def __str__(self) -> str: 55 55 + return f"did:{self.__method}:{self.__value}" 56 56 + 57 57 + def __repr__(self) -> str: 58 58 + return str(self)

+46

src/id/handle.py

reviewed

··· 1 1 + import re 2 2 + 3 3 + 4 4 + class Handle: 5 5 + __lexicon_string_format__ = "handle" 6 6 + 7 7 + PATTERN = re.compile( 8 8 + 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])?$" 9 9 + ) 10 10 + FORBIDDEN_TLDS = [ 11 11 + ".alt", 12 12 + ".arpa", 13 13 + ".example", 14 14 + ".internal", 15 15 + ".local", 16 16 + ".localhost", 17 17 + ".onion", 18 18 + ] 19 19 + 20 20 + __handle: str 21 21 + 22 22 + @property 23 23 + def valid(self) -> bool: 24 24 + return self.__handle != "handle.invalid" 25 25 + 26 26 + def __init__(self, handle: str): 27 27 + handle = handle.lower() 28 28 + if not self.PATTERN.match(handle): 29 29 + raise ValueError("Invalid Handle: does not match pattern") 30 30 + if any(handle.endswith(tld) for tld in self.FORBIDDEN_TLDS): 31 31 + raise ValueError("Invalid Handle: uses forbidden tld") 32 32 + if handle.endswith(".invalid") and not handle == "handle.invalid": 33 33 + raise ValueError( 34 34 + "Invalid Handle: '.invalid' tld may only be used with 'handle.invalid'" 35 35 + ) 36 36 + self.__handle = handle 37 37 + 38 38 + @property 39 39 + def labels(self) -> list[str]: 40 40 + return self.__handle.split(".") 41 41 + 42 42 + def __str__(self) -> str: 43 43 + return self.__handle 44 44 + 45 45 + def __repr__(self) -> str: 46 46 + return f"Handle({str(self)})"

+12

src/id/literal.py

reviewed

··· 1 1 + class Literal: 2 2 + __literal: str 3 3 + 4 4 + def __init__(self, literal: str): 5 5 + self.__record_key_type__ = "literal:" + literal 6 6 + self.__literal = literal 7 7 + 8 8 + def __str__(self) -> str: 9 9 + return self.__literal 10 10 + 11 11 + def __repr__(self) -> str: 12 12 + return f"Literal({self.__literal})"

+73

src/id/nsid.py

reviewed

··· 1 1 + import re 2 2 + from typing import Iterable, overload 3 3 + 4 4 + 5 5 + class NSID: 6 6 + __lexicon_string_format__ = "nsid" 7 7 + 8 8 + PATTERN = re.compile( 9 9 + 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})?)$" 10 10 + ) 11 11 + FRAGMENT_PATTERN = re.compile(r"(\.[a-zA-Z]([a-zA-Z0-9]{0,62})?)") 12 12 + 13 13 + __segments: list[str] 14 14 + __fragment: str | None 15 15 + 16 16 + @overload 17 17 + def __init__(self, nsid: str) -> None: ... 18 18 + @overload 19 19 + def __init__(self, nsid: Iterable[str]) -> None: ... 20 20 + 21 21 + def __init__(self, nsid: str | Iterable[str]) -> None: 22 22 + if not isinstance(nsid, str): 23 23 + nsid = ".".join(nsid) 24 24 + if "#" in nsid: 25 25 + nsid, self.__fragment = nsid.rsplit("#", 1) 26 26 + if not self.FRAGMENT_PATTERN.match(self.__fragment): 27 27 + raise ValueError("Invalid NSID: fragment does not match pattern") 28 28 + else: 29 29 + self.__fragment = None 30 30 + if not self.PATTERN.match(nsid): 31 31 + raise ValueError("Invalid NSID: does not match pattern") 32 32 + self.__segments = nsid.split(".") 33 33 + 34 34 + @property 35 35 + def segments(self) -> list[str]: 36 36 + return self.__segments 37 37 + 38 38 + @property 39 39 + def fragment(self) -> str | None: 40 40 + return self.__fragment 41 41 + 42 42 + @property 43 43 + def domain_authority(self) -> list[str]: 44 44 + return self.__segments[:-1] 45 45 + 46 46 + @property 47 47 + def name(self) -> str: 48 48 + return self.__segments[-1] 49 49 + 50 50 + def __str__(self) -> str: 51 51 + return ".".join(self.__segments) + ( 52 52 + "#" + self.__fragment if self.__fragment is not None else "" 53 53 + ) 54 54 + 55 55 + def __repr__(self) -> str: 56 56 + return f"NSID({str(self)})" 57 57 + 58 58 + 59 59 + class NSIDGlob(NSID): 60 60 + PATTERN = re.compile( 61 61 + 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})?|\*))|\*)$" 62 62 + ) 63 63 + 64 64 + @classmethod 65 65 + def any(cls): 66 66 + return cls("*") 67 67 + 68 68 + @classmethod 69 69 + def sub_of(cls, nsid: NSID): 70 70 + return cls(str(nsid) + ".*") 71 71 + 72 72 + def matches(self, nsid: NSID): 73 73 + return str(nsid).startswith(str(self)[:-1])

+110

src/id/tid.py

reviewed

··· 1 1 + import base64 2 2 + import enum 3 3 + import random 4 4 + import re 5 5 + import time 6 6 + from typing import overload 7 7 + 8 8 + from ..coding import base32_sortable 9 9 + 10 10 + 11 11 + LAST_GENERATED_TID = 0 12 12 + CLOCK_IDENTIFIER = random.randint(0, ~-(1 << 10)) 13 13 + 14 14 + 15 15 + class TID: 16 16 + __lexicon_string_format__ = "tid" 17 17 + 18 18 + PATTERN = re.compile(r"^[234567abcdefghij][234567abcdefghijklmnopqrstuvwxyz]{12}$") 19 19 + 20 20 + __value: int 21 21 + 22 22 + def __init__(self, tid: bytes | int | str, /): 23 23 + if isinstance(tid, bytes): 24 24 + tid = int.from_bytes(tid, "big", signed=False) 25 25 + if isinstance(tid, str): 26 26 + if not self.PATTERN.match(tid): 27 27 + raise ValueError("Invalid TID: does not match pattern") 28 28 + tid = base32_sortable.decode_int(tid) 29 29 + if not isinstance(tid, int): 30 30 + raise TypeError( 31 31 + f"Invalid TID: cannot construct from '{type(tid).__name__}'" 32 32 + ) 33 33 + if tid >> 63: 34 34 + raise ValueError("Invalid TID: first bytes high bit must be 0") 35 35 + self.__value = tid 36 36 + 37 37 + @property 38 38 + def clock_identifier(self) -> int: 39 39 + return self.__value & ~-(1 << 10) 40 40 + 41 41 + @property 42 42 + def timestamp(self) -> int: 43 43 + return self.__value >> 10 44 44 + 45 45 + @property 46 46 + def value(self) -> int: 47 47 + return self.__value 48 48 + 49 49 + def as_bytes(self) -> bytes: 50 50 + return self.__value.to_bytes(8, "big", signed=False) 51 51 + 52 52 + def __str__(self) -> str: 53 53 + return f"{base32_sortable.encode_int(self.__value, 64)}" 54 54 + 55 55 + def __repr__(self) -> str: 56 56 + return f"TID({self.__value})" 57 57 + 58 58 + def __lt__(self, other) -> bool: 59 59 + if not isinstance(other, TID): 60 60 + raise TypeError( 61 61 + f"Cannot compare '{type(self).__name__}' to '{type(other).__name__}'" 62 62 + ) 63 63 + return self.__value < other.__value 64 64 + 65 65 + def __le__(self, other) -> bool: 66 66 + if not isinstance(other, TID): 67 67 + raise TypeError( 68 68 + f"Cannot compare '{type(self).__name__}' to '{type(other).__name__}'" 69 69 + ) 70 70 + return self.__value <= other.__value 71 71 + 72 72 + def __gt__(self, other) -> bool: 73 73 + if not isinstance(other, TID): 74 74 + raise TypeError( 75 75 + f"Cannot compare '{type(self).__name__}' to '{type(other).__name__}'" 76 76 + ) 77 77 + return self.__value > other.__value 78 78 + 79 79 + def __ge__(self, other) -> bool: 80 80 + if not isinstance(other, TID): 81 81 + raise TypeError( 82 82 + f"Cannot compare '{type(self).__name__}' to '{type(other).__name__}'" 83 83 + ) 84 84 + return self.__value >= other.__value 85 85 + 86 86 + def __eq__(self, other) -> bool: 87 87 + if not isinstance(other, TID): 88 88 + raise TypeError( 89 89 + f"Cannot compare '{type(self).__name__}' to '{type(other).__name__}'" 90 90 + ) 91 91 + return self.__value == other.__value 92 92 + 93 93 + def __neq__(self, other: "TID") -> bool: 94 94 + if not isinstance(other, TID): 95 95 + raise TypeError( 96 96 + f"Cannot compare '{type(self).__name__}' to '{type(other).__name__}'" 97 97 + ) 98 98 + return self.__value != other.__value 99 99 + 100 100 + @classmethod 101 101 + def now(cls: "type[TID]") -> "TID": 102 102 + global LAST_GENERATED_TID 103 103 + 104 104 + timestamp = time.monotonic_ns() // 1000 105 105 + if timestamp <= LAST_GENERATED_TID: 106 106 + LAST_GENERATED_TID += 1 107 107 + timestamp = LAST_GENERATED_TID 108 108 + 109 109 + value = ((timestamp & ~-(1 << 53)) << 10) + CLOCK_IDENTIFIER 110 110 + return cls(value)

+4

src/lexicon/__init__.py

reviewed

··· 1 1 + from .lexicon import schema_object, lexicon 2 2 + 3 3 + 4 4 + __all__ = ["schema_object", "lexicon"]

+244

src/lexicon/codegen.py

reviewed

··· 1 1 + import glob 2 2 + import os 3 3 + import pathlib 4 4 + from typing import Literal 5 5 + import ast 6 6 + from src.id.nsid import NSID 7 7 + from src.lexicon.lexicon import ( 8 8 + LLexicon, 9 9 + LObject, 10 10 + LParams, 11 11 + LQuery, 12 12 + SchemaObject, 13 13 + lexicon, 14 14 + ) 15 15 + 16 16 + 17 17 + TYPE_MAP: dict[str, str] = { 18 18 + "null": "None", 19 19 + "boolean": "bool", 20 20 + "integer": "int", 21 21 + "string": "str", 22 22 + "bytes": "bytes", 23 23 + # "cid-link": ..., 24 24 + # "blob": ..., 25 25 + "array": "list", 26 26 + "object": "object", 27 27 + # "params": ..., 28 28 + "token": "str", 29 29 + # "ref": ..., 30 30 + # "union": ..., 31 31 + # "unknown": ..., 32 32 + # "record": ..., 33 33 + # "query": ..., 34 34 + # "procedure": ..., 35 35 + # "subscription": ..., 36 36 + } 37 37 + 38 38 + LEXICON_STORE = pathlib.Path.cwd() / "lex" 39 39 + 40 40 + 41 41 + def content_for_type(fragment: SchemaObject): 42 42 + if isinstance(fragment, LObject): 43 43 + return [ 44 44 + ast.AnnAssign( 45 45 + target=ast.Name(field), 46 46 + annotation=ast.Constant( 47 47 + TYPE_MAP[schema.__lexicon_type__] 48 48 + + (" | None" if field in (fragment.nullables or []) else "") 49 49 + ), 50 50 + value=None, 51 51 + simple=True, 52 52 + ) 53 53 + for field, schema in fragment.properties.items() 54 54 + ] or [ast.Pass()] 55 55 + if isinstance(fragment, LParams): 56 56 + return [ 57 57 + ast.AnnAssign( 58 58 + target=ast.Name(field), 59 59 + annotation=ast.Constant( 60 60 + TYPE_MAP[schema.__lexicon_type__] 61 61 + + (" | None" if field not in (fragment.required or []) else "") 62 62 + ), 63 63 + value=None, 64 64 + simple=True, 65 65 + ) 66 66 + for field, schema in fragment.properties.items() 67 67 + ] or [ast.Pass()] 68 68 + if isinstance(fragment, LQuery): 69 69 + return [] 70 70 + return [ast.Pass()] 71 71 + 72 72 + 73 73 + def create_lexicon(lexicon: LLexicon): 74 74 + lex_nsid = str(lexicon.id).replace("-", "_") 75 75 + 76 76 + body: list[ast.stmt] = [ 77 77 + ast.ImportFrom( 78 78 + "src.lexicon.model", 79 79 + [ast.alias("BaseFragment"), ast.alias("BaseExport")], 80 80 + level=0, 81 81 + lineno=0, 82 82 + ), 83 83 + ] 84 84 + names_for_main = [] 85 85 + for key, fragment in sorted(lexicon.defs.items(), key=lambda x: x[0] == "main"): 86 86 + if key == "main": 87 87 + continue 88 88 + names_for_main.append(key) 89 89 + body.append( 90 90 + ast.ClassDef( 91 91 + bases=[ast.Name("BaseFragment")], 92 92 + name="_meta_" + key, 93 93 + body=[ 94 94 + ast.Assign( 95 95 + targets=[ast.Name("__lexicon__")], 96 96 + value=ast.Constant(lex_nsid), 97 97 + lineno=0, 98 98 + ), 99 99 + ast.Assign( 100 100 + targets=[ast.Name("__fragment__")], 101 101 + value=ast.Constant(key), 102 102 + lineno=0, 103 103 + ), 104 104 + ], 105 105 + ) 106 106 + ) 107 107 + body.append( 108 108 + ast.ClassDef( 109 109 + "_frag_" + key, 110 110 + bases=[ast.Name(TYPE_MAP[fragment.__lexicon_type__])], 111 111 + keywords=[ast.keyword("metaclass", ast.Name("_meta_" + key))], 112 112 + body=[ 113 113 + ast.Assign( 114 114 + [ast.Name("__qualname__")], ast.Constant(key), lineno=0 115 115 + ), 116 116 + *content_for_type(fragment), 117 117 + ], 118 118 + ), 119 119 + ) 120 120 + if "main" in lexicon.defs: 121 121 + fragment = lexicon.defs["main"] 122 122 + body.append( 123 123 + ast.ClassDef( 124 124 + bases=[ast.Name("BaseFragment")], 125 125 + name="_meta_main", 126 126 + body=[ 127 127 + ast.Assign( 128 128 + targets=[ast.Name("__lexicon__")], 129 129 + value=ast.Constant(lex_nsid), 130 130 + lineno=0, 131 131 + ), 132 132 + ast.Assign( 133 133 + targets=[ast.Name("__fragment__")], 134 134 + value=ast.Constant("main"), 135 135 + lineno=0, 136 136 + ), 137 137 + *[ 138 138 + ast.Assign( 139 139 + targets=[ast.Name(name)], 140 140 + value=ast.Name("_frag_" + name), 141 141 + lineno=0, 142 142 + ) 143 143 + for name in names_for_main 144 144 + ], 145 145 + ], 146 146 + ) 147 147 + ) 148 148 + body.append( 149 149 + ast.ClassDef( 150 150 + "_frag_main", 151 151 + bases=[ast.Name(TYPE_MAP[fragment.__lexicon_type__])], 152 152 + keywords=[ast.keyword("metaclass", ast.Name("_meta_main"))], 153 153 + body=[ 154 154 + ast.Assign( 155 155 + [ast.Name("__qualname__")], ast.Constant("main"), lineno=0 156 156 + ), 157 157 + *content_for_type(fragment), 158 158 + ], 159 159 + ), 160 160 + ) 161 161 + body.append( 162 162 + ast.Assign( 163 163 + targets=[ast.Name(lexicon.id.name)], 164 164 + value=ast.Name("_frag_main"), 165 165 + lineno=0, 166 166 + ) 167 167 + ) 168 168 + else: 169 169 + body.append( 170 170 + ast.ClassDef( 171 171 + bases=[ast.Name("BaseExport")], 172 172 + name="_export", 173 173 + body=[ 174 174 + ast.Assign( 175 175 + targets=[ast.Name("__lexicon__")], 176 176 + value=ast.Constant(lex_nsid), 177 177 + lineno=0, 178 178 + ), 179 179 + *[ 180 180 + ast.Assign( 181 181 + targets=[ast.Name(name)], 182 182 + value=ast.Name("_frag_" + name), 183 183 + lineno=0, 184 184 + ) 185 185 + for name in names_for_main 186 186 + ], 187 187 + ], 188 188 + ) 189 189 + ) 190 190 + body.append( 191 191 + ast.Assign( 192 192 + targets=[ast.Name(lexicon.id.name)], 193 193 + value=ast.Call(ast.Name("_export")), 194 194 + lineno=0, 195 195 + ) 196 196 + ) 197 197 + return ast.Module( 198 198 + body=body, 199 199 + ) 200 200 + 201 201 + 202 202 + def convert_lexicon(lexicon: LLexicon): 203 203 + lexicon_authority_store = pathlib.Path(LEXICON_STORE, *lexicon.id.domain_authority) 204 204 + os.makedirs(lexicon_authority_store, exist_ok=True) 205 205 + lexicon_store = pathlib.Path(LEXICON_STORE, *lexicon.id.segments).with_suffix(".py") 206 206 + with lexicon_store.open("w", encoding="utf-8") as file: 207 207 + file.write(ast.unparse(create_lexicon(lexicon))) 208 208 + 209 209 + 210 210 + def regenerate_dunder_inits(changed: NSID): 211 211 + segments = ["", *changed.domain_authority] 212 212 + lng = len(segments) - 1 213 213 + for idx in range(len(segments)): 214 214 + segment_path = pathlib.Path(LEXICON_STORE, *segments[: idx + 1]) 215 215 + files = list(segment_path.glob("*")) 216 216 + file_content = ast.unparse( 217 217 + ast.Module( 218 218 + [ 219 219 + *[ 220 220 + ast.ImportFrom( 221 221 + ("." if idx < lng else "." + file.with_suffix("").name), 222 222 + [ast.alias(file.with_suffix("").name)], 223 223 + level=0, 224 224 + lineno=0, 225 225 + ) 226 226 + for file in files 227 227 + if not file.name.startswith("__") 228 228 + ], 229 229 + ast.Assign( 230 230 + [ast.Name("__all__")], 231 231 + ast.List( 232 232 + [ 233 233 + ast.Constant(file.with_suffix("").name) 234 234 + for file in files 235 235 + if not file.name.startswith("__") 236 236 + ] 237 237 + ), 238 238 + lineno=0, 239 239 + ), 240 240 + ] 241 241 + ) 242 242 + ) 243 243 + with (segment_path / "__init__.py").open("w", encoding="utf-8") as fw: 244 244 + fw.write(file_content)

+645

src/lexicon/lexicon.py

reviewed

··· 1 1 + import abc 2 2 + import re 3 3 + 4 4 + from ..id.nsid import NSID 5 5 + 6 6 + 7 7 + type JSONObject = None | int | bool | str | list[JSONObject] | dict[str, JSONObject] 8 8 + 9 9 + 10 10 + class SchemaObject(abc.ABC): 11 11 + __lexicon_type__: str 12 12 + description: str | None = None 13 13 + 14 14 + def __init__(self, obj: dict[str, JSONObject]): 15 15 + if not isinstance(obj, dict): 16 16 + raise TypeError("Lexicon typedef must be object") 17 17 + type_ = obj.pop("type", None) 18 18 + if not self.__lexicon_type__.startswith("__"): 19 19 + assert ( 20 20 + type_ == self.__lexicon_type__ 21 21 + ), f"Cannot interpret obj of type '{type_} as type '{self.__lexicon_type__}'" 22 22 + 23 23 + description = obj.pop("description", None) 24 24 + assert description is None or isinstance( 25 25 + description, str 26 26 + ), "'description' must be a string" 27 27 + self.description = description 28 28 + 29 29 + self.initialize(obj) 30 30 + assert not obj, f"Unused keys in obj of type '{self.__lexicon_type__}': {", ".join(obj.keys())}" 31 31 + 32 32 + @abc.abstractmethod 33 33 + def initialize(self, obj: dict[str, JSONObject]) -> None: ... 34 34 + 35 35 + 36 36 + class LNull(SchemaObject): 37 37 + __lexicon_type__: str = "null" 38 38 + 39 39 + def initialize(self, obj: dict[str, JSONObject]) -> None: 40 40 + pass 41 41 + 42 42 + 43 43 + class LBoolean(SchemaObject): 44 44 + __lexicon_type__: str = "boolean" 45 45 + 46 46 + const: bool | None = None 47 47 + default: bool | None = None 48 48 + 49 49 + def initialize(self, obj: dict[str, JSONObject]) -> None: 50 50 + # Default is bool or None 51 51 + default = obj.pop("default", None) 52 52 + assert default is None or isinstance( 53 53 + default, bool 54 54 + ), "'default' must be a boolean" 55 55 + self.default = default 56 56 + 57 57 + # Const is bool or None 58 58 + const = obj.pop("const", None) 59 59 + assert const is None or isinstance(const, bool), "'const' must be a boolean" 60 60 + self.const = const 61 61 + 62 62 + 63 63 + class LInteger(SchemaObject): 64 64 + __lexicon_type__: str = "integer" 65 65 + 66 66 + const: int | None = None 67 67 + default: int | None = None 68 68 + minimum: int | None = None 69 69 + maximum: int | None = None 70 70 + enum: list[int] | None = None 71 71 + 72 72 + def initialize(self, obj: dict[str, JSONObject]) -> None: 73 73 + # Minimum is int or None 74 74 + minimum = obj.pop("minimum", None) 75 75 + assert minimum is None or isinstance( 76 76 + minimum, int 77 77 + ), "'minimum' must be an integer" 78 78 + self.minimum = minimum 79 79 + 80 80 + # Maximum is int or None 81 81 + maximum = obj.pop("maximum", None) 82 82 + assert maximum is None or isinstance( 83 83 + maximum, int 84 84 + ), "'maximum' must be an integer" 85 85 + self.maximum = maximum 86 86 + 87 87 + # Enum is list[int] or None 88 88 + enum = obj.pop("enum", None) 89 89 + assert enum is None or ( 90 90 + isinstance(enum, list) and all(isinstance(element, int) for element in enum) 91 91 + ), "'enum' must be a list of integers" 92 92 + self.enum = enum # type: ignore 93 93 + 94 94 + # Default is int or None 95 95 + default = obj.pop("minimum", None) 96 96 + assert default is None or isinstance( 97 97 + default, int 98 98 + ), "'default' must be an integer" 99 99 + self.default = default 100 100 + 101 101 + # Const is int or None 102 102 + const = obj.pop("const", None) 103 103 + assert const is None or isinstance(const, int), "'const' must be an integer" 104 104 + self.const = const 105 105 + 106 106 + 107 107 + STRING_FORMATS: set[str] = { 108 108 + "at-identifier", 109 109 + "at-uri", 110 110 + "cid", 111 111 + "datetime", 112 112 + "did", 113 113 + "handle", 114 114 + "nsid", 115 115 + "tid", 116 116 + "record-key", 117 117 + "uri", 118 118 + "language", 119 119 + } 120 120 + 121 121 + 122 122 + class LString(SchemaObject): 123 123 + __lexicon_type__: str = "string" 124 124 + 125 125 + const: str | None = None 126 126 + default: str | None = None 127 127 + format: str | None = None 128 128 + min_length: int | None = None 129 129 + max_length: int | None = None 130 130 + min_graphemes: int | None = None 131 131 + max_graphemes: int | None = None 132 132 + enum: list[str] | None = None 133 133 + known_values: list[str] | None = None 134 134 + 135 135 + def initialize(self, obj: dict[str, JSONObject]) -> None: 136 136 + # Format is str or None 137 137 + format_ = obj.pop("format", None) 138 138 + assert ( 139 139 + format_ is None or format_ in STRING_FORMATS 140 140 + ), f"'format' must be one of: {", ".join(STRING_FORMATS)}" 141 141 + self.format = format_ 142 142 + 143 143 + # MinLength is int or None 144 144 + min_length = obj.pop("minLength", None) 145 145 + assert min_length is None or isinstance( 146 146 + min_length, int 147 147 + ), "'minLength' must be an integer" 148 148 + self.min_length = min_length 149 149 + 150 150 + # MaxLength is int or None 151 151 + max_length = obj.pop("maxLength", None) 152 152 + assert max_length is None or isinstance( 153 153 + max_length, int 154 154 + ), "'maxLength' must be an integer" 155 155 + self.max_length = max_length 156 156 + 157 157 + # MinGraphemes is int or None 158 158 + min_graphemes = obj.pop("minGraphemes", None) 159 159 + assert min_graphemes is None or isinstance( 160 160 + min_graphemes, int 161 161 + ), "'minGraphemes' must be an integer" 162 162 + self.min_graphemes = min_graphemes 163 163 + 164 164 + # MaxGraphemes is int or None 165 165 + max_graphemes = obj.pop("maxGraphemes", None) 166 166 + assert max_graphemes is None or isinstance( 167 167 + max_graphemes, int 168 168 + ), "'maxGraphemes' must be an integer" 169 169 + self.max_graphemes = max_graphemes 170 170 + 171 171 + # KnownValues is list[str] or None 172 172 + known_values = obj.pop("knownValues", None) 173 173 + assert known_values is None or ( 174 174 + isinstance(known_values, list) 175 175 + and all(isinstance(element, str) for element in known_values) 176 176 + ), "'enum' must be a list of integers" 177 177 + self.known_values = known_values # type: ignore 178 178 + 179 179 + # Enum is list[str] or None 180 180 + enum = obj.pop("enum", None) 181 181 + assert enum is None or ( 182 182 + isinstance(enum, list) and all(isinstance(element, str) for element in enum) 183 183 + ), "'enum' must be a list of integers" 184 184 + self.enum = enum # type: ignore 185 185 + 186 186 + # Default is str or None 187 187 + default = obj.pop("minimum", None) 188 188 + assert default is None or isinstance(default, str), "'default' must be a string" 189 189 + self.default = default 190 190 + 191 191 + # Const is str or None 192 192 + const = obj.pop("const", None) 193 193 + assert const is None or isinstance(const, str), "'const' must be a string" 194 194 + self.const = const 195 195 + 196 196 + 197 197 + class LBytes(SchemaObject): 198 198 + __lexicon_type__: str = "bytes" 199 199 + 200 200 + min_length: int | None = None 201 201 + max_length: int | None = None 202 202 + 203 203 + def initialize(self, obj: dict[str, JSONObject]) -> None: 204 204 + # MinLength is int or None 205 205 + min_length = obj.pop("minLength", None) 206 206 + assert min_length is None or isinstance( 207 207 + min_length, int 208 208 + ), "'minLength' must be an integer" 209 209 + self.min_length = min_length 210 210 + 211 211 + # MaxLength is int or None 212 212 + max_length = obj.pop("maxLength", None) 213 213 + assert max_length is None or isinstance( 214 214 + max_length, int 215 215 + ), "'maxLength' must be an integer" 216 216 + self.max_length = max_length 217 217 + 218 218 + 219 219 + class LCIDLink(SchemaObject): 220 220 + __lexicon_type__: str = "cid-link" 221 221 + 222 222 + def initialize(self, obj: dict[str, JSONObject]) -> None: ... 223 223 + 224 224 + 225 225 + class LArray(SchemaObject): 226 226 + __lexicon_type__: str = "array" 227 227 + 228 228 + items: SchemaObject 229 229 + min_length: int | None = None 230 230 + max_length: int | None = None 231 231 + 232 232 + def initialize(self, obj: dict[str, JSONObject]) -> None: 233 233 + # MinLength is int or None 234 234 + min_length = obj.pop("minLength", None) 235 235 + assert min_length is None or isinstance( 236 236 + min_length, int 237 237 + ), "'minLength' must be an integer" 238 238 + self.min_length = min_length 239 239 + 240 240 + # MaxLength is int or None 241 241 + max_length = obj.pop("maxLength", None) 242 242 + assert max_length is None or isinstance( 243 243 + max_length, int 244 244 + ), "'maxLength' must be an integer" 245 245 + self.max_length = max_length 246 246 + 247 247 + # Items is SchemaObject 248 248 + items = obj.pop("items") 249 249 + assert isinstance(items, dict), "'items' must be a valid schema definition" 250 250 + items_schema = schema_object(items) 251 251 + self.items = items_schema 252 252 + 253 253 + 254 254 + class LObject(SchemaObject): 255 255 + __lexicon_type__: str = "object" 256 256 + 257 257 + properties: dict[str, "SchemaObject"] 258 258 + required: list[str] | None = None 259 259 + nullable: list[str] | None = None 260 260 + 261 261 + def initialize(self, obj: dict[str, JSONObject]) -> None: 262 262 + # Properties is SchemaObject 263 263 + properties = obj.pop("properties", {}) 264 264 + assert isinstance(properties, dict) and all( 265 265 + isinstance(key, str) and isinstance(value, dict) 266 266 + for key, value in properties.items() 267 267 + ), "'properties' must be a record of valid schema definitions" 268 268 + properties_schemas = { 269 269 + key: schema_object(value) # type: ignore 270 270 + for key, value in properties.items() 271 271 + } 272 272 + self.properties = properties_schemas 273 273 + 274 274 + # Required is list[keyof[properties]] 275 275 + required = obj.pop("required", []) 276 276 + assert isinstance(required, list) and all( 277 277 + key in self.properties for key in required 278 278 + ), "'required' must be a list of keys in 'properties'" 279 279 + self.required = required # type: ignore 280 280 + 281 281 + # Nullables is list[keyof[properties]] 282 282 + nullables = obj.pop("nullables", []) 283 283 + assert isinstance(nullables, list) and all( 284 284 + key in self.properties for key in nullables 285 285 + ), "'nullables' must be a list of keys in 'properties'" 286 286 + self.nullables = nullables 287 287 + 288 288 + 289 289 + class LBlob(SchemaObject): 290 290 + __lexicon_type__: str = "blob" 291 291 + 292 292 + accept: list[str] | None 293 293 + max_size: int | None = None 294 294 + 295 295 + def initialize(self, obj: dict[str, JSONObject]) -> None: 296 296 + # Accept is list[str] 297 297 + accept = obj.pop("accept", []) 298 298 + assert isinstance(accept, list) and all( 299 299 + isinstance(value, str) for value in accept 300 300 + ), "'accept' must be a list of strings" 301 301 + self.accept = accept # type: ignore 302 302 + 303 303 + # MaxSize is int 304 304 + max_size = obj.pop("maxSize", []) 305 305 + assert isinstance(max_size, int), "'maxSize' must be an integer" 306 306 + self.nullables = max_size 307 307 + 308 308 + 309 309 + class LParams(SchemaObject): 310 310 + __lexicon_type__: str = "params" 311 311 + 312 312 + required: list[str] | None = None 313 313 + properties: dict[str, "SchemaObject"] 314 314 + 315 315 + def initialize(self, obj: dict[str, JSONObject]) -> None: 316 316 + # Properties is SchemaObject 317 317 + properties = obj.pop("properties", {}) 318 318 + assert isinstance(properties, dict) and all( 319 319 + isinstance(key, str) and isinstance(value, dict) 320 320 + for key, value in properties.items() 321 321 + ), "'properties' must be a record of valid schema definitions" 322 322 + properties_schemas = { 323 323 + key: schema_object(value) # type: ignore 324 324 + for key, value in properties.items() 325 325 + } 326 326 + self.properties = properties_schemas 327 327 + 328 328 + # Required is list[keyof[properties]] 329 329 + required = obj.pop("required", []) 330 330 + assert isinstance(required, list) and all( 331 331 + key in self.properties for key in required 332 332 + ), "'required' must be a list of keys in 'properties'" 333 333 + self.required = required # type: ignore 334 334 + 335 335 + 336 336 + class LToken(SchemaObject): 337 337 + __lexicon_type__: str = "token" 338 338 + 339 339 + def initialize(self, obj: dict[str, JSONObject]) -> None: 340 340 + pass 341 341 + 342 342 + 343 343 + REF_PATTERN = re.compile( 344 344 + 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})?))?(#[a-zA-Z]([a-zA-Z0-9]{0,62})?)?$" 345 345 + ) 346 346 + 347 347 + 348 348 + class LRef(SchemaObject): 349 349 + __lexicon_type__: str = "ref" 350 350 + 351 351 + ref: str 352 352 + 353 353 + def initialize(self, obj: dict[str, JSONObject]): 354 354 + # Ref is NSID 355 355 + ref = obj.pop("ref") 356 356 + assert ( 357 357 + isinstance(ref, str) and len(ref) and REF_PATTERN.match(ref) 358 358 + ), "'ref' must be a valid nsid ref" 359 359 + self.ref = ref 360 360 + 361 361 + 362 362 + class LUnion(SchemaObject): 363 363 + __lexicon_type__ = "union" 364 364 + 365 365 + refs: list[str] 366 366 + closed: bool = False 367 367 + 368 368 + def initialize(self, obj: dict[str, JSONObject]): 369 369 + # Refs is list[NSID] 370 370 + refs = obj.pop("refs") 371 371 + assert isinstance(refs, list) and all( 372 372 + isinstance(ref, str) and REF_PATTERN.match(ref) for ref in refs 373 373 + ), "'ref' must be a list of valid nsid refs" 374 374 + self.refs = refs # type: ignore 375 375 + 376 376 + # Closed is bool 377 377 + closed = obj.pop("closed", False) 378 378 + assert isinstance(closed, bool), "'closed' must be a boolean" 379 379 + self.closed = closed 380 380 + 381 381 + 382 382 + class LUnkown(SchemaObject): 383 383 + __lexicon_type__ = "unkown" 384 384 + 385 385 + def initialize(self, obj: dict[str, JSONObject]): 386 386 + pass 387 387 + 388 388 + 389 389 + RECORD_KEY_TYPES = { 390 390 + "nsid", 391 391 + "any", 392 392 + } 393 393 + 394 394 + 395 395 + class LRecord(SchemaObject): 396 396 + __lexicon_type__ = "unkown" 397 397 + 398 398 + key: str 399 399 + record: LObject 400 400 + 401 401 + def initialize(self, obj: dict[str, JSONObject]): 402 402 + # key is Record Key Type 403 403 + key = obj.pop("key") 404 404 + assert ( 405 405 + isinstance(key, str) 406 406 + and ( 407 407 + key in RECORD_KEY_TYPES or key.startswith("literal:") 408 408 + ) # TODO: Improve 'literal' filter 409 409 + ), "'key' must be a valid record key type" 410 410 + self.key = key 411 411 + 412 412 + # Record is LObject 413 413 + record = obj.pop("record") 414 414 + assert ( 415 415 + isinstance(record, dict) and record.get("type") == "object" 416 416 + ), "'record' must be an object" 417 417 + self.record = LObject(record) 418 418 + 419 419 + 420 420 + class LQueryOutput(SchemaObject): 421 421 + __lexicon_type__ = "__query_output" 422 422 + 423 423 + encoding: str 424 424 + schema: SchemaObject 425 425 + 426 426 + def initialize(self, obj: dict[str, JSONObject]): 427 427 + # Encoding is str 428 428 + encoding = obj.pop("encoding") 429 429 + assert isinstance(encoding, str), "'encoding' must be a string" 430 430 + self.encoding = encoding 431 431 + 432 432 + # Schema is LObject 433 433 + schema = obj.pop("schema") 434 434 + assert isinstance(schema, dict) and schema.get("type") in { 435 435 + "object", 436 436 + "ref", 437 437 + "union", 438 438 + }, "'record' must be an object, a ref, or a union of refs" 439 439 + self.schema = schema_object(schema) 440 440 + 441 441 + 442 442 + class LQueryError(SchemaObject): 443 443 + __lexicon_type__ = "__query_error" 444 444 + 445 445 + name: str 446 446 + 447 447 + def initialize(self, obj: dict[str, JSONObject]): 448 448 + # Name is str 449 449 + name = obj.pop("name") 450 450 + assert isinstance(name, str), "'name' must be a string" 451 451 + self.name = name 452 452 + 453 453 + 454 454 + class LQuery(SchemaObject): 455 455 + __lexicon_type__ = "query" 456 456 + 457 457 + parameters: LParams | None = None 458 458 + output: LQueryOutput | None = None 459 459 + errors: list[LQueryError] | None = None 460 460 + 461 461 + def initialize(self, obj: dict[str, JSONObject]): 462 462 + # parameters is LParams 463 463 + parameters = obj.pop("parameters", None) 464 464 + if parameters is not None: 465 465 + assert ( 466 466 + isinstance(parameters, dict) and parameters.get("type") == "params" 467 467 + ), "'parameters' must be a params object" 468 468 + self.parameters = LParams(parameters) 469 469 + else: 470 470 + self.parameters = None 471 471 + 472 472 + # output is LQueryOutput 473 473 + output = obj.pop("output", None) 474 474 + if output is not None: 475 475 + assert isinstance(output, dict), "'output' must be an object" 476 476 + self.output = LQueryOutput(output) 477 477 + else: 478 478 + self.output = None 479 479 + 480 480 + # errors is list[LQueryError] 481 481 + errors = obj.pop("errors", None) 482 482 + if errors is not None: 483 483 + assert isinstance(errors, list) and all( 484 484 + isinstance(error, dict) for error in errors 485 485 + ), "'errors' must be a list of objects" 486 486 + self.errors = [ 487 487 + LQueryError(error) # type:ignore 488 488 + for error in errors 489 489 + ] 490 490 + else: 491 491 + self.errors = None 492 492 + 493 493 + 494 494 + class LProcedure(LQuery): 495 495 + __lexicon_type__ = "procedure" 496 496 + 497 497 + input: LQueryOutput | None = None 498 498 + 499 499 + def initialize(self, obj: dict[str, JSONObject]): 500 500 + super().initialize(obj) 501 501 + 502 502 + # output is LQueryOutput 503 503 + input_ = obj.pop("input", None) 504 504 + if input_ is not None: 505 505 + assert isinstance(input_, dict), "'input' must be an object" 506 506 + self.input = LQueryOutput(input_) 507 507 + else: 508 508 + self.input = None 509 509 + 510 510 + 511 511 + class LSubscriptionMessage(SchemaObject): 512 512 + __lexicon_type__ = "__subscription_message" 513 513 + 514 514 + schema: SchemaObject | None = None 515 515 + 516 516 + def initialize(self, obj: dict[str, JSONObject]): 517 517 + # Schema is LObject 518 518 + schema = obj.pop("schema") 519 519 + assert ( 520 520 + isinstance(schema, dict) and schema.get("type") == "union" 521 521 + ), "'record' must be a union of refs" 522 522 + self.schema = schema_object(schema) 523 523 + 524 524 + 525 525 + class LSubscription(SchemaObject): 526 526 + __lexicon_type__ = "subscription" 527 527 + 528 528 + parameters: LParams | None = None 529 529 + message: LSubscriptionMessage | None = None 530 530 + errors: list[LQueryError] | None = None 531 531 + 532 532 + def initialize(self, obj: dict[str, JSONObject]): 533 533 + # parameters is LParams 534 534 + parameters = obj.pop("parameters", None) 535 535 + if parameters is not None: 536 536 + assert ( 537 537 + isinstance(parameters, dict) and parameters.get("type") == "params" 538 538 + ), "'parameters' must be a params object" 539 539 + self.parameters = LParams(parameters) 540 540 + else: 541 541 + self.parameters = None 542 542 + 543 543 + # message is LSubscriptionMessage 544 544 + message = obj.pop("message", None) 545 545 + if message is not None: 546 546 + assert isinstance(message, dict), "'output' must be an object" 547 547 + self.message = LSubscriptionMessage(message) 548 548 + else: 549 549 + self.message = None 550 550 + 551 551 + # errors is list[LQueryError] 552 552 + errors = obj.pop("errors", None) 553 553 + if errors is not None: 554 554 + assert isinstance(errors, list) and all( 555 555 + isinstance(error, dict) for error in errors 556 556 + ), "'errors' must be a list of objects" 557 557 + self.errors = [ 558 558 + LQueryError(error) # type:ignore 559 559 + for error in errors 560 560 + ] 561 561 + else: 562 562 + self.errors = None 563 563 + 564 564 + 565 565 + NSID_PATTERN = re.compile( 566 566 + 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})?)$" 567 567 + ) 568 568 + NSID_FRAGMENT_PATTERN = re.compile(r"^[a-zA-Z]([a-zA-Z0-9]{0,62})?$") 569 569 + 570 570 + 571 571 + class LLexicon(SchemaObject): 572 572 + __lexicon_type__: str = "__lexicon" 573 573 + 574 574 + lexicon: int = 1 575 575 + id: NSID 576 576 + defs: dict[str, SchemaObject] 577 577 + 578 578 + def initialize(self, obj: dict[str, JSONObject]) -> None: 579 579 + # Lexicon is Literal[1] 580 580 + lexicon = obj.pop("lexicon") 581 581 + assert lexicon == 1, "'lexicon' must be 1" 582 582 + self.lexicon = lexicon # type: ignore 583 583 + 584 584 + # Id is NSID 585 585 + id_ = obj.pop("id") 586 586 + assert isinstance(id_, str) and NSID_PATTERN.match( 587 587 + id_ 588 588 + ), "'id' must be a valid nsid" 589 589 + self.id = NSID(id_) 590 590 + 591 591 + # Defs is dict[Fragment, SchemaObject] 592 592 + defs = obj.pop("defs") 593 593 + assert isinstance( 594 594 + defs, dict 595 595 + ), "'defs' must be a record of valid schema definitions" 596 596 + assert all( 597 597 + isinstance(key, str) and NSID_FRAGMENT_PATTERN.match(key) 598 598 + for key in defs.keys() 599 599 + ), "'defs's keys must be valid nsid fragments" 600 600 + assert all( 601 601 + isinstance(value, dict) for value in defs.values() 602 602 + ), "'defs' must be a record of valid schema definitions" 603 603 + assert all( 604 604 + value.get("type") not in {"record", "query", "procedure", "subscription"} 605 605 + or key == "main" 606 606 + for key, value in defs.items() 607 607 + ), "primary data types must be in the 'main' fragment" 608 608 + defs_obj = { 609 609 + key: schema_object(value) # type: ignore 610 610 + for key, value in defs.items() 611 611 + } 612 612 + self.defs = defs_obj 613 613 + 614 614 + 615 615 + TYPE_MAP: dict[str, type[SchemaObject]] = { 616 616 + "null": LNull, 617 617 + "boolean": LBoolean, 618 618 + "integer": LInteger, 619 619 + "string": LString, 620 620 + "bytes": LBytes, 621 621 + "cid-link": LCIDLink, 622 622 + "blob": LBlob, 623 623 + "array": LArray, 624 624 + "object": LObject, 625 625 + "params": LParams, 626 626 + "token": LToken, 627 627 + "ref": LRef, 628 628 + "union": LUnion, 629 629 + "unknown": LUnkown, 630 630 + "record": LRecord, 631 631 + "query": LQuery, 632 632 + "procedure": LProcedure, 633 633 + "subscription": LSubscription, 634 634 + } 635 635 + 636 636 + 637 637 + def schema_object(obj: dict[str, JSONObject]): 638 638 + type_ = obj.get("type") 639 639 + if type_ not in TYPE_MAP: 640 640 + raise TypeError(f"Cannot find lexcion type '{type_}'") 641 641 + return TYPE_MAP[type_](obj) 642 642 + 643 643 + 644 644 + def lexicon(obj: dict[str, JSONObject]): 645 645 + return LLexicon(obj)

+18

src/lexicon/model.py

reviewed

··· 1 1 + class BaseFragment(type): 2 2 + __fragment__: str 3 3 + __lexicon__: str 4 4 + 5 5 + def __repr__(self): 6 6 + if self.__fragment__ == "main": 7 7 + return self.__lexicon__ 8 8 + return f"{self.__lexicon__}#{self.__fragment__}" 9 9 + 10 10 + 11 11 + class BaseExport: 12 12 + __lexicon__: str 13 13 + 14 14 + # def __init__(self): 15 15 + # raise TypeError("Cannot instantiate export") 16 16 + 17 17 + def __repr__(self): 18 18 + return f"<fragment collection of lexicon '{self.__lexicon__}'>"

+46

test.py

reviewed

··· 1 1 + # import src.id as id 2 2 + 3 3 + # a = id.TID("2zzzzzzzzzzzz") 4 4 + # print(repr(a), a, a.timestamp, a.clock_identifier) 5 5 + 6 6 + # print(repr(id.DID("did:web:::::jojojux.de"))) 7 7 + 8 8 + # com_bsky = id.NSIDGlob("com.bsky.*") 9 9 + # com_bsky_feed = id.NSID("com.bsky.feed") 10 10 + # print(com_bsky.matches(com_bsky_feed)) 11 11 + 12 12 + 13 13 + import base64 14 14 + from src.lexicon import lexicon 15 15 + from src.lexicon.lexicon import LQuery 16 16 + 17 17 + 18 18 + lex = lexicon( 19 19 + { 20 20 + "lexicon": 1, 21 21 + "id": "com.example.getProfile", 22 22 + "defs": { 23 23 + "main": { 24 24 + "type": "query", 25 25 + "parameters": { 26 26 + "type": "params", 27 27 + "required": ["user"], 28 28 + "properties": {"user": {"type": "string"}}, 29 29 + }, 30 30 + "output": { 31 31 + "encoding": "application/json", 32 32 + "schema": { 33 33 + "type": "object", 34 34 + "required": ["did", "name"], 35 35 + "properties": { 36 36 + "did": {"type": "string"}, 37 37 + "name": {"type": "string"}, 38 38 + "displayName": {"type": "string", "maxLength": 64}, 39 39 + "description": {"type": "string", "maxLength": 256}, 40 40 + }, 41 41 + }, 42 42 + }, 43 43 + } 44 44 + }, 45 45 + } 46 46 + )

+29

testt.py

reviewed

··· 1 1 + from src.id.nsid import NSID 2 2 + import src.lexicon.codegen 3 3 + from src.lexicon import lexicon 4 4 + 5 5 + src.lexicon.codegen.convert_lexicon( 6 6 + lexicon( 7 7 + { 8 8 + "lexicon": 1, 9 9 + "id": "com.example.getProfile", 10 10 + "defs": { 11 11 + "main": { 12 12 + "type": "object", 13 13 + "properties": { 14 14 + "test": {"type": "string"}, 15 15 + "test2": {"type": "array", "items": {"type": "boolean"}}, 16 16 + }, 17 17 + "nullables": ["test2"], 18 18 + }, 19 19 + "other": {"type": "object", "properties": {"int": {"type": "integer"}}}, 20 20 + }, 21 21 + } 22 22 + ) 23 23 + ) 24 24 + src.lexicon.codegen.regenerate_dunder_inits(NSID("com.example.getProfile")) 25 25 + 26 26 + import lex 27 27 + 28 28 + print(lex.com.example.getProfile()) 29 29 + print(lex.com.example.getProfile.other)