type-bridge-schema-codegen 2.0.1

Deterministic projection-only schema emitters for type-bridge
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

import json
from datetime import UTC, date, datetime, timedelta
from decimal import Decimal

from generated_v2 import (
    PLAYING_FACTS,
    PROJECTION_FINGERPRINT_JSON,
    RUNTIME_PROJECTION_JSON,
    SEMANTIC_SCHEMA_FINGERPRINT_JSON,
    Aliases,
    Container,
    Employment,
    Event,
    EventRef,
    FieldToken,
    Identifier,
    Nickname,
    Person,
    PersonRef,
    RoleToken,
    Score,
    ValBool,
    ValConstrained,
    ValDate,
    ValDatetime,
    ValDatetimeTz,
    ValDecimal,
    ValDouble,
    ValDuration,
)


def make_person(identifier: str, **values: object) -> Person:
    return Person(
        identifier=Identifier(identifier),
        score=Score(3),
        val_bool=ValBool(True),
        val_constrained=ValConstrained(20),
        val_date=ValDate(date(2026, 7, 29)),
        val_datetime=ValDatetime(datetime(2026, 7, 29)),
        val_datetime_tz=ValDatetimeTz(datetime(2026, 7, 29, tzinfo=UTC)),
        val_decimal=ValDecimal(Decimal("3.5")),
        val_double=ValDouble(3.5),
        val_duration=ValDuration(timedelta(seconds=3)),
        **values,
    )


descriptor = Employment.__dict__["employee"]
assert descriptor.name == "employee"
assert isinstance(Employment.employee, RoleToken)
assert isinstance(Person.identifier, FieldToken)
assert Person.identifier.fact["key"] is True
assert Person.aliases.fact["unique"] is True

person = make_person(
    "person-1",
    nickname=Nickname("alice"),
    aliases=[Aliases("a"), Aliases("b")],
)
assert isinstance(person.identifier, Identifier)
assert isinstance(person.nickname, Nickname)
assert len(person.aliases) == 2
assert all(isinstance(alias, Aliases) for alias in person.aliases)
event = Event(subject=person)
assert event.subject is person
employment = Employment(employee=person)
assert employment.employee is person

container = Container(item=[EventRef("event-iid")])
assert len(container.item) == 1

try:
    Container(
        item=[
            EventRef("event-1"),
            EventRef("event-2"),
            EventRef("event-3"),
        ]
    )
except ValueError:
    pass
else:
    raise AssertionError("role maximum cardinality was not enforced")

try:
    Employment(employee=event)
except TypeError:
    pass
else:
    raise AssertionError("wrong role-player type was not rejected")

try:
    Employment(
        employee=make_person("person-1"),
        member=make_person("person-2"),
    )
except TypeError:
    pass
else:
    raise AssertionError("specialized-away keyword was accepted")

reference = PersonRef("person-iid", identifier=Identifier("person-1"))
assert reference.iid == "person-iid"
assert reference.__model_form__ == "reference"
assert person.iid is None
assert person.identifier.value == "person-1"

try:
    make_person("person-1", aliases="not-a-sequence-value")
except TypeError:
    pass
else:
    raise AssertionError("string was accepted as a multi-cardinality owns value")

assert len(PLAYING_FACTS) == 8
membership_facts = [
    fact
    for fact in PLAYING_FACTS.values()
    if fact["role"]["declaring_relation"] == "membership" and fact["role"]["label"] == "member"
]
assert len(membership_facts) == 2
membership_by_player = {fact["id"]["player"]["label"]: fact for fact in membership_facts}
assert set(membership_by_player) == {"person", "robot"}
assert membership_by_player["person"]["multiplicity"]["cardinality"]["max"] == "2"
assert membership_by_player["robot"]["multiplicity"]["cardinality"]["max"] == "1"
assert "membership player" in json.dumps(membership_by_player["person"])
assert "robot membership player" in json.dumps(membership_by_player["robot"])

event_subject_facts = [
    fact
    for fact in PLAYING_FACTS.values()
    if fact["role"]["declaring_relation"] == "event" and fact["role"]["label"] == "subject"
]
assert len(event_subject_facts) == 1
event_subject_fact = event_subject_facts[0]
assert event_subject_fact["id"]["player"]["label"] == "person"
assert event_subject_fact["multiplicity"]["cardinality"]["max"] == "1"
assert "event subject player" in json.dumps(event_subject_fact)
assert event_subject_fact["id"] != membership_by_player["person"]["id"]

projection = json.loads(RUNTIME_PROJECTION_JSON)
assert json.loads(SEMANTIC_SCHEMA_FINGERPRINT_JSON) == projection["semantic_fingerprint"]
assert json.loads(PROJECTION_FINGERPRINT_JSON) == projection["projection_fingerprint"]