Skip to content

Schemas

This page documents the schema classes used in Eunomia Core for data validation and serialization.

Attribute Schemas

eunomia_core.schemas.Attribute

Bases: BaseModel

Source code in pkgs/core/src/eunomia_core/schemas.py 
 9
10
11
class Attribute(BaseModel):
    key: str = Field(..., description="Attribute key")
    value: str = Field(..., description="Attribute value")

eunomia_core.schemas.AttributeInDb

Bases: Attribute

Source code in pkgs/core/src/eunomia_core/schemas.py 
14
15
16
17
18
19
20
21
22
class AttributeInDb(Attribute):
    updated_at: datetime = Field(
        description="Time when this attribute was last updated"
    )
    registered_at: datetime = Field(
        description="Time when this attribute was first registered"
    )

    model_config = ConfigDict(from_attributes=True)

Entity Schemas

eunomia_core.schemas.EntityBase

Bases: BaseModel

Source code in pkgs/core/src/eunomia_core/schemas.py 
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
class EntityBase(BaseModel):
    uri: str = Field(..., description="Unique identifier for the entity")
    attributes: list[Attribute] = Field(..., description="Entity attributes")
    type: EntityType = Field(..., description="Type of entity")

    @field_validator("attributes", mode="before")
    @classmethod
    def from_dict(cls, v: list[Attribute] | dict) -> list[Attribute]:
        if isinstance(v, dict):
            return [Attribute(key=k, value=str(val)) for k, val in v.items()]
        return v

    @field_validator("attributes", mode="after")
    @classmethod
    def unique_attribute_keys(cls, v: list[Attribute]) -> list[Attribute]:
        keys = {}
        for i, attr in enumerate(v):
            if attr.key in keys:
                raise ValueError(
                    f"Duplicate attribute key: '{attr.key}' at positions {keys[attr.key]} and {i}"
                )
            keys[attr.key] = i
        return v

eunomia_core.schemas.EntityCreate

Bases: EntityBase

Source code in pkgs/core/src/eunomia_core/schemas.py 
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
class EntityCreate(EntityBase):
    uri: Optional[str] = Field(
        default_factory=lambda: generate_uri(),
        description="Unique identifier for the entity, generated if not provided",
    )

    @field_validator("attributes", mode="before")
    @classmethod
    def at_least_one_attribute(cls, v: list[Attribute]) -> list[Attribute]:
        if not v:
            raise ValueError("At least one attribute must be provided")
        return v

    @field_validator("uri", mode="after")
    @classmethod
    def enforce_uri(cls, v: str | None) -> str:
        if v is None:
            return generate_uri()
        return v

eunomia_core.schemas.EntityUpdate

Bases: EntityBase

Source code in pkgs/core/src/eunomia_core/schemas.py 
71
72
73
74
75
76
77
78
79
class EntityUpdate(EntityBase):
    type: EntityType = EntityType.any  # type is not required for the attributes update

    @field_validator("attributes", mode="before")
    @classmethod
    def at_least_one_attribute(cls, v: list[Attribute]) -> list[Attribute]:
        if not v:
            raise ValueError("At least one attribute must be provided")
        return v

eunomia_core.schemas.EntityAccess

Bases: EntityBase

Source code in pkgs/core/src/eunomia_core/schemas.py 
82
83
84
85
86
87
88
89
90
91
92
93
94
class EntityAccess(EntityBase):
    uri: Optional[str] = Field(
        default=None, description="Unique identifier for the entity"
    )
    attributes: Optional[list[Attribute]] = Field(
        default_factory=list, description="Entity attributes"
    )

    @model_validator(mode="after")
    def either_uri_or_attributes(self) -> "EntityAccess":
        if not self.uri and not self.attributes:
            raise ValueError("Either 'uri' or non-empty 'attributes' must be provided")
        return self

eunomia_core.schemas.EntityInDb

Bases: EntityBase

Source code in pkgs/core/src/eunomia_core/schemas.py 
 97
 98
 99
100
101
class EntityInDb(EntityBase):
    attributes: list[AttributeInDb] = Field(..., description="Entity attributes")
    registered_at: datetime = Field(description="Time when this entity was registered")

    model_config = ConfigDict(from_attributes=True)

Access Control Schemas

eunomia_core.schemas.ResourceAccess

Bases: EntityAccess

Source code in pkgs/core/src/eunomia_core/schemas.py 
104
105
106
107
108
109
110
111
class ResourceAccess(EntityAccess):
    type: Literal[EntityType.resource, EntityType.any] = EntityType.resource

    # The type is always overridden to "resource", although it can accept "any" as input.
    @field_validator("type", mode="after")
    @classmethod
    def override_type(cls, v):
        return EntityType.resource

eunomia_core.schemas.PrincipalAccess

Bases: EntityAccess

Source code in pkgs/core/src/eunomia_core/schemas.py 
114
115
116
117
118
119
120
121
class PrincipalAccess(EntityAccess):
    type: Literal[EntityType.principal, EntityType.any] = EntityType.principal

    # The type is always overridden to "principal", although it can accept "any" as input.
    @field_validator("type", mode="after")
    @classmethod
    def override_type(cls, v):
        return EntityType.principal

eunomia_core.schemas.AccessRequest

Bases: BaseModel

Source code in pkgs/core/src/eunomia_core/schemas.py 
124
125
126
127
128
129
130
131
132
133
class AccessRequest(BaseModel):
    principal: PrincipalAccess = Field(
        ..., description="The principal requesting access"
    )
    resource: ResourceAccess = Field(..., description="The resource being accessed")
    action: Literal["allow"] = Field(
        default="allow",
        description="Action to be performed on the resource. "
        "Currently only 'allow' is supported.",
    )

eunomia_core.schemas.Policy

Bases: BaseModel

Source code in pkgs/core/src/eunomia_core/schemas.py 
136
137
class Policy(BaseModel):
    rules: list[AccessRequest] = Field(..., description="List of access rules")