Pydantic Core

Public package exports for dartfx.rdf.pydantic.

class dartfx.rdf.pydantic.CompositeUriGenerator(*generators: RdfUriGenerator)[source]

Bases: object

URI generator that tries multiple generators in priority order.

Returns the result of the first generator that produces a URIRef. Falls back to a BNode only if every generator in the chain returns a BNode.

This is useful for expressing fallback strategies:

“Use the doi field if set, otherwise hash the title, otherwise BNode.”
“Use a custom generator for known types, fall back to default otherwise.”

Parameters:: *generators (RdfUriGenerator) – Generators to try in order. Must accept the standard (model, *, base_uri=None) -> URIRef | BNode signature.

Examples

from dartfx.rdf.pydantic import DefaultUriGenerator
from dartfx.rdf.pydantic._uri_generators import (
    CompositeUriGenerator,
    HashUriGenerator,
)

gen = CompositeUriGenerator(
    DefaultUriGenerator(auto_uuid=False),          # use id if set, else BNode
    HashUriGenerator("https://example.org/h/", ["title"]),  # hash fallback
)

class Article(RdfBaseModel):
    rdf_uri_generator = gen
    title: str | None = None

class dartfx.rdf.pydantic.DefaultUriGenerator(*, auto_uuid: bool = True)[source]

Bases: object

Default RDF subject URI generator.

Encapsulates the standard URI resolution strategy used by RdfBaseModel out of the box:

If the model has an rdf_id_field and that field is non-None, build a URI from the value:
- If the value already looks like an absolute URI, use it directly.
- If the model’s class defines rdf_namespace, prepend it.
- If a base_uri was provided to the serialiser, prepend it.
- Otherwise use the raw string as a URI.
If no identifier was found and auto_uuid is True, mint a new UUID-based URI (using the namespace if available, otherwise urn:uuid:<uuid4>).
If auto_uuid is False, return a rdflib.BNode.

Parameters:

auto_uuid (bool) – Whether to generate a UUID URI when no explicit identifier is present. Default is True.
default (Why auto_uuid=True is the)
--------------------------------------
perspective (From a strict RDF)
identifier (a resource with no stable global)
(BNode) (*should* be represented as a Blank Node)
graph (single)
commitment. (and carrying no identity)
However
developer (auto_uuid=True is the pragmatic default for)
experience
be (* Graph portability — UUID URIs survive serialisation and can) – referenced across graph boundaries; BNodes cannot.
subject (* Predictable round-trips — from_rdf can reconstruct the) – URI from a UUID URI. BNode identifiers are opaque and may change across parse/serialise cycles.
can (* Merge safety — merging two graphs that both contain BNodes) – silently collapse unrelated resources; UUID URIs are globally unique.
(e.g. (Set auto_uuid=False when you explicitly want anonymous resources)
statements (reified)
inability (inline blank-node structures) and accept the)
externally. (to reference them)

See also

TemplateUriGenerator: URI from a pattern string.
HashUriGenerator: Deterministic URI from field content.
CompositeUriGenerator: Priority-ordered fallback chain.

Examples

Default usage (auto UUID enabled):

person = Person(rdf_uri_generator=DefaultUriGenerator())

Disable UUID fallback (produces BNodes instead):

person = Person(rdf_uri_generator=DefaultUriGenerator(auto_uuid=False))

class dartfx.rdf.pydantic.HashUriGenerator(namespace: str | Namespace, fields: list[str], *, algorithm: str = 'sha256')[source]

Bases: object

URI generator that creates deterministic, content-addressable URIs.

Computes a stable hash of the specified model fields and appends it to a base namespace, producing a reproducible URI regardless of insert order or serialisation time.

This is particularly useful when:

No natural identifier exists in the data.
You want to deduplicate resources across separate serialisations.
You need stable URIs without assigning them explicitly.

Parameters:

namespace (str | Namespace) – The base URI namespace to prepend to the hash digest, e.g. "https://example.org/hash/" or Namespace("https://example.org/hash/"). A trailing / is added automatically if absent.
fields (list[str]) – Names of the model fields to include in the hash, in order. Fields with None values are skipped. If no field has a value, a BNode is returned.
algorithm (str) – Hash algorithm name accepted by hashlib.new(). Default is "sha256". Use "sha1" for shorter (but collision-prone) digests.

Examples

from dartfx.rdf.pydantic import RdfBaseModel
from dartfx.rdf.pydantic._uri_generators import HashUriGenerator

class Publication(RdfBaseModel):
    rdf_uri_generator = HashUriGenerator(
        namespace="https://example.org/pub/",
        fields=["doi", "title"],
    )

    doi: str | None = None
    title: str | None = None

pub = Publication(doi="10.1234/example", title="My Paper")
# Subject: <https://example.org/pub/<sha256-of-doi+title>>

Notes

Field values are concatenated with "|" as a separator before hashing. The base_uri argument from the serialiser is ignored; namespace always takes precedence.

class dartfx.rdf.pydantic.LangString(*, value: str, lang: str | None = None)[source]

Bases: BaseModel

A string with an optional language tag.

This class is used to represent RDF language-tagged literals in Pydantic models. It provides a structured way to handle localized strings while maintaining compatibility with Pydantic validation.

value

The string content of the literal.

Type:: str

lang

The language tag (e.g., “en”, “fr”, “de”). Default is None.

Type:: str | None, optional

lang: str | None

model_config = {}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

value: str

class dartfx.rdf.pydantic.LangStringList(iterable=(), /)[source]

Bases: list[LangString]

A list[LangString] subclass with convenience query methods.

Every mutation (append, extend, +=, insert) automatically skips duplicate (value, lang) pairs and coerces flexible input types (str, dict, LangString) into LangString objects.

Examples

from dartfx.rdf.pydantic import LangString, LangStringList

ls = LangStringList([
    LangString(value="World", lang="en"),
    LangString(value="Mundo", lang="es"),
])

ls += LangString(value="Welt", lang="de")

ls.has_language("en")   # True
ls.count_by_lang("en")  # 1
ls.languages()          # {"en", "es", "de"}
ls.has_synonyms("en")   # False

append(item: LangString) → None[source]: Append item, silently skipping if (value, lang) already exists.

count_by_lang(lang: str | None = None) → int[source]

Return the number of entries for a given language tag.

Parameters:: lang (str | None) – The language tag to count (e.g. "en"). Use None or "" for untagged (plain) strings.
Returns:: Number of entries matching the language.
Return type:: int

extend(items: Any) → None[source]: Extend with items, coercing flexible inputs and deduplicating.

get_by_language(lang: str | None = None) → LangStringList[source]

Return entries matching the given language tag.

Parameters:: lang (str | None) – Language tag to filter by. Use None or "" for untagged entries.
Returns:: A new LangStringList containing only matching entries.
Return type:: LangStringList

has_language(lang: str | None) → bool[source]

Return True if at least one entry has the given language tag.

Parameters:: lang (str | None) – Language tag to check. Use None or "" for untagged entries.

has_synonyms(lang: str | None = None) → bool[source]

Return True if the specified language has more than one entry.

Parameters:: lang (str | None) – Language tag to check. If None or "", checks untagged entries.

has_untagged() → bool[source]: Return True if at least one entry has no language tag (lang=None).

insert(index: int, item: LangString) → None[source]: Insert item at index if (value, lang) is not already present.

languages() → set[str | None][source]: Return the set of distinct language tags (including None for untagged).

untagged() → LangStringList[source]: Return entries whose language tag is None.

class dartfx.rdf.pydantic.PrefixedUriGenerator(prefix: str | Namespace, field: str)[source]

Bases: object

URI generator that concatenates a fixed prefix with a single field value.

A lightweight convenience alternative to TemplateUriGenerator when the URI is simply <prefix><field_value>.

Parameters:

prefix (str | Namespace) – The URI prefix. A trailing / is added automatically if absent.
field (str) – The model field whose value is appended to the prefix. If the field is None or absent, a BNode is returned.

Examples

from dartfx.rdf.pydantic._uri_generators import PrefixedUriGenerator

class Concept(RdfBaseModel):
    rdf_uri_generator = PrefixedUriGenerator(
        prefix="https://vocab.example.org/concepts/",
        field="code",
    )
    code: str | None = None
    label: str | None = None

c = Concept(code="001", label="Agriculture")
# Subject: <https://vocab.example.org/concepts/001>

Notes

The base_uri argument from the serialiser is ignored; prefix always takes precedence.

class dartfx.rdf.pydantic.RdfBaseModel(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: BaseModel

Base class for Pydantic models with RDF serialization capabilities.

This class extends Pydantic’s BaseModel to provide automatic conversion to and from RDF graphs. Models inheriting from RdfBaseModel can be serialized to various RDF formats (Turtle, RDF/XML, JSON-LD, etc.) and deserialized back to Python objects.

Class Attributes

rdf_typestr | URIRef | None: The RDF type (rdf:type) for instances of this class. Typically set to a vocabulary class URI like FOAF.Person or SKOS.Concept. If None, no rdf:type triple is added to the graph. Note: None is valid only for base or abstract models; concrete vocabulary classes should explicitly define an rdf_type.
rdf_namespacestr | Namespace | None: The default namespace for generating subject URIs. Used when an instance has an id but not a full URI. For example, with namespace FOAF and id “john”, the subject becomes <http://xmlns.com/foaf/0.1/john>.
rdf_id_fieldstr | None: The name of the field to use for the RDF subject identifier. Defaults to “id”. Set to None to disable ID field mapping and always use UUIDs.
rdf_prefixesDict[str, str | Namespace]: Namespace prefix bindings for RDF serialization. Used to create readable output with prefixes like foaf:name instead of full URIs. Automatically includes ‘rdf’ and ‘xsd’ prefixes.

Instance Attributes

idAny, optional: If rdf_id_field is “id” (default), this field contains the subject identifier. Can be a short string (combined with namespace) or a full URI.

to_rdf_graph(graph=None, \*, base_uri=None) → Graph[source]: Serialize this model instance into an rdflib Graph.

to_rdf(format="turtle", \*, base_uri=None, \*\*kwargs) → str[source]: Serialize this model instance to an RDF string in the specified format.

from_rdf_graph(graph, subject, \*, base_uri=None) → RdfBaseModel[source]: Class method to deserialize a model from an RDF graph.

from_rdf(data, \*, format="turtle", subject=None, base_uri=None) → RdfBaseModel[source]: Class method to deserialize a model from an RDF string or bytes.

Configuration()

-------------

The model_config allows arbitrary types (URIRef, Literal, etc.) in fields.

Examples

Basic model definition:

from rdflib import Namespace, FOAF
from typing import Annotated, Optional, List

class Person(RdfBaseModel):
    rdf_type: str = str(FOAF.Person)
    rdf_namespace = FOAF
    rdf_prefixes = {"foaf": FOAF}

    name: Annotated[Optional[List[str]], RdfProperty(FOAF.name)] = None
    email: Annotated[Optional[List[str]], RdfProperty(FOAF.mbox)] = None

Creating and serializing:

person = Person(name=["Alice Smith"], email=["alice@example.org"])
turtle_output = person.to_rdf("turtle")
# Output includes proper @prefix declarations and triples

Deserializing:

restored = Person.from_rdf(turtle_output, format="turtle")
assert restored.name == ["Alice Smith"]

With custom ID:

person = Person(id="alice", name=["Alice Smith"])
# Subject URI becomes: <http://xmlns.com/foaf/0.1/alice>

With full URI as ID:

person = Person(id="http://example.org/people/alice", name=["Alice"])
# Subject URI is: <http://example.org/people/alice>

Nested objects:

class Organization(RdfBaseModel):
    rdf_type: str = str(FOAF.Organization)
    name: Annotated[Optional[List[str]], RdfProperty(FOAF.name)] = None

class Person(RdfBaseModel):
    rdf_type: str = str(FOAF.Person)
    name: Annotated[Optional[List[str]], RdfProperty(FOAF.name)] = None
    org: Annotated[Optional[List[Organization]], RdfProperty(FOAF.member)] = None

person = Person(
    name=["Alice"],
    org=[Organization(name=["ACME Corp"])]
)
# Both person and organization are serialized to the graph

Notes

All fields mapped to RDF should use Annotated[…, RdfProperty(…)]
Multi-valued properties use Optional[List[T]] (standard in RDF)
The id field is optional; if not provided, a UUID is generated
Nested RdfBaseModel instances are automatically serialized
Round-trip serialization is lossless for supported types
Custom serializers/parsers can handle complex types

See also

RdfProperty: Metadata for field-to-predicate mapping

Deserialize a model instance from an RDF string or bytes.

This class method parses RDF data and reconstructs a Pydantic model instance. If the subject is not specified, it attempts to infer it from the graph (using rdf:type if available, or assuming a single subject).

Parameters:

data (str | bytes) – The RDF data as a string or bytes. Can be in any format supported by rdflib (Turtle, RDF/XML, JSON-LD, N-Triples, etc.).
format (str, optional) – The RDF format of the input data. Common formats: - “turtle”: Turtle/Trig format (default) - “xml”: RDF/XML format - “json-ld”: JSON-LD format - “nt” or “ntriples”: N-Triples format - “n3”: Notation3 format Default is “turtle”.
subject (URIRef | str | None, optional) – The subject URI to deserialize. If None, the subject is automatically inferred from the graph. Use this when the graph contains multiple resources. Default is None.
base_uri (str | None, optional) – A base URI for generating relative identifiers. Default is None.

Returns:

A new instance of the model class populated with the RDF data.

Return type:

RdfBaseModel

Raises:

ValueError – If subject is None and the subject cannot be inferred, or if multiple subjects are found and none is specified.
ValidationError – If the deserialized data doesn’t pass Pydantic validation.

Examples

From Turtle string:

turtle = '''
@prefix foaf: <http://xmlns.com/foaf/0.1/> .

foaf:alice a foaf:Person ;
    foaf:name "Alice Smith" ;
    foaf:mbox "alice@example.org" .
'''
person = Person.from_rdf(turtle, format="turtle")

With explicit subject:

person = Person.from_rdf(
    turtle_data,
    format="turtle",
    subject="http://example.org/people/alice"
)

From RDF/XML:

person = Person.from_rdf(xml_data, format="xml")

From JSON-LD:

person = Person.from_rdf(jsonld_data, format="json-ld")

Round-trip example:

# Serialize
original = Person(name=["Alice"])
turtle = original.to_rdf("turtle")

# Deserialize
restored = Person.from_rdf(turtle)
assert restored.name == original.name

Notes

Subject inference works best with single-resource graphs
If rdf_type is set, it’s used to find the subject
Format detection is not automatic; always specify the format
Bytes input is decoded as UTF-8

See also

from_rdf_graph: Deserialize from a Graph object
to_rdf: Serialize to an RDF string

classmethod from_rdf_graph(graph: Graph, subject: URIRef | BNode | str, *, base_uri: str | None = None) → T[source]

Deserialize a model instance from an RDF graph.

This class method reconstructs a Pydantic model instance from RDF triples in a Graph. It extracts values for all fields annotated with RdfProperty by querying the graph for triples with the specified subject.

Parameters:

graph (Graph) – The rdflib Graph containing the RDF data.
subject (URIRef | str) – The subject URI of the resource to deserialize. Can be a URIRef or a string that will be converted to a URIRef.
base_uri (str | None, optional) – A base URI for converting the subject back to a relative identifier for the id field. If the subject starts with this base, the remainder is used as the id. Default is None.

Returns:

A new instance of the model class populated with data from the graph.

Return type:

RdfBaseModel

Raises:

ValidationError – If the extracted values don’t pass Pydantic validation.

Examples

Basic deserialization:

graph = Graph()
graph.parse(data=turtle_data, format="turtle")
person = Person.from_rdf_graph(
    graph,
    URIRef("http://example.org/people/alice")
)

With base URI:

person = Person.from_rdf_graph(
    graph,
    URIRef("http://example.org/people/alice"),
    base_uri="http://example.org/people/"
)
# person.id becomes "alice"

Nested objects:

# If the graph contains triples for both Person and Organization,
# nested objects are automatically reconstructed
person = Person.from_rdf_graph(graph, subject_uri)
assert isinstance(person.org[0], Organization)

Notes

Multi-valued properties are always returned as lists
Missing properties result in None values
Nested RdfBaseModel instances are recursively deserialized
Custom parsers in RdfProperty are applied during conversion
Type coercion follows Pydantic’s validation rules

See also

from_rdf: Deserialize from an RDF string
to_rdf_graph: Serialize to a Graph

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_id_field: ClassVar[str | None] = 'id'

rdf_namespace: ClassVar[str | Namespace | None] = None

rdf_prefixes: ClassVar[dict[str, str | Namespace]] = {}

rdf_type: ClassVar[str | URIRef | None] = None

rdf_uri_generator: RdfUriGenerator

to_rdf(format: str = 'turtle', *, base_uri: str | None = None, rdf_uri_generator: RdfUriGenerator | None = None, **kwargs: Any) → str[source]

Serialize the model instance to an RDF string.

This is a convenience method that creates a Graph, serializes the model into it, and then serializes the Graph to the specified format.

Parameters:

format (str, optional) – The RDF serialization format. Supported formats include: - “turtle” (default): Turtle/Trig format - “xml” or “pretty-xml”: RDF/XML format - “json-ld”: JSON-LD format - “nt” or “ntriples”: N-Triples format - “n3”: Notation3 format Default is “turtle”.
base_uri (str | None, optional) – A base URI for generating subject URIs. Default is None.
rdf_uri_generator (RdfUriGenerator | None, optional) – A custom function to generate subject URIs for model instances. The function receives the model instance and should return an rdflib URIRef or BNode. This overrides the model’s own rdf_uri_generator if provided.
**kwargs (Any) – Additional keyword arguments passed to rdflib’s serialize() method.

Returns:

The serialized RDF as a string.

Return type:

str

Examples

Turtle format (default):

person = Person(name=["Alice Smith"])
turtle = person.to_rdf("turtle")
print(turtle)
# @prefix foaf: <http://xmlns.com/foaf/0.1/> .
# foaf:alice a foaf:Person ;
#     foaf:name "Alice Smith" .

RDF/XML format:

xml = person.to_rdf("xml")

JSON-LD format:

jsonld = person.to_rdf("json-ld")

N-Triples format:

ntriples = person.to_rdf("ntriples")

Notes

Turtle format is most human-readable with prefix support
Format names are case-insensitive
The output encoding is UTF-8

See also

to_rdf_graph: Get the Graph object directly
from_rdf: Deserialize from an RDF string

to_rdf_graph(graph: Graph | None = None, *, base_uri: str | None = None, rdf_uri_generator: RdfUriGenerator | None = None) → Graph[source]

Serialize the model instance into an rdflib Graph.

This method converts the Pydantic model instance into RDF triples and adds them to an rdflib Graph. All fields annotated with RdfProperty are converted to RDF predicates and objects. Nested RdfBaseModel instances are recursively serialized.

Parameters:

graph (Graph | None, optional) – An existing rdflib Graph to add triples to. If None, a new Graph is created. Default is None.
base_uri (str | None, optional) – A base URI for generating subject URIs when the model doesn’t have a full URI identifier. Used for relative identifier resolution. Default is None.
rdf_uri_generator (RdfUriGenerator | None, optional) – A custom function to generate subject URIs for model instances. The function receives the model instance and should return an rdflib URIRef or BNode. This overrides the model’s own rdf_uri_generator if provided.

Returns:

The rdflib Graph containing the serialized RDF triples.

Return type:

Graph

Examples

Basic serialization:

person = Person(name=["Alice"])
graph = person.to_rdf_graph()
# graph now contains triples for the person

Adding to existing graph:

graph = Graph()
person1 = Person(name=["Alice"])
person2 = Person(name=["Bob"])
person1.to_rdf_graph(graph)
person2.to_rdf_graph(graph)
# graph contains triples for both persons

With base URI:

person = Person(id="alice", name=["Alice"])
graph = person.to_rdf_graph(base_uri="http://example.org/people/")
# Subject becomes: <http://example.org/people/alice>

Notes

Namespace prefixes from rdf_prefixes are automatically bound
rdf:type triple is added if rdf_type is set
None values and empty lists are skipped
The subject URI is generated from the id field or a UUID

See also

to_rdf: Serialize directly to a string format
from_rdf_graph: Deserialize from a Graph

Bases: object

Metadata descriptor for mapping Pydantic fields to RDF predicates.

This class is used as metadata in type annotations to specify how a Pydantic field should be serialized to and deserialized from RDF. It provides control over the RDF predicate URI, datatype, language tags, and custom serialization.

Parameters:

predicate (str | URIRef) – The RDF predicate URI for this property. Can be a string URI or an rdflib URIRef. Typically uses a namespace property like FOAF.name.
datatype (str | URIRef | None, optional) – The XSD datatype URI for literal values. If None, the datatype is inferred from the Python type. Examples: XSD.string, XSD.integer, XSD.dateTime. Default is None.
language (str | None, optional) – The language tag for string literals (e.g., “en”, “fr”, “de”). Creates language-tagged RDF literals. Cannot be used with datatype. Default is None.
serializer (Callable | None, optional) – A custom function to transform Python values before RDF serialization. Signature: (value: Any) -> Any. The returned value should be compatible with RDF serialization (str, int, URIRef, Literal, etc.). Default is None.
parser (Callable | None, optional) – A custom function to transform RDF nodes back to Python values during deserialization. Signature: (node: URIRef | Literal) -> Any. Default is None.

predicate

The RDF predicate URI.

Type:: str | URIRef

datatype

The XSD datatype URI for literals.

Type:: str | URIRef | None

language

The language tag for string literals.

Type:: str | None

serializer

Custom serialization function.

Type:: Callable | None

parser

Custom parsing function.

Type:: Callable | None

predicate_uri() → URIRef[source]: Convert the predicate to an rdflib URIRef.

datatype_uri() → URIRef | None[source]: Convert the datatype to an rdflib URIRef, or None if not specified.

Examples

Basic property mapping:

from rdflib import FOAF
from typing import Annotated, Optional, List

name: Annotated[Optional[List[str]], RdfProperty(FOAF.name)] = None

With datatype:

from rdflib import XSD

age: Annotated[Optional[int], RdfProperty(
    FOAF.age,
    datatype=XSD.integer
)] = None

With language tag:

description: Annotated[Optional[List[str]], RdfProperty(
    DCTERMS.description,
    language="en"
)] = None

With custom serializer/parser:

from datetime import date

def serialize_date(d: date) -> str:
    return d.isoformat()

def parse_date(node) -> date:
    return date.fromisoformat(str(node))

birth_date: Annotated[Optional[date], RdfProperty(
    SCHEMA.birthDate,
    serializer=serialize_date,
    parser=parse_date
)] = None

Notes

RdfProperty instances are immutable (frozen dataclass)
Use in Annotated type hints as metadata
Language and datatype are mutually exclusive
Custom serializers/parsers override default behavior
The predicate URI is the only required parameter

See also

RdfBaseModel: Base class for RDF-enabled Pydantic models

datatype: str | URIRef | None = None

datatype_uri() → URIRef | None[source]

Convert the datatype to an rdflib URIRef.

Returns:: The datatype as an rdflib URIRef, or None if no datatype is specified.
Return type:: URIRef | None

Examples

>>> from rdflib import XSD
>>> prop = RdfProperty(FOAF.age, datatype=XSD.integer)
>>> prop.datatype_uri()
rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#integer')

language: str | None = None

parser: Any | None = None

predicate: str | URIRef

predicate_uri() → URIRef[source]

Convert the predicate to an rdflib URIRef.

Returns:: The predicate as an rdflib URIRef.
Return type:: URIRef

Examples

>>> from rdflib import FOAF
>>> prop = RdfProperty(FOAF.name)
>>> prop.predicate_uri()
rdflib.term.URIRef('http://xmlns.com/foaf/0.1/name')

serializer: Any | None = None

class dartfx.rdf.pydantic.RdfUriGenerator(*args, **kwargs)[source]

Bases: Protocol

Protocol for objects that generate an RDF subject URI from a model instance.

Any callable with the matching signature — including plain functions and lambdas — satisfies this protocol, so existing rdf_uri_generator callables require no changes.

Parameters:

model (RdfBaseModel) – The model instance being serialised.
base_uri (str | None, optional) – Base URI hint, forwarded from to_rdf_graph.

Returns:

The subject node to use for the resource.

Return type:

URIRef | BNode

Examples

Using a plain function:

def my_generator(model: RdfBaseModel, *, base_uri: str | None = None) -> URIRef | BNode:
    return EX[type(model).__name__ + "/" + str(model.id)]

person = Person(id="alice", rdf_uri_generator=my_generator)

Using a class-based generator:

class PrefixedGenerator:
    def __init__(self, prefix: str) -> None:
        self.prefix = prefix

    def __call__(self, model: RdfBaseModel, *, base_uri: str | None = None) -> URIRef | BNode:
        return URIRef(self.prefix + str(model.id))

class dartfx.rdf.pydantic.TemplateUriGenerator(template: str)[source]

Bases: object

URI generator driven by a Python format-string template.

Placeholders are replaced with model field values using str.format_map(). If a placeholder refers to a field that is None or absent, the generator returns a BNode rather than producing a malformed URI.

Parameters:: template (str) – A URI string with {field_name} placeholders. Any field accessible via model_dump() can be referenced.

Examples

from dartfx.rdf.pydantic import RdfBaseModel, RdfProperty
from dartfx.rdf.pydantic._uri_generators import TemplateUriGenerator
from rdflib import Namespace

EX = Namespace("https://example.org/")

class Dataset(RdfBaseModel):
    rdf_namespace = EX
    rdf_uri_generator = TemplateUriGenerator(
        "https://example.org/datasets/{year}/{slug}"
    )

    year: int | None = None
    slug: str | None = None

ds = Dataset(year=2024, slug="climate-data")
ttl = ds.to_rdf("turtle")
# Subject: <https://example.org/datasets/2024/climate-data>

Notes

The base_uri argument from the serialiser is ignored; the template is always used as-is.

URI Generators

Additional RDF subject URI generators for dartfx.rdf.pydantic.

This module provides a collection of ready-to-use RdfUriGenerator implementations beyond the DefaultUriGenerator that is built into RdfBaseModel.

Available generators:

TemplateUriGenerator
HashUriGenerator
CompositeUriGenerator
PrefixedUriGenerator

Choosing the right generator

No explicit identifier available, and the resource has global identity → use DefaultUriGenerator (UUID on) or HashUriGenerator.
No explicit identifier available, and the resource is local / anonymous (e.g. a reified statement, an intermediate blank node in a graph pattern) → use DefaultUriGenerator with auto_uuid=False, which returns a BNode. This is more semantically correct per the RDF specification, but BNodes cannot be referenced across graph boundaries.
Identifier is embedded in existing fields and you want to build a structured URI without changing the model → use TemplateUriGenerator or PrefixedUriGenerator.
No stable identifier exists but you need a deterministic, reproducible URI from the model’s content (useful for deduplication) → use HashUriGenerator.
Multiple strategies needed with a clear priority order → wrap them in CompositeUriGenerator.

class dartfx.rdf.pydantic._uri_generators.CompositeUriGenerator(*generators: RdfUriGenerator)[source]

Bases: object

URI generator that tries multiple generators in priority order.

Returns the result of the first generator that produces a URIRef. Falls back to a BNode only if every generator in the chain returns a BNode.

This is useful for expressing fallback strategies:

“Use the doi field if set, otherwise hash the title, otherwise BNode.”
“Use a custom generator for known types, fall back to default otherwise.”

Parameters:: *generators (RdfUriGenerator) – Generators to try in order. Must accept the standard (model, *, base_uri=None) -> URIRef | BNode signature.

Examples

from dartfx.rdf.pydantic import DefaultUriGenerator
from dartfx.rdf.pydantic._uri_generators import (
    CompositeUriGenerator,
    HashUriGenerator,
)

gen = CompositeUriGenerator(
    DefaultUriGenerator(auto_uuid=False),          # use id if set, else BNode
    HashUriGenerator("https://example.org/h/", ["title"]),  # hash fallback
)

class Article(RdfBaseModel):
    rdf_uri_generator = gen
    title: str | None = None

class dartfx.rdf.pydantic._uri_generators.HashUriGenerator(namespace: str | Namespace, fields: list[str], *, algorithm: str = 'sha256')[source]

Bases: object

URI generator that creates deterministic, content-addressable URIs.

Computes a stable hash of the specified model fields and appends it to a base namespace, producing a reproducible URI regardless of insert order or serialisation time.

This is particularly useful when:

No natural identifier exists in the data.
You want to deduplicate resources across separate serialisations.
You need stable URIs without assigning them explicitly.

Parameters:

namespace (str | Namespace) – The base URI namespace to prepend to the hash digest, e.g. "https://example.org/hash/" or Namespace("https://example.org/hash/"). A trailing / is added automatically if absent.
fields (list[str]) – Names of the model fields to include in the hash, in order. Fields with None values are skipped. If no field has a value, a BNode is returned.
algorithm (str) – Hash algorithm name accepted by hashlib.new(). Default is "sha256". Use "sha1" for shorter (but collision-prone) digests.

Examples

from dartfx.rdf.pydantic import RdfBaseModel
from dartfx.rdf.pydantic._uri_generators import HashUriGenerator

class Publication(RdfBaseModel):
    rdf_uri_generator = HashUriGenerator(
        namespace="https://example.org/pub/",
        fields=["doi", "title"],
    )

    doi: str | None = None
    title: str | None = None

pub = Publication(doi="10.1234/example", title="My Paper")
# Subject: <https://example.org/pub/<sha256-of-doi+title>>

Notes

Field values are concatenated with "|" as a separator before hashing. The base_uri argument from the serialiser is ignored; namespace always takes precedence.

class dartfx.rdf.pydantic._uri_generators.PrefixedUriGenerator(prefix: str | Namespace, field: str)[source]

Bases: object

URI generator that concatenates a fixed prefix with a single field value.

A lightweight convenience alternative to TemplateUriGenerator when the URI is simply <prefix><field_value>.

Parameters:

prefix (str | Namespace) – The URI prefix. A trailing / is added automatically if absent.
field (str) – The model field whose value is appended to the prefix. If the field is None or absent, a BNode is returned.

Examples

from dartfx.rdf.pydantic._uri_generators import PrefixedUriGenerator

class Concept(RdfBaseModel):
    rdf_uri_generator = PrefixedUriGenerator(
        prefix="https://vocab.example.org/concepts/",
        field="code",
    )
    code: str | None = None
    label: str | None = None

c = Concept(code="001", label="Agriculture")
# Subject: <https://vocab.example.org/concepts/001>

Notes

The base_uri argument from the serialiser is ignored; prefix always takes precedence.

class dartfx.rdf.pydantic._uri_generators.TemplateUriGenerator(template: str)[source]

Bases: object

URI generator driven by a Python format-string template.

Placeholders are replaced with model field values using str.format_map(). If a placeholder refers to a field that is None or absent, the generator returns a BNode rather than producing a malformed URI.

Parameters:: template (str) – A URI string with {field_name} placeholders. Any field accessible via model_dump() can be referenced.

Examples

from dartfx.rdf.pydantic import RdfBaseModel, RdfProperty
from dartfx.rdf.pydantic._uri_generators import TemplateUriGenerator
from rdflib import Namespace

EX = Namespace("https://example.org/")

class Dataset(RdfBaseModel):
    rdf_namespace = EX
    rdf_uri_generator = TemplateUriGenerator(
        "https://example.org/datasets/{year}/{slug}"
    )

    year: int | None = None
    slug: str | None = None

ds = Dataset(year=2024, slug="climate-data")
ttl = ds.to_rdf("turtle")
# Subject: <https://example.org/datasets/2024/climate-data>

Notes

The base_uri argument from the serialiser is ignored; the template is always used as-is.

DCTERMS: Dublin Core

Dublin Core Terms (DCTERMS) vocabulary using Pydantic RDF models.

This module provides Pydantic-based models for the Dublin Core Terms vocabulary, allowing easy serialization to and from RDF formats.

References: - https://www.dublincore.org/specifications/dublin-core/dcmi-terms/ - https://www.dublincore.org/specifications/dublin-core/collection-description/frequency/

class dartfx.rdf.pydantic.dcterms.Agent(*, rdf_uri_generator: RdfUriGenerator = <factory>, id: str, name: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/name, datatype=None, language=None, serializer=None, parser=None)] = None, valid: datetime] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/valid, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: DctermsResource

A resource that acts or has the power to act.

id: str

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: org/dc/terms/name, datatype=None, language=None, serializer=None, parser=None)]

rdf_type = rdflib.term.URIRef('http://purl.org/dc/terms/Agent')

valid: org/dc/terms/valid, datatype=None, language=None, serializer=None, parser=None)]

class dartfx.rdf.pydantic.dcterms.BibliographicResource(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: DctermsResource

A bibliographic resource.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type = rdflib.term.URIRef('http://purl.org/dc/terms/BibliographicResource')

class dartfx.rdf.pydantic.dcterms.DcmiFrequency(*values)[source]

Bases: StrEnum

DCMI Collection Description Frequency Vocabulary.

ANNUAL = 'http://purl.org/cld/freq/annual'

BIENNIAL = 'http://purl.org/cld/freq/biennial'

BIMONTHLY = 'http://purl.org/cld/freq/bimonthly'

BIWEEKLY = 'http://purl.org/cld/freq/biweekly'

CONTINUOUS = 'http://purl.org/cld/freq/continuous'

DAILY = 'http://purl.org/cld/freq/daily'

IRREGULAR = 'http://purl.org/cld/freq/irregular'

MONTHLY = 'http://purl.org/cld/freq/monthly'

QUARTERLY = 'http://purl.org/cld/freq/quarterly'

SEMIANNUAL = 'http://purl.org/cld/freq/semiannual'

SEMIMONTHLY = 'http://purl.org/cld/freq/semimonthly'

SEMIWEEKLY = 'http://purl.org/cld/freq/semiweekly'

THREE_TIMES_A_MONTH = 'http://purl.org/cld/freq/threeTimesAMonth'

THREE_TIMES_A_WEEK = 'http://purl.org/cld/freq/threeTimesAWeek'

TRIENNIAL = 'http://purl.org/cld/freq/triennial'

WEEKLY = 'http://purl.org/cld/freq/weekly'

class dartfx.rdf.pydantic.dcterms.DctermsResource(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: RdfBaseModel

Base class for Dublin Core Terms resources.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_namespace = Namespace('http://purl.org/dc/terms/')

rdf_prefixes = {'dcterms': Namespace('http://purl.org/dc/terms/'), 'freq': Namespace('http://purl.org/cld/freq/')}

class dartfx.rdf.pydantic.dcterms.DublinCoreRecord(*, rdf_uri_generator: RdfUriGenerator = <factory>, id: str, title: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/title, datatype=None, language=None, serializer=None, parser=None)] = None, description: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/description, datatype=None, language=None, serializer=None, parser=None)] = None, creator: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/creator, datatype=None, language=None, serializer=None, parser=None)] = None, subject: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/subject, datatype=None, language=None, serializer=None, parser=None)] = None, publisher: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/publisher, datatype=None, language=None, serializer=None, parser=None)] = None, contributor: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/contributor, datatype=None, language=None, serializer=None, parser=None)] = None, date: datetime] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/date, datatype=None, language=None, serializer=None, parser=None)] = None, created: datetime] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/created, datatype=None, language=None, serializer=None, parser=None)] = None, issued: datetime] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/issued, datatype=None, language=None, serializer=None, parser=None)] = None, modified: datetime] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/modified, datatype=None, language=None, serializer=None, parser=None)] = None, type: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/type, datatype=None, language=None, serializer=None, parser=None)] = None, format: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/format, datatype=None, language=None, serializer=None, parser=None)] = None, identifier: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/identifier, datatype=None, language=None, serializer=None, parser=None)] = None, source: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/source, datatype=None, language=None, serializer=None, parser=None)] = None, language: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/language, datatype=None, language=None, serializer=None, parser=None)] = None, relation: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/relation, datatype=None, language=None, serializer=None, parser=None)] = None, coverage: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/coverage, datatype=None, language=None, serializer=None, parser=None)] = None, rights: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/rights, datatype=None, language=None, serializer=None, parser=None)] = None, license: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/license, datatype=None, language=None, serializer=None, parser=None)] = None, accrual_periodicity: DcmiFrequency] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/accrualPeriodicity, datatype=None, language=None, serializer=None, parser=None)] = None, abstract: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/abstract, datatype=None, language=None, serializer=None, parser=None)] = None, access_rights: RightsStatement] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/accessRights, datatype=None, language=None, serializer=None, parser=None)] = None, alternative: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/alternative, datatype=None, language=None, serializer=None, parser=None)] = None, audience: Agent] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/audience, datatype=None, language=None, serializer=None, parser=None)] = None, available: datetime] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/available, datatype=None, language=None, serializer=None, parser=None)] = None, bibliographic_citation: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/bibliographicCitation, datatype=None, language=None, serializer=None, parser=None)] = None, conforms_to: Standard] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/conformsTo, datatype=None, language=None, serializer=None, parser=None)] = None, date_accepted: datetime] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/dateAccepted, datatype=None, language=None, serializer=None, parser=None)] = None, date_copyrighted: datetime] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/dateCopyrighted, datatype=None, language=None, serializer=None, parser=None)] = None, date_submitted: datetime] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/dateSubmitted, datatype=None, language=None, serializer=None, parser=None)] = None, education_level: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/educationLevel, datatype=None, language=None, serializer=None, parser=None)] = None, extent: SizeOrDuration] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/extent, datatype=None, language=None, serializer=None, parser=None)] = None, has_format: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/hasFormat, datatype=None, language=None, serializer=None, parser=None)] = None, has_part: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/hasPart, datatype=None, language=None, serializer=None, parser=None)] = None, has_version: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/hasVersion, datatype=None, language=None, serializer=None, parser=None)] = None, instructional_method: MethodOfInstruction] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/instructionalMethod, datatype=None, language=None, serializer=None, parser=None)] = None, is_format_of: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/isFormatOf, datatype=None, language=None, serializer=None, parser=None)] = None, is_part_of: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/isPartOf, datatype=None, language=None, serializer=None, parser=None)] = None, is_referenced_by: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/isReferencedBy, datatype=None, language=None, serializer=None, parser=None)] = None, is_replaced_by: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/isReplacedBy, datatype=None, language=None, serializer=None, parser=None)] = None, is_required_by: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/isRequiredBy, datatype=None, language=None, serializer=None, parser=None)] = None, is_version_of: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/isVersionOf, datatype=None, language=None, serializer=None, parser=None)] = None, mediator: Agent] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/mediator, datatype=None, language=None, serializer=None, parser=None)] = None, medium: MediaType] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/medium, datatype=None, language=None, serializer=None, parser=None)] = None, references: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/references, datatype=None, language=None, serializer=None, parser=None)] = None, replaces: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/replaces, datatype=None, language=None, serializer=None, parser=None)] = None, requires: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/requires, datatype=None, language=None, serializer=None, parser=None)] = None, spatial: Location] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/spatial, datatype=None, language=None, serializer=None, parser=None)] = None, table_of_contents: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/tableOfContents, datatype=None, language=None, serializer=None, parser=None)] = None, temporal: PeriodOfTime] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/temporal, datatype=None, language=None, serializer=None, parser=None)] = None, valid: datetime] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://purl.org/dc/terms/valid, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: DctermsResource

A resource with Dublin Core metadata properties.

abstract: org/dc/terms/abstract, datatype=None, language=None, serializer=None, parser=None)]

access_rights: org/dc/terms/accessRights, datatype=None, language=None, serializer=None, parser=None)]

accrual_periodicity: org/dc/terms/accrualPeriodicity, datatype=None, language=None, serializer=None, parser=None)]

alternative: org/dc/terms/alternative, datatype=None, language=None, serializer=None, parser=None)]

audience: org/dc/terms/audience, datatype=None, language=None, serializer=None, parser=None)]

available: org/dc/terms/available, datatype=None, language=None, serializer=None, parser=None)]

bibliographic_citation: org/dc/terms/bibliographicCitation, datatype=None, language=None, serializer=None, parser=None)]

conforms_to: org/dc/terms/conformsTo, datatype=None, language=None, serializer=None, parser=None)]

contributor: org/dc/terms/contributor, datatype=None, language=None, serializer=None, parser=None)]

coverage: org/dc/terms/coverage, datatype=None, language=None, serializer=None, parser=None)]

created: org/dc/terms/created, datatype=None, language=None, serializer=None, parser=None)]

creator: org/dc/terms/creator, datatype=None, language=None, serializer=None, parser=None)]

date: org/dc/terms/date, datatype=None, language=None, serializer=None, parser=None)]

date_accepted: org/dc/terms/dateAccepted, datatype=None, language=None, serializer=None, parser=None)]

date_copyrighted: org/dc/terms/dateCopyrighted, datatype=None, language=None, serializer=None, parser=None)]

date_submitted: org/dc/terms/dateSubmitted, datatype=None, language=None, serializer=None, parser=None)]

description: org/dc/terms/description, datatype=None, language=None, serializer=None, parser=None)]

education_level: org/dc/terms/educationLevel, datatype=None, language=None, serializer=None, parser=None)]

extent: org/dc/terms/extent, datatype=None, language=None, serializer=None, parser=None)]

format: org/dc/terms/format, datatype=None, language=None, serializer=None, parser=None)]

has_format: org/dc/terms/hasFormat, datatype=None, language=None, serializer=None, parser=None)]

has_part: org/dc/terms/hasPart, datatype=None, language=None, serializer=None, parser=None)]

has_version: org/dc/terms/hasVersion, datatype=None, language=None, serializer=None, parser=None)]

id: str

identifier: org/dc/terms/identifier, datatype=None, language=None, serializer=None, parser=None)]

instructional_method: org/dc/terms/instructionalMethod, datatype=None, language=None, serializer=None, parser=None)]

is_format_of: org/dc/terms/isFormatOf, datatype=None, language=None, serializer=None, parser=None)]

is_part_of: org/dc/terms/isPartOf, datatype=None, language=None, serializer=None, parser=None)]

is_referenced_by: org/dc/terms/isReferencedBy, datatype=None, language=None, serializer=None, parser=None)]

is_replaced_by: org/dc/terms/isReplacedBy, datatype=None, language=None, serializer=None, parser=None)]

is_required_by: org/dc/terms/isRequiredBy, datatype=None, language=None, serializer=None, parser=None)]

is_version_of: org/dc/terms/isVersionOf, datatype=None, language=None, serializer=None, parser=None)]

issued: org/dc/terms/issued, datatype=None, language=None, serializer=None, parser=None)]

language: org/dc/terms/language, datatype=None, language=None, serializer=None, parser=None)]

license: org/dc/terms/license, datatype=None, language=None, serializer=None, parser=None)]

mediator: org/dc/terms/mediator, datatype=None, language=None, serializer=None, parser=None)]

medium: org/dc/terms/medium, datatype=None, language=None, serializer=None, parser=None)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

modified: org/dc/terms/modified, datatype=None, language=None, serializer=None, parser=None)]

publisher: org/dc/terms/publisher, datatype=None, language=None, serializer=None, parser=None)]

references: org/dc/terms/references, datatype=None, language=None, serializer=None, parser=None)]

relation: org/dc/terms/relation, datatype=None, language=None, serializer=None, parser=None)]

replaces: org/dc/terms/replaces, datatype=None, language=None, serializer=None, parser=None)]

requires: org/dc/terms/requires, datatype=None, language=None, serializer=None, parser=None)]

rights: org/dc/terms/rights, datatype=None, language=None, serializer=None, parser=None)]

source: org/dc/terms/source, datatype=None, language=None, serializer=None, parser=None)]

spatial: org/dc/terms/spatial, datatype=None, language=None, serializer=None, parser=None)]

subject: org/dc/terms/subject, datatype=None, language=None, serializer=None, parser=None)]

table_of_contents: org/dc/terms/tableOfContents, datatype=None, language=None, serializer=None, parser=None)]

temporal: org/dc/terms/temporal, datatype=None, language=None, serializer=None, parser=None)]

title: org/dc/terms/title, datatype=None, language=None, serializer=None, parser=None)]

type: org/dc/terms/type, datatype=None, language=None, serializer=None, parser=None)]

valid: org/dc/terms/valid, datatype=None, language=None, serializer=None, parser=None)]

class dartfx.rdf.pydantic.dcterms.FileFormat(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: DctermsResource

A file format.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type = rdflib.term.URIRef('http://purl.org/dc/terms/FileFormat')

class dartfx.rdf.pydantic.dcterms.Frequency(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: DctermsResource

A rate of occurrence.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type = rdflib.term.URIRef('http://purl.org/dc/terms/Frequency')

class dartfx.rdf.pydantic.dcterms.Jurisdiction(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: DctermsResource

The extent or range of judicial, law enforcement, or other authority.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type = rdflib.term.URIRef('http://purl.org/dc/terms/Jurisdiction')

class dartfx.rdf.pydantic.dcterms.LicenseDocument(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: DctermsResource

A legal document giving official permission to do something with a Resource.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type = rdflib.term.URIRef('http://purl.org/dc/terms/LicenseDocument')

class dartfx.rdf.pydantic.dcterms.Location(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: DctermsResource

A spatial region or named place.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type = rdflib.term.URIRef('http://purl.org/dc/terms/Location')

class dartfx.rdf.pydantic.dcterms.LocationPeriodOrJurisdiction(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: DctermsResource

A location, period of time, or jurisdiction.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type = rdflib.term.URIRef('http://purl.org/dc/terms/LocationPeriodOrJurisdiction')

class dartfx.rdf.pydantic.dcterms.MediaType(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: DctermsResource

A file format or physical medium.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type = rdflib.term.URIRef('http://purl.org/dc/terms/MediaType')

class dartfx.rdf.pydantic.dcterms.MediaTypeOrExtent(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: DctermsResource

A media type or extent.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type = rdflib.term.URIRef('http://purl.org/dc/terms/MediaTypeOrExtent')

class dartfx.rdf.pydantic.dcterms.MethodOfAccrual(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: DctermsResource

A method by which items are added to a collection.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type = rdflib.term.URIRef('http://purl.org/dc/terms/MethodOfAccrual')

class dartfx.rdf.pydantic.dcterms.MethodOfInstruction(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: DctermsResource

A process that is used to engender knowledge, attitudes, and skills.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type = rdflib.term.URIRef('http://purl.org/dc/terms/MethodOfInstruction')

class dartfx.rdf.pydantic.dcterms.PeriodOfTime(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: DctermsResource

An interval of time that is named or defined by its start and end dates.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type = rdflib.term.URIRef('http://purl.org/dc/terms/PeriodOfTime')

class dartfx.rdf.pydantic.dcterms.PhysicalMedium(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: DctermsResource

A physical material or carrier.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type = rdflib.term.URIRef('http://purl.org/dc/terms/PhysicalMedium')

class dartfx.rdf.pydantic.dcterms.PhysicalResource(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: DctermsResource

A material thing.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type = rdflib.term.URIRef('http://purl.org/dc/terms/PhysicalResource')

class dartfx.rdf.pydantic.dcterms.Policy(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: DctermsResource

A plan or course of action by an authority.

Intended to influence and determine decisions, actions, and other matters.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type = rdflib.term.URIRef('http://purl.org/dc/terms/Policy')

class dartfx.rdf.pydantic.dcterms.ProvenanceStatement(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: DctermsResource

A statement of changes in ownership and custody of a resource.

Includes changes since creation that are significant for authenticity, integrity, and interpretation.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type = rdflib.term.URIRef('http://purl.org/dc/terms/ProvenanceStatement')

class dartfx.rdf.pydantic.dcterms.RightsStatement(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: DctermsResource

A statement about intellectual property rights or permissions.

This includes IPR held in or over a Resource, legal documents giving official permission to do something with a resource, or statements about access rights.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type = rdflib.term.URIRef('http://purl.org/dc/terms/RightsStatement')

class dartfx.rdf.pydantic.dcterms.SizeOrDuration(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: DctermsResource

A dimension or extent, or a time taken to play or execute.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type = rdflib.term.URIRef('http://purl.org/dc/terms/SizeOrDuration')

class dartfx.rdf.pydantic.dcterms.Standard(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: DctermsResource

A basis for comparison; a reference point against which other things can be evaluated.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type = rdflib.term.URIRef('http://purl.org/dc/terms/Standard')

FOAF: Friend of a Friend

FOAF (Friend of a Friend) vocabulary using Pydantic RDF models.

This module provides Pydantic-based models for the FOAF vocabulary, allowing easy serialization to and from RDF formats.

References: - http://xmlns.com/foaf/spec/

class dartfx.rdf.pydantic.foaf.Agent(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: FoafResource

An agent (person, group, software or physical artifact).

account: Annotated[str | URIRef | OnlineAccount | list[str | URIRef | OnlineAccount] | None, RdfProperty(FOAF.account)]

aim_chat_id: Annotated[str | list[str] | None, RdfProperty(FOAF.aimChatID)]

depiction: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(FOAF.depiction)]

homepage: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(FOAF.homepage)]

icq_chat_id: Annotated[str | list[str] | None, RdfProperty(FOAF.icqChatID)]

img: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(FOAF.img)]

jabber_id: Annotated[str | list[str] | None, RdfProperty(FOAF.jabberID)]

made: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(FOAF.made)]

mbox: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(FOAF.mbox)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

msn_chat_id: Annotated[str | list[str] | None, RdfProperty(FOAF.msnChatID)]

name: Annotated[LocalizedStr | None, RdfProperty(FOAF.name)]

nick: Annotated[LocalizedStr | None, RdfProperty(FOAF.nick)]

rdf_type: ClassVar[str | URIRef | None] = 'http://xmlns.com/foaf/0.1/Agent'

status: Annotated[LocalizedStr | None, RdfProperty(FOAF.status)]

tipjar: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(FOAF.tipjar)]

title: Annotated[LocalizedStr | None, RdfProperty(FOAF.title)]

weblog: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(FOAF.weblog)]

yahoo_chat_id: Annotated[str | list[str] | None, RdfProperty(FOAF.yahooChatID)]

class dartfx.rdf.pydantic.foaf.Document(*, rdf_uri_generator: RdfUriGenerator = <factory>, topic: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://xmlns.com/foaf/0.1/topic, datatype=None, language=None, serializer=None, parser=None)] = None, primary_topic: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://xmlns.com/foaf/0.1/primaryTopic, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: FoafResource

A document.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

primary_topic: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(FOAF.primaryTopic)]

rdf_type: ClassVar[str | URIRef | None] = 'http://xmlns.com/foaf/0.1/Document'

topic: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(FOAF.topic)]

class dartfx.rdf.pydantic.foaf.FoafResource(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: RdfBaseModel

Base class for FOAF resources.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_namespace: alias of FOAF

rdf_prefixes: ClassVar = {'foaf': Namespace(Namespace('http://xmlns.com/foaf/0.1/'))}

class dartfx.rdf.pydantic.foaf.Group(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: Agent

A group of agents.

member: Annotated[str | URIRef | Agent | list[str | URIRef | Agent] | None, RdfProperty(FOAF.member)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://xmlns.com/foaf/0.1/Group'

class dartfx.rdf.pydantic.foaf.Image(*, rdf_uri_generator: RdfUriGenerator = <factory>, topic: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://xmlns.com/foaf/0.1/topic, datatype=None, language=None, serializer=None, parser=None)] = None, primary_topic: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://xmlns.com/foaf/0.1/primaryTopic, datatype=None, language=None, serializer=None, parser=None)] = None, depicts: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://xmlns.com/foaf/0.1/depicts, datatype=None, language=None, serializer=None, parser=None)] = None, thumbnail: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://xmlns.com/foaf/0.1/thumbnail, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: Document

An image.

depicts: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(FOAF.depicts)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://xmlns.com/foaf/0.1/Image'

thumbnail: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(FOAF.thumbnail)]

class dartfx.rdf.pydantic.foaf.LabelProperty(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: FoafResource

A label property.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://xmlns.com/foaf/0.1/LabelProperty'

class dartfx.rdf.pydantic.foaf.OnlineAccount(*, rdf_uri_generator: RdfUriGenerator = <factory>, account_name: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://xmlns.com/foaf/0.1/accountName, datatype=None, language=None, serializer=None, parser=None)] = None, account_service_homepage: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://xmlns.com/foaf/0.1/accountServiceHomepage, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: FoafResource

An online account.

account_name: Annotated[str | list[str] | None, RdfProperty(FOAF.accountName)]

account_service_homepage: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(FOAF.accountServiceHomepage)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://xmlns.com/foaf/0.1/OnlineAccount'

class dartfx.rdf.pydantic.foaf.OnlineChatAccount(*, rdf_uri_generator: RdfUriGenerator = <factory>, account_name: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://xmlns.com/foaf/0.1/accountName, datatype=None, language=None, serializer=None, parser=None)] = None, account_service_homepage: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://xmlns.com/foaf/0.1/accountServiceHomepage, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: OnlineAccount

An online chat account.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://xmlns.com/foaf/0.1/OnlineChatAccount'

class dartfx.rdf.pydantic.foaf.OnlineEcommerceAccount(*, rdf_uri_generator: RdfUriGenerator = <factory>, account_name: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://xmlns.com/foaf/0.1/accountName, datatype=None, language=None, serializer=None, parser=None)] = None, account_service_homepage: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://xmlns.com/foaf/0.1/accountServiceHomepage, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: OnlineAccount

An online e-commerce account.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://xmlns.com/foaf/0.1/OnlineEcommerceAccount'

class dartfx.rdf.pydantic.foaf.OnlineGamingAccount(*, rdf_uri_generator: RdfUriGenerator = <factory>, account_name: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://xmlns.com/foaf/0.1/accountName, datatype=None, language=None, serializer=None, parser=None)] = None, account_service_homepage: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://xmlns.com/foaf/0.1/accountServiceHomepage, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: OnlineAccount

An online gaming account.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://xmlns.com/foaf/0.1/OnlineGamingAccount'

class dartfx.rdf.pydantic.foaf.Organization(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: Agent

An organization.

member: Annotated[str | URIRef | Agent | list[str | URIRef | Agent] | None, RdfProperty(FOAF.member)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://xmlns.com/foaf/0.1/Organization'

class dartfx.rdf.pydantic.foaf.Person(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: Agent

A person.

age: Annotated[str | list[str] | None, RdfProperty(FOAF.age)]

based_near: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(FOAF.based_near)]

birthday: Annotated[str | list[str] | None, RdfProperty(FOAF.birthday)]

current_project: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(FOAF.currentProject)]

dna_checksum: Annotated[str | list[str] | None, RdfProperty(FOAF.dnaChecksum)]

family_name: Annotated[LocalizedStr | None, RdfProperty(FOAF.familyName)]

first_name: Annotated[LocalizedStr | None, RdfProperty(FOAF.firstName)]

geekcode: Annotated[str | list[str] | None, RdfProperty(FOAF.geekcode)]

gender: Annotated[LocalizedStr | None, RdfProperty(FOAF.gender)]

given_name: Annotated[LocalizedStr | None, RdfProperty(FOAF.givenName)]

interest: Annotated[str | URIRef | Document | list[str | URIRef | Document] | None, RdfProperty(FOAF.interest)]

knows: Annotated[str | URIRef | Person | list[str | URIRef | Person] | None, RdfProperty(FOAF.knows)]

last_name: Annotated[LocalizedStr | None, RdfProperty(FOAF.lastName)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

myers_briggs: Annotated[str | list[str] | None, RdfProperty(FOAF.myersBriggs)]

openid: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(FOAF.openid)]

past_project: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(FOAF.pastProject)]

plan: Annotated[LocalizedStr | None, RdfProperty(FOAF.plan)]

publications: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(FOAF.publications)]

rdf_type: ClassVar[str | URIRef | None] = 'http://xmlns.com/foaf/0.1/Person'

school_homepage: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(FOAF.schoolHomepage)]

surname: Annotated[LocalizedStr | None, RdfProperty(FOAF.surname)]

topic_interest: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(FOAF.topic_interest)]

work_info_homepage: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(FOAF.workInfoHomepage)]

workplace_homepage: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(FOAF.workplaceHomepage)]

class dartfx.rdf.pydantic.foaf.PersonalProfileDocument(*, rdf_uri_generator: RdfUriGenerator = <factory>, topic: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://xmlns.com/foaf/0.1/topic, datatype=None, language=None, serializer=None, parser=None)] = None, primary_topic: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://xmlns.com/foaf/0.1/primaryTopic, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: Document

A personal profile document.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://xmlns.com/foaf/0.1/PersonalProfileDocument'

class dartfx.rdf.pydantic.foaf.Project(*, rdf_uri_generator: RdfUriGenerator = <factory>, name: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://xmlns.com/foaf/0.1/name, datatype=None, language=None, serializer=None, parser=None)] = None, homepage: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://xmlns.com/foaf/0.1/homepage, datatype=None, language=None, serializer=None, parser=None)] = None, logo: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://xmlns.com/foaf/0.1/logo, datatype=None, language=None, serializer=None, parser=None)] = None, funded_by: Agent] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://xmlns.com/foaf/0.1/fundedBy, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: FoafResource

A project (a collective endeavour of some kind).

funded_by: Annotated[str | URIRef | Agent | list[str | URIRef | Agent] | None, RdfProperty(FOAF.fundedBy)]

homepage: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(FOAF.homepage)]

logo: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(FOAF.logo)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: Annotated[LocalizedStr | None, RdfProperty(FOAF.name)]

rdf_type: ClassVar[str | URIRef | None] = 'http://xmlns.com/foaf/0.1/Project'

ODRL: Open Digital Rights Language

ODRL (Open Digital Rights Language) vocabulary using Pydantic RDF models.

This module provides Pydantic-based models for the ODRL vocabulary, allowing easy serialization to and from RDF formats.

References: - https://www.w3.org/TR/odrl-model/ - https://www.w3.org/TR/odrl-vocab/

class dartfx.rdf.pydantic.odrl.Action(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: OdrlResource

An ODRL Action - an operation on an asset.

implies: Annotated[str | URIRef | Action | list[str | URIRef | Action] | None, RdfProperty(ODRL2.implies)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/odrl/2/Action'

refinement: Annotated[str | URIRef | Constraint | list[str | URIRef | Constraint] | None, RdfProperty(ODRL2.refinement)]

class dartfx.rdf.pydantic.odrl.Agreement(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: Policy

An ODRL Agreement - a policy that has been agreed to.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/odrl/2/Agreement'

class dartfx.rdf.pydantic.odrl.Assertion(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: Policy

An ODRL Assertion.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/odrl/2/Assertion'

class dartfx.rdf.pydantic.odrl.Asset(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: OdrlResource

An ODRL Asset - a resource that is the subject of a policy.

has_policy: Annotated[str | URIRef | Policy | list[str | URIRef | Policy] | None, RdfProperty(ODRL2.hasPolicy)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

part_of: Annotated[str | URIRef | AssetCollection | list[str | URIRef | AssetCollection] | None, RdfProperty(ODRL2.partOf)]

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/odrl/2/Asset'

refinement: Annotated[str | URIRef | Constraint | list[str | URIRef | Constraint] | None, RdfProperty(ODRL2.refinement)]

source: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(ODRL2.source)]

class dartfx.rdf.pydantic.odrl.AssetCollection(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: OdrlResource

An ODRL Asset Collection - a group of assets.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/odrl/2/AssetCollection'

class dartfx.rdf.pydantic.odrl.ConflictTerm(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: OdrlResource

Conflict strategy preference.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/odrl/2/ConflictTerm'

class dartfx.rdf.pydantic.odrl.Constraint(*, rdf_uri_generator: RdfUriGenerator = <factory>, left_operand: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/odrl/2/leftOperand, datatype=None, language=None, serializer=None, parser=None)] = None, operator: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/odrl/2/operator, datatype=None, language=None, serializer=None, parser=None)] = None, right_operand: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/odrl/2/rightOperand, datatype=None, language=None, serializer=None, parser=None)] = None, and_sequence: Constraint] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/odrl/2/and, datatype=None, language=None, serializer=None, parser=None)] = None, or_sequence: Constraint] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/odrl/2/or, datatype=None, language=None, serializer=None, parser=None)] = None, xone: Constraint] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/odrl/2/xone, datatype=None, language=None, serializer=None, parser=None)] = None, data_type: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/odrl/2/dataType, datatype=None, language=None, serializer=None, parser=None)] = None, unit: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/odrl/2/unit, datatype=None, language=None, serializer=None, parser=None)] = None, status: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/odrl/2/status, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: OdrlResource

An ODRL Constraint - a boolean expression.

and_sequence: Annotated[str | URIRef | Constraint | list[str | URIRef | Constraint] | None, RdfProperty(ODRL2['and'])]

data_type: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(ODRL2.dataType)]

left_operand: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(ODRL2.leftOperand)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

operator: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(ODRL2.operator)]

or_sequence: Annotated[str | URIRef | Constraint | list[str | URIRef | Constraint] | None, RdfProperty(ODRL2['or'])]

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/odrl/2/Constraint'

right_operand: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(ODRL2.rightOperand)]

status: Annotated[LocalizedStr | None, RdfProperty(ODRL2.status)]

unit: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(ODRL2.unit)]

xone: Annotated[str | URIRef | Constraint | list[str | URIRef | Constraint] | None, RdfProperty(ODRL2.xone)]

class dartfx.rdf.pydantic.odrl.Duty(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: Rule

An ODRL Duty - an obligation to perform an action.

consequence: Annotated[str | URIRef | Duty | list[str | URIRef | Duty] | None, RdfProperty(ODRL2.consequence)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/odrl/2/Duty'

class dartfx.rdf.pydantic.odrl.LeftOperand(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: OdrlResource

Left operand for a constraint.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/odrl/2/LeftOperand'

class dartfx.rdf.pydantic.odrl.LogicalConstraint(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: OdrlResource

A logical constraint.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/odrl/2/LogicalConstraint'

class dartfx.rdf.pydantic.odrl.OdrlResource(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: RdfBaseModel

Base class for ODRL resources.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_namespace: alias of ODRL2

rdf_prefixes: ClassVar = {'odrl': Namespace(Namespace('http://www.w3.org/ns/odrl/2/'))}

class dartfx.rdf.pydantic.odrl.Offer(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: Policy

An ODRL Offer - a policy offered by an assigner.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/odrl/2/Offer'

class dartfx.rdf.pydantic.odrl.Operator(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: OdrlResource

Operator for a constraint.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/odrl/2/Operator'

class dartfx.rdf.pydantic.odrl.Party(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: OdrlResource

An ODRL Party - an entity with a functional role.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

part_of: Annotated[str | URIRef | PartyCollection | list[str | URIRef | PartyCollection] | None, RdfProperty(ODRL2.partOf)]

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/odrl/2/Party'

refinement: Annotated[str | URIRef | Constraint | list[str | URIRef | Constraint] | None, RdfProperty(ODRL2.refinement)]

scope: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(ODRL2.scope)]

source: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(ODRL2.source)]

class dartfx.rdf.pydantic.odrl.PartyCollection(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: OdrlResource

An ODRL Party Collection - a group of parties.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/odrl/2/PartyCollection'

class dartfx.rdf.pydantic.odrl.Permission(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: Rule

An ODRL Permission - the ability to perform an action.

duty: Annotated[str | URIRef | Duty | list[str | URIRef | Duty] | None, RdfProperty(ODRL2.duty)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/odrl/2/Permission'

class dartfx.rdf.pydantic.odrl.Policy(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: OdrlResource

An ODRL Policy.

conflict: Annotated[ConflictTerm | URIRef | str | list[ConflictTerm | URIRef | str] | None, RdfProperty(ODRL2.conflict)]

inherits_from: Annotated[Policy | URIRef | str | list[Policy | URIRef | str] | None, RdfProperty(ODRL2.inheritFrom)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

obligation: Annotated[Duty | URIRef | str | list[Duty | URIRef | str] | None, RdfProperty(ODRL2.obligation)]

permission: Annotated[Permission | URIRef | str | list[Permission | URIRef | str] | None, RdfProperty(ODRL2.permission)]

profile: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(ODRL2.profile)]

prohibition: Annotated[Prohibition | URIRef | str | list[Prohibition | URIRef | str] | None, RdfProperty(ODRL2.prohibition)]

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/odrl/2/Policy'

uid: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(ODRL2.uid)]

class dartfx.rdf.pydantic.odrl.Privacy(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: Policy

An ODRL Privacy Policy.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/odrl/2/Privacy'

class dartfx.rdf.pydantic.odrl.Prohibition(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: Rule

An ODRL Prohibition - the inability to perform an action.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/odrl/2/Prohibition'

remedy: Annotated[str | URIRef | Duty | list[str | URIRef | Duty] | None, RdfProperty(ODRL2.remedy)]

class dartfx.rdf.pydantic.odrl.Request(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: Policy

An ODRL Request.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/odrl/2/Request'

class dartfx.rdf.pydantic.odrl.RightOperand(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: OdrlResource

Right operand for a constraint.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/odrl/2/RightOperand'

class dartfx.rdf.pydantic.odrl.Rule(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: OdrlResource

Base class for ODRL Rules.

action: Annotated[str | URIRef | Action | list[str | URIRef | Action] | None, RdfProperty(ODRL2.action)]

assignee: Annotated[str | URIRef | Party | list[str | URIRef | Party] | None, RdfProperty(ODRL2.assignee)]

assigner: Annotated[str | URIRef | Party | list[str | URIRef | Party] | None, RdfProperty(ODRL2.assigner)]

constraint: Annotated[str | URIRef | Constraint | list[str | URIRef | Constraint] | None, RdfProperty(ODRL2.constraint)]

failure: Annotated[str | URIRef | Rule | list[str | URIRef | Rule] | None, RdfProperty(ODRL2.failure)]

function: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(ODRL2['function'])]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

relation: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(ODRL2.relation)]

target: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(ODRL2.target)]

class dartfx.rdf.pydantic.odrl.Set(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: Policy

An ODRL Set Policy - no specific target.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/odrl/2/Set'

class dartfx.rdf.pydantic.odrl.Ticket(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: Policy

An ODRL Ticket.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/odrl/2/Ticket'

PROV: Prov Ontology

PROV (Provenance Ontology) vocabulary using Pydantic RDF models.

This module provides Pydantic-based models for the PROV-O vocabulary, allowing easy serialization to and from RDF formats.

References: - https://www.w3.org/TR/prov-o/ - https://www.w3.org/TR/prov-dm/

class dartfx.rdf.pydantic.prov.Activity(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: ProvResource

A PROV Activity - something that occurs over a period of time.

at_location: Annotated[str | URIRef | Location | list[str | URIRef | Location] | None, RdfProperty(PROV.atLocation)]

ended_at_time: Annotated[str | datetime | list[str | datetime] | None, RdfProperty(PROV.endedAtTime)]

generated: Annotated[str | URIRef | Entity | list[str | URIRef | Entity] | None, RdfProperty(PROV.generated)]

invalidated: Annotated[str | URIRef | Entity | list[str | URIRef | Entity] | None, RdfProperty(PROV.invalidated)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

qualified_association: Annotated[str | URIRef | Association | list[str | URIRef | Association] | None, RdfProperty(PROV.qualifiedAssociation)]

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/prov#Activity'

started_at_time: Annotated[str | datetime | list[str | datetime] | None, RdfProperty(PROV.startedAtTime)]

used: Annotated[str | URIRef | Entity | list[str | URIRef | Entity] | None, RdfProperty(PROV.used)]

was_associated_with: Annotated[str | URIRef | Agent | list[str | URIRef | Agent] | None, RdfProperty(PROV.wasAssociatedWith)]

was_ended_by: Annotated[str | URIRef | Entity | list[str | URIRef | Entity] | None, RdfProperty(PROV.wasEndedBy)]

was_influenced_by: Annotated[str | URIRef | Agent | Entity | Activity | Influence | list[str | URIRef | Agent | Entity | Activity | Influence] | None, RdfProperty(PROV.wasInfluencedBy)]

was_informed_by: Annotated[str | URIRef | Activity | list[str | URIRef | Activity] | None, RdfProperty(PROV.wasInformedBy)]

was_started_by: Annotated[str | URIRef | Entity | list[str | URIRef | Entity] | None, RdfProperty(PROV.wasStartedBy)]

class dartfx.rdf.pydantic.prov.Agent(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: ProvResource

A PROV Agent - something that bears some form of responsibility.

acted_on_behalf_of: Annotated[str | URIRef | Agent | list[str | URIRef | Agent] | None, RdfProperty(PROV.actedOnBehalfOf)]

at_location: Annotated[str | URIRef | Location | list[str | URIRef | Location] | None, RdfProperty(PROV.atLocation)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

qualified_delegation: Annotated[str | URIRef | Delegation | list[str | URIRef | Delegation] | None, RdfProperty(PROV.qualifiedDelegation)]

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/prov#Agent'

was_influenced_by: Annotated[str | URIRef | Agent | Entity | Activity | Influence | list[str | URIRef | Agent | Entity | Activity | Influence] | None, RdfProperty(PROV.wasInfluencedBy)]

class dartfx.rdf.pydantic.prov.Association(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: ProvResource

A PROV Association - an assignment of responsibility to an agent.

agent: Annotated[str | URIRef | Agent | list[str | URIRef | Agent] | None, RdfProperty(PROV.agent)]

had_plan: Annotated[str | URIRef | Plan | list[str | URIRef | Plan] | None, RdfProperty(PROV.hadPlan)]

had_role: Annotated[str | URIRef | Role | list[str | URIRef | Role] | None, RdfProperty(PROV.hadRole)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/prov#Association'

class dartfx.rdf.pydantic.prov.Bundle(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: Entity

A PROV Bundle - a named set of provenance descriptions.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/prov#Bundle'

class dartfx.rdf.pydantic.prov.Collection(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: Entity

A PROV Collection - an entity that provides a structure for its members.

had_member: Annotated[str | URIRef | Entity | list[str | URIRef | Entity] | None, RdfProperty(PROV.hadMember)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/prov#Collection'

class dartfx.rdf.pydantic.prov.Delegation(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: ProvResource

A PROV Delegation - responsibility transfer from one agent to another.

agent: Annotated[str | URIRef | Agent | list[str | URIRef | Agent] | None, RdfProperty(PROV.agent)]

had_activity: Annotated[str | URIRef | Activity | list[str | URIRef | Activity] | None, RdfProperty(PROV.hadActivity)]

had_role: Annotated[str | URIRef | Role | list[str | URIRef | Role] | None, RdfProperty(PROV.hadRole)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/prov#Delegation'

class dartfx.rdf.pydantic.prov.Derivation(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: ProvResource

A PROV Derivation - transformation of an entity into another.

entity: Annotated[str | URIRef | Entity | list[str | URIRef | Entity] | None, RdfProperty(PROV.entity)]

had_activity: Annotated[str | URIRef | Activity | list[str | URIRef | Activity] | None, RdfProperty(PROV.hadActivity)]

had_generation: Annotated[str | URIRef | Generation | list[str | URIRef | Generation] | None, RdfProperty(PROV.hadGeneration)]

had_usage: Annotated[str | URIRef | Usage | list[str | URIRef | Usage] | None, RdfProperty(PROV.hadUsage)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/prov#Derivation'

class dartfx.rdf.pydantic.prov.EmptyCollection(*, rdf_uri_generator: RdfUriGenerator = <factory>, was_generated_by: Activity] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#wasGeneratedBy, datatype=None, language=None, serializer=None, parser=None)] = None, was_invalidated_by: Activity] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#wasInvalidatedBy, datatype=None, language=None, serializer=None, parser=None)] = None, generated_at_time: datetime] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#generatedAtTime, datatype=None, language=None, serializer=None, parser=None)] = None, invalidated_at_time: datetime] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#invalidatedAtTime, datatype=None, language=None, serializer=None, parser=None)] = None, was_derived_from: Entity] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#wasDerivedFrom, datatype=None, language=None, serializer=None, parser=None)] = None, was_revision_of: Entity] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#wasRevisionOf, datatype=None, language=None, serializer=None, parser=None)] = None, was_quoted_from: Entity] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#wasQuotedFrom, datatype=None, language=None, serializer=None, parser=None)] = None, had_primary_source: Entity] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#hadPrimarySource, datatype=None, language=None, serializer=None, parser=None)] = None, was_attributed_to: Agent] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#wasAttributedTo, datatype=None, language=None, serializer=None, parser=None)] = None, alternate_of: Entity] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#alternateOf, datatype=None, language=None, serializer=None, parser=None)] = None, specialization_of: Entity] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#specializationOf, datatype=None, language=None, serializer=None, parser=None)] = None, at_location: Location] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#atLocation, datatype=None, language=None, serializer=None, parser=None)] = None, value: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#value, datatype=None, language=None, serializer=None, parser=None)] = None, was_influenced_by: Influence] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#wasInfluencedBy, datatype=None, language=None, serializer=None, parser=None)] = None, had_member: Entity] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#hadMember, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: Collection

A PROV Empty Collection - a collection with no members.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/prov#EmptyCollection'

class dartfx.rdf.pydantic.prov.End(*, rdf_uri_generator: RdfUriGenerator = <factory>, influencer: Activity] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#influencer, datatype=None, language=None, serializer=None, parser=None)] = None, had_role: Role] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#hadRole, datatype=None, language=None, serializer=None, parser=None)] = None, had_activity: Activity] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#hadActivity, datatype=None, language=None, serializer=None, parser=None)] = None, had_plan: Plan] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#hadPlan, datatype=None, language=None, serializer=None, parser=None)] = None, had_usage: Usage] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#hadUsage, datatype=None, language=None, serializer=None, parser=None)] = None, had_generation: Generation] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#hadGeneration, datatype=None, language=None, serializer=None, parser=None)] = None, at_time: datetime] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#atTime, datatype=None, language=None, serializer=None, parser=None)] = None, at_location: Location] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#atLocation, datatype=None, language=None, serializer=None, parser=None)] = None, entity: Entity] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#entity, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: InstantaneousEvent, Influence

A PROV End - when an activity is deemed to have ended.

entity: Annotated[str | URIRef | Entity | list[str | URIRef | Entity] | None, RdfProperty(PROV.entity)]

had_activity: Annotated[str | URIRef | Activity | list[str | URIRef | Activity] | None, RdfProperty(PROV.hadActivity)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/prov#End'

class dartfx.rdf.pydantic.prov.Entity(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: ProvResource

A PROV Entity - a physical, digital, conceptual, or other kind of thing.

alternate_of: Annotated[str | URIRef | Entity | list[str | URIRef | Entity] | None, RdfProperty(PROV.alternateOf)]

at_location: Annotated[str | URIRef | Location | list[str | URIRef | Location] | None, RdfProperty(PROV.atLocation)]

generated_at_time: Annotated[str | datetime | list[str | datetime] | None, RdfProperty(PROV.generatedAtTime)]

had_primary_source: Annotated[str | URIRef | Entity | list[str | URIRef | Entity] | None, RdfProperty(PROV.hadPrimarySource)]

invalidated_at_time: Annotated[str | datetime | list[str | datetime] | None, RdfProperty(PROV.invalidatedAtTime)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/prov#Entity'

specialization_of: Annotated[str | URIRef | Entity | list[str | URIRef | Entity] | None, RdfProperty(PROV.specializationOf)]

value: Annotated[LocalizedStr | None, RdfProperty(PROV.value)]

was_attributed_to: Annotated[str | URIRef | Agent | list[str | URIRef | Agent] | None, RdfProperty(PROV.wasAttributedTo)]

was_derived_from: Annotated[str | URIRef | Entity | list[str | URIRef | Entity] | None, RdfProperty(PROV.wasDerivedFrom)]

was_generated_by: Annotated[str | URIRef | Activity | list[str | URIRef | Activity] | None, RdfProperty(PROV.wasGeneratedBy)]

was_influenced_by: Annotated[str | URIRef | Agent | Entity | Activity | Influence | list[str | URIRef | Agent | Entity | Activity | Influence] | None, RdfProperty(PROV.wasInfluencedBy)]

was_invalidated_by: Annotated[str | URIRef | Activity | list[str | URIRef | Activity] | None, RdfProperty(PROV.wasInvalidatedBy)]

was_quoted_from: Annotated[str | URIRef | Entity | list[str | URIRef | Entity] | None, RdfProperty(PROV.wasQuotedFrom)]

was_revision_of: Annotated[str | URIRef | Entity | list[str | URIRef | Entity] | None, RdfProperty(PROV.wasRevisionOf)]

class dartfx.rdf.pydantic.prov.Generation(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: ProvResource

A PROV Generation - completion of production of a new entity.

activity: Annotated[str | URIRef | Activity | list[str | URIRef | Activity] | None, RdfProperty(PROV.activity)]

at_time: Annotated[str | datetime | list[str | datetime] | None, RdfProperty(PROV.atTime)]

entity: Annotated[str | URIRef | Entity | list[str | URIRef | Entity] | None, RdfProperty(PROV.entity)]

had_role: Annotated[str | URIRef | Role | list[str | URIRef | Role] | None, RdfProperty(PROV.hadRole)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/prov#Generation'

class dartfx.rdf.pydantic.prov.Influence(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: ProvResource

A PROV Influence - capacity of an entity, activity, or agent to have an effect on another.

had_activity: Annotated[str | URIRef | Activity | list[str | URIRef | Activity] | None, RdfProperty(PROV.hadActivity)]

had_generation: Annotated[str | URIRef | Generation | list[str | URIRef | Generation] | None, RdfProperty(PROV.hadGeneration)]

had_plan: Annotated[str | URIRef | Plan | list[str | URIRef | Plan] | None, RdfProperty(PROV.hadPlan)]

had_role: Annotated[str | URIRef | Role | list[str | URIRef | Role] | None, RdfProperty(PROV.hadRole)]

had_usage: Annotated[str | URIRef | Usage | list[str | URIRef | Usage] | None, RdfProperty(PROV.hadUsage)]

influencer: Annotated[str | URIRef | Agent | Entity | Activity | list[str | URIRef | Agent | Entity | Activity] | None, RdfProperty(PROV.influencer)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/prov#Influence'

class dartfx.rdf.pydantic.prov.InstantaneousEvent(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: ProvResource

A PROV Instantaneous Event - happens at a specific instant in time.

at_location: Annotated[str | URIRef | Location | list[str | URIRef | Location] | None, RdfProperty(PROV.atLocation)]

at_time: Annotated[str | datetime | list[str | datetime] | None, RdfProperty(PROV.atTime)]

had_role: Annotated[str | URIRef | Role | list[str | URIRef | Role] | None, RdfProperty(PROV.hadRole)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/prov#InstantaneousEvent'

class dartfx.rdf.pydantic.prov.Location(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: ProvResource

A PROV Location - an identifiable geographic place.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/prov#Location'

class dartfx.rdf.pydantic.prov.Organization(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: Agent

A PROV Organization.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/prov#Organization'

class dartfx.rdf.pydantic.prov.Person(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: Agent

A PROV Person.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/prov#Person'

class dartfx.rdf.pydantic.prov.Plan(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: Entity

A PROV Plan - a set of actions or steps intended by an agent.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/prov#Plan'

class dartfx.rdf.pydantic.prov.ProvResource(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: RdfBaseModel

Base class for PROV resources.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_namespace: alias of PROV

rdf_prefixes: ClassVar = {'prov': Namespace(Namespace('http://www.w3.org/ns/prov#'))}

class dartfx.rdf.pydantic.prov.Role(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: ProvResource

A PROV Role - function of an entity or agent in an activity.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/prov#Role'

class dartfx.rdf.pydantic.prov.SoftwareAgent(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: Agent

A PROV Software Agent.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/prov#SoftwareAgent'

class dartfx.rdf.pydantic.prov.Start(*, rdf_uri_generator: RdfUriGenerator = <factory>, influencer: Activity] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#influencer, datatype=None, language=None, serializer=None, parser=None)] = None, had_role: Role] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#hadRole, datatype=None, language=None, serializer=None, parser=None)] = None, had_activity: Activity] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#hadActivity, datatype=None, language=None, serializer=None, parser=None)] = None, had_plan: Plan] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#hadPlan, datatype=None, language=None, serializer=None, parser=None)] = None, had_usage: Usage] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#hadUsage, datatype=None, language=None, serializer=None, parser=None)] = None, had_generation: Generation] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#hadGeneration, datatype=None, language=None, serializer=None, parser=None)] = None, at_time: datetime] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#atTime, datatype=None, language=None, serializer=None, parser=None)] = None, at_location: Location] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#atLocation, datatype=None, language=None, serializer=None, parser=None)] = None, entity: Entity] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/ns/prov#entity, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: InstantaneousEvent, Influence

A PROV Start - when an activity is deemed to have started.

entity: Annotated[str | URIRef | Entity | list[str | URIRef | Entity] | None, RdfProperty(PROV.entity)]

had_activity: Annotated[str | URIRef | Activity | list[str | URIRef | Activity] | None, RdfProperty(PROV.hadActivity)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/prov#Start'

class dartfx.rdf.pydantic.prov.Usage(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: ProvResource

A PROV Usage - consumption of an entity by an activity.

at_time: Annotated[str | datetime | list[str | datetime] | None, RdfProperty(PROV.atTime)]

entity: Annotated[str | URIRef | Entity | list[str | URIRef | Entity] | None, RdfProperty(PROV.entity)]

had_role: Annotated[str | URIRef | Role | list[str | URIRef | Role] | None, RdfProperty(PROV.hadRole)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/ns/prov#Usage'

SKOS: Simple Knowledge Organization System

SKOS (Simple Knowledge Organization System) vocabulary using Pydantic RDF models.

This module provides Pydantic-based models for the SKOS vocabulary, allowing easy serialization to and from RDF formats.

References: - https://www.w3.org/2004/02/skos/ - https://www.w3.org/TR/skos-reference/

class dartfx.rdf.pydantic.skos.Collection(*, rdf_uri_generator: RdfUriGenerator = <factory>, id: str, pref_label: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#prefLabel, datatype=None, language=None, serializer=None, parser=None)] = None, alt_label: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#altLabel, datatype=None, language=None, serializer=None, parser=None)] = None, hidden_label: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#hiddenLabel, datatype=None, language=None, serializer=None, parser=None)] = None, notation: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#notation, datatype=None, language=None, serializer=None, parser=None)] = None, note: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#note, datatype=None, language=None, serializer=None, parser=None)] = None, member: Collection] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#member, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: SkosResource

A SKOS Collection - a meaningful grouping of concepts.

alt_label: Annotated[LocalizedStr | None, RdfProperty(SKOS.altLabel)]

hidden_label: Annotated[LocalizedStr | None, RdfProperty(SKOS.hiddenLabel)]

id: str

member: Annotated[str | URIRef | Concept | Collection | list[str | URIRef | Concept | Collection] | None, RdfProperty(SKOS.member)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

notation: Annotated[str | list[str] | None, RdfProperty(SKOS.notation)]

note: Annotated[LocalizedStr | None, RdfProperty(SKOS.note)]

pref_label: Annotated[LocalizedStr | None, RdfProperty(SKOS.prefLabel)]

rdf_type = rdflib.term.URIRef('http://www.w3.org/2004/02/skos/core#Collection')

class dartfx.rdf.pydantic.skos.Concept(*, rdf_uri_generator: RdfUriGenerator = <factory>, id: str, pref_label: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#prefLabel, datatype=None, language=None, serializer=None, parser=None)] = None, alt_label: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#altLabel, datatype=None, language=None, serializer=None, parser=None)] = None, hidden_label: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#hiddenLabel, datatype=None, language=None, serializer=None, parser=None)] = None, pref_label_xl: Label] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2008/05/skos-xl#prefLabel, datatype=None, language=None, serializer=None, parser=None)] = None, alt_label_xl: Label] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2008/05/skos-xl#altLabel, datatype=None, language=None, serializer=None, parser=None)] = None, hidden_label_xl: Label] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2008/05/skos-xl#hiddenLabel, datatype=None, language=None, serializer=None, parser=None)] = None, notation: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#notation, datatype=None, language=None, serializer=None, parser=None)] = None, note: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#note, datatype=None, language=None, serializer=None, parser=None)] = None, change_note: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#changeNote, datatype=None, language=None, serializer=None, parser=None)] = None, definition: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#definition, datatype=None, language=None, serializer=None, parser=None)] = None, editorial_note: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#editorialNote, datatype=None, language=None, serializer=None, parser=None)] = None, example: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#example, datatype=None, language=None, serializer=None, parser=None)] = None, history_note: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#historyNote, datatype=None, language=None, serializer=None, parser=None)] = None, scope_note: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#scopeNote, datatype=None, language=None, serializer=None, parser=None)] = None, in_scheme: ConceptScheme] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#inScheme, datatype=None, language=None, serializer=None, parser=None)] = None, top_concept_of: ConceptScheme] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#topConceptOf, datatype=None, language=None, serializer=None, parser=None)] = None, broader: Concept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#broader, datatype=None, language=None, serializer=None, parser=None)] = None, narrower: Concept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#narrower, datatype=None, language=None, serializer=None, parser=None)] = None, broader_transitive: Concept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#broaderTransitive, datatype=None, language=None, serializer=None, parser=None)] = None, narrower_transitive: Concept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#narrowerTransitive, datatype=None, language=None, serializer=None, parser=None)] = None, related: Concept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#related, datatype=None, language=None, serializer=None, parser=None)] = None, close_match: Concept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#closeMatch, datatype=None, language=None, serializer=None, parser=None)] = None, exact_match: Concept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#exactMatch, datatype=None, language=None, serializer=None, parser=None)] = None, broad_match: Concept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#broadMatch, datatype=None, language=None, serializer=None, parser=None)] = None, narrow_match: Concept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#narrowMatch, datatype=None, language=None, serializer=None, parser=None)] = None, related_match: Concept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#relatedMatch, datatype=None, language=None, serializer=None, parser=None)] = None, semantic_relation: Concept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#semanticRelation, datatype=None, language=None, serializer=None, parser=None)] = None, mapping_relation: Concept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#mappingRelation, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: SkosResource

A SKOS Concept - a unit of thought.

alt_label: Annotated[LocalizedStr | None, RdfProperty(SKOS.altLabel)]

alt_label_xl: Annotated[str | URIRef | Label | list[str | URIRef | Label] | None, RdfProperty(SKOSXL.altLabel)]

broad_match: Annotated[str | URIRef | Concept | list[str | URIRef | Concept] | None, RdfProperty(SKOS.broadMatch)]

broader: Annotated[str | URIRef | Concept | list[str | URIRef | Concept] | None, RdfProperty(SKOS.broader)]

broader_transitive: Annotated[str | URIRef | Concept | list[str | URIRef | Concept] | None, RdfProperty(SKOS.broaderTransitive)]

change_note: Annotated[LocalizedStr | None, RdfProperty(SKOS.changeNote)]

close_match: Annotated[str | URIRef | Concept | list[str | URIRef | Concept] | None, RdfProperty(SKOS.closeMatch)]

definition: Annotated[LocalizedStr | None, RdfProperty(SKOS.definition)]

editorial_note: Annotated[LocalizedStr | None, RdfProperty(SKOS.editorialNote)]

exact_match: Annotated[str | URIRef | Concept | list[str | URIRef | Concept] | None, RdfProperty(SKOS.exactMatch)]

example: Annotated[LocalizedStr | None, RdfProperty(SKOS.example)]

hidden_label: Annotated[LocalizedStr | None, RdfProperty(SKOS.hiddenLabel)]

hidden_label_xl: Annotated[str | URIRef | Label | list[str | URIRef | Label] | None, RdfProperty(SKOSXL.hiddenLabel)]

history_note: Annotated[LocalizedStr | None, RdfProperty(SKOS.historyNote)]

id: str

in_scheme: Annotated[str | URIRef | ConceptScheme | list[str | URIRef | ConceptScheme] | None, RdfProperty(SKOS.inScheme)]

mapping_relation: Annotated[str | URIRef | Concept | list[str | URIRef | Concept] | None, RdfProperty(SKOS.mappingRelation)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

narrow_match: Annotated[str | URIRef | Concept | list[str | URIRef | Concept] | None, RdfProperty(SKOS.narrowMatch)]

narrower: Annotated[str | URIRef | Concept | list[str | URIRef | Concept] | None, RdfProperty(SKOS.narrower)]

narrower_transitive: Annotated[str | URIRef | Concept | list[str | URIRef | Concept] | None, RdfProperty(SKOS.narrowerTransitive)]

notation: Annotated[str | list[str] | None, RdfProperty(SKOS.notation)]

note: Annotated[LocalizedStr | None, RdfProperty(SKOS.note)]

pref_label: Annotated[LocalizedStr | None, RdfProperty(SKOS.prefLabel)]

pref_label_xl: Annotated[str | URIRef | Label | list[str | URIRef | Label] | None, RdfProperty(SKOSXL.prefLabel)]

rdf_type = rdflib.term.URIRef('http://www.w3.org/2004/02/skos/core#Concept')

related: Annotated[str | URIRef | Concept | list[str | URIRef | Concept] | None, RdfProperty(SKOS.related)]

related_match: Annotated[str | URIRef | Concept | list[str | URIRef | Concept] | None, RdfProperty(SKOS.relatedMatch)]

scope_note: Annotated[LocalizedStr | None, RdfProperty(SKOS.scopeNote)]

semantic_relation: Annotated[str | URIRef | Concept | list[str | URIRef | Concept] | None, RdfProperty(SKOS.semanticRelation)]

top_concept_of: Annotated[str | URIRef | ConceptScheme | list[str | URIRef | ConceptScheme] | None, RdfProperty(SKOS.topConceptOf)]

class dartfx.rdf.pydantic.skos.ConceptScheme(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: SkosResource

A SKOS Concept Scheme - an aggregation of one or more SKOS concepts.

alt_label: Annotated[LocalizedStr | None, RdfProperty(SKOS.altLabel)]

alt_label_xl: Annotated[str | URIRef | Label | list[str | URIRef | Label] | None, RdfProperty(SKOSXL.altLabel)]

change_note: Annotated[LocalizedStr | None, RdfProperty(SKOS.changeNote)]

definition: Annotated[LocalizedStr | None, RdfProperty(SKOS.definition)]

editorial_note: Annotated[LocalizedStr | None, RdfProperty(SKOS.editorialNote)]

example: Annotated[LocalizedStr | None, RdfProperty(SKOS.example)]

has_top_concept: Annotated[str | URIRef | Concept | list[str | URIRef | Concept] | None, RdfProperty(SKOS.hasTopConcept)]

hidden_label: Annotated[LocalizedStr | None, RdfProperty(SKOS.hiddenLabel)]

hidden_label_xl: Annotated[str | URIRef | Label | list[str | URIRef | Label] | None, RdfProperty(SKOSXL.hiddenLabel)]

history_note: Annotated[LocalizedStr | None, RdfProperty(SKOS.historyNote)]

id: str

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

notation: Annotated[str | list[str] | None, RdfProperty(SKOS.notation)]

note: Annotated[LocalizedStr | None, RdfProperty(SKOS.note)]

pref_label: Annotated[LocalizedStr | None, RdfProperty(SKOS.prefLabel)]

pref_label_xl: Annotated[str | URIRef | Label | list[str | URIRef | Label] | None, RdfProperty(SKOSXL.prefLabel)]

rdf_type = rdflib.term.URIRef('http://www.w3.org/2004/02/skos/core#ConceptScheme')

scope_note: Annotated[LocalizedStr | None, RdfProperty(SKOS.scopeNote)]

class dartfx.rdf.pydantic.skos.Label(*, rdf_uri_generator: ~dartfx.rdf.pydantic._base.RdfUriGenerator = <factory>, literal_form: ~typing.Annotated[str, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2008/05/skos-xl#literalForm, datatype=None, language=None, serializer=None, parser=None)])[source]

Bases: SkosResource

A SKOS-XL Label.

literal_form: Annotated[str, RdfProperty(SKOSXL.literalForm)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_namespace = Namespace('http://www.w3.org/2008/05/skos-xl#')

rdf_prefixes = {'skosxl': Namespace('http://www.w3.org/2008/05/skos-xl#')}

rdf_type = rdflib.term.URIRef('http://www.w3.org/2008/05/skos-xl#Label')

class dartfx.rdf.pydantic.skos.OrderedCollection(*, rdf_uri_generator: RdfUriGenerator = <factory>, id: str, pref_label: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#prefLabel, datatype=None, language=None, serializer=None, parser=None)] = None, alt_label: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#altLabel, datatype=None, language=None, serializer=None, parser=None)] = None, hidden_label: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#hiddenLabel, datatype=None, language=None, serializer=None, parser=None)] = None, notation: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#notation, datatype=None, language=None, serializer=None, parser=None)] = None, note: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#note, datatype=None, language=None, serializer=None, parser=None)] = None, member_list: Concept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#memberList, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: SkosResource

A SKOS Ordered Collection - an ordered grouping of concepts.

alt_label: Annotated[LocalizedStr | None, RdfProperty(SKOS.altLabel)]

hidden_label: Annotated[LocalizedStr | None, RdfProperty(SKOS.hiddenLabel)]

id: str

member_list: Annotated[str | URIRef | Concept | list[str | URIRef | Concept] | None, RdfProperty(SKOS.memberList)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

notation: Annotated[str | list[str] | None, RdfProperty(SKOS.notation)]

note: Annotated[LocalizedStr | None, RdfProperty(SKOS.note)]

pref_label: Annotated[LocalizedStr | None, RdfProperty(SKOS.prefLabel)]

rdf_type = rdflib.term.URIRef('http://www.w3.org/2004/02/skos/core#OrderedCollection')

class dartfx.rdf.pydantic.skos.SkosResource(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: RdfBaseModel

Base class for SKOS resources.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_namespace: alias of SKOS

rdf_prefixes = {'skos': Namespace(Namespace('http://www.w3.org/2004/02/skos/core#'))}

SPDX: Software Package Data Exchange

SPDX (Software Package Data Exchange) vocabulary using Pydantic RDF models.

This module provides Pydantic-based models for the SPDX vocabulary, allowing easy serialization to and from RDF formats.

References: - https://spdx.github.io/spdx-spec/ - https://spdx.org/rdf/terms/

class dartfx.rdf.pydantic.spdx.Annotation(*, rdf_uri_generator: RdfUriGenerator = <factory>, annotator: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#annotator, datatype=None, language=None, serializer=None, parser=None)] = None, annotation_date: datetime] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#annotationDate, datatype=None, language=None, serializer=None, parser=None)] = None, annotation_type: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#annotationType, datatype=None, language=None, serializer=None, parser=None)] = None, comment: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#comment, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: SpdxResource

An SPDX Annotation.

annotation_date: Annotated[str | datetime | list[str | datetime] | None, RdfProperty(SPDX.annotationDate)]

annotation_type: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.annotationType)]

annotator: Annotated[str | list[str] | None, RdfProperty(SPDX.annotator)]

comment: Annotated[LocalizedStr | None, RdfProperty(SPDX.comment)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://spdx.org/rdf/terms#Annotation'

class dartfx.rdf.pydantic.spdx.Checksum(*, rdf_uri_generator: RdfUriGenerator = <factory>, algorithm: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#algorithm, datatype=None, language=None, serializer=None, parser=None)] = None, checksum_value: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#checksumValue, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: SpdxResource

An SPDX Checksum.

algorithm: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.algorithm)]

checksum_value: Annotated[str | list[str] | None, RdfProperty(SPDX.checksumValue)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://spdx.org/rdf/terms#Checksum'

class dartfx.rdf.pydantic.spdx.ConjunctiveLicenseSet(*, rdf_uri_generator: RdfUriGenerator = <factory>, license_id: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#licenseId, datatype=None, language=None, serializer=None, parser=None)] = None, name: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#name, datatype=None, language=None, serializer=None, parser=None)] = None, license_text: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#licenseText, datatype=None, language=None, serializer=None, parser=None)] = None, see_also: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#seeAlso, datatype=None, language=None, serializer=None, parser=None)] = None, comment: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#comment, datatype=None, language=None, serializer=None, parser=None)] = None, member: License] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#member, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: License

An SPDX Conjunctive License Set.

member: Annotated[str | URIRef | License | list[str | URIRef | License] | None, RdfProperty(SPDX.member)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://spdx.org/rdf/terms#ConjunctiveLicenseSet'

class dartfx.rdf.pydantic.spdx.CreationInfo(*, rdf_uri_generator: RdfUriGenerator = <factory>, created: datetime] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#created, datatype=None, language=None, serializer=None, parser=None)] = None, creator: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#creator, datatype=None, language=None, serializer=None, parser=None)] = None, license_list_version: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#licenseListVersion, datatype=None, language=None, serializer=None, parser=None)] = None, comment: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#comment, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: SpdxResource

SPDX Creation Info.

comment: Annotated[LocalizedStr | None, RdfProperty(SPDX.comment)]

created: Annotated[str | datetime | list[str | datetime] | None, RdfProperty(SPDX.created)]

creator: Annotated[str | list[str] | None, RdfProperty(SPDX.creator)]

license_list_version: Annotated[str | list[str] | None, RdfProperty(SPDX.licenseListVersion)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://spdx.org/rdf/terms#CreationInfo'

class dartfx.rdf.pydantic.spdx.DisjunctiveLicenseSet(*, rdf_uri_generator: RdfUriGenerator = <factory>, license_id: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#licenseId, datatype=None, language=None, serializer=None, parser=None)] = None, name: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#name, datatype=None, language=None, serializer=None, parser=None)] = None, license_text: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#licenseText, datatype=None, language=None, serializer=None, parser=None)] = None, see_also: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#seeAlso, datatype=None, language=None, serializer=None, parser=None)] = None, comment: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#comment, datatype=None, language=None, serializer=None, parser=None)] = None, member: License] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#member, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: License

An SPDX Disjunctive License Set.

member: Annotated[str | URIRef | License | list[str | URIRef | License] | None, RdfProperty(SPDX.member)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://spdx.org/rdf/terms#DisjunctiveLicenseSet'

class dartfx.rdf.pydantic.spdx.ExternalDocumentRef(*, rdf_uri_generator: RdfUriGenerator = <factory>, external_document_id: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#externalDocumentId, datatype=None, language=None, serializer=None, parser=None)] = None, spdx_document: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#spdxDocument, datatype=None, language=None, serializer=None, parser=None)] = None, checksum: Checksum] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#checksum, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: SpdxResource

An SPDX External Document Reference.

checksum: Annotated[str | URIRef | Checksum | list[str | URIRef | Checksum] | None, RdfProperty(SPDX.checksum)]

external_document_id: Annotated[str | list[str] | None, RdfProperty(SPDX.externalDocumentId)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://spdx.org/rdf/terms#ExternalDocumentRef'

spdx_document: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.spdxDocument)]

class dartfx.rdf.pydantic.spdx.ExternalRef(*, rdf_uri_generator: RdfUriGenerator = <factory>, reference_category: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#referenceCategory, datatype=None, language=None, serializer=None, parser=None)] = None, reference_type: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#referenceType, datatype=None, language=None, serializer=None, parser=None)] = None, reference_locator: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#referenceLocator, datatype=None, language=None, serializer=None, parser=None)] = None, comment: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#comment, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: SpdxResource

An SPDX External Reference.

comment: Annotated[LocalizedStr | None, RdfProperty(SPDX.comment)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://spdx.org/rdf/terms#ExternalRef'

reference_category: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.referenceCategory)]

reference_locator: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.referenceLocator)]

reference_type: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.referenceType)]

class dartfx.rdf.pydantic.spdx.ExtractedLicensingInfo(*, rdf_uri_generator: RdfUriGenerator = <factory>, license_id: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#licenseId, datatype=None, language=None, serializer=None, parser=None)] = None, name: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#name, datatype=None, language=None, serializer=None, parser=None)] = None, license_text: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#licenseText, datatype=None, language=None, serializer=None, parser=None)] = None, see_also: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#seeAlso, datatype=None, language=None, serializer=None, parser=None)] = None, comment: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#comment, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: License

An SPDX Extracted Licensing Info.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://spdx.org/rdf/terms#ExtractedLicensingInfo'

class dartfx.rdf.pydantic.spdx.File(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: SpdxResource

An SPDX File.

artifact_of: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.artifactOf)]

attribution_text: Annotated[LocalizedStr | None, RdfProperty(SPDX.attributionText)]

checksum: Annotated[str | URIRef | Checksum | list[str | URIRef | Checksum] | None, RdfProperty(SPDX.checksum)]

comment: Annotated[LocalizedStr | None, RdfProperty(SPDX.comment)]

copyright_text: Annotated[LocalizedStr | None, RdfProperty(SPDX.copyrightText)]

file_contributor: Annotated[str | list[str] | None, RdfProperty(SPDX.fileContributor)]

file_dependency: Annotated[str | URIRef | File | list[str | URIRef | File] | None, RdfProperty(SPDX.fileDependency)]

file_name: Annotated[str | list[str] | None, RdfProperty(SPDX.fileName)]

file_type: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.fileType)]

license_comments: Annotated[LocalizedStr | None, RdfProperty(SPDX.licenseComments)]

license_concluded: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.licenseConcluded)]

license_info_in_file: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.licenseInfoInFile)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

notice_text: Annotated[LocalizedStr | None, RdfProperty(SPDX.noticeText)]

rdf_type: ClassVar[str | URIRef | None] = 'http://spdx.org/rdf/terms#File'

class dartfx.rdf.pydantic.spdx.FileType(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: SpdxResource

An SPDX File Type.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://spdx.org/rdf/terms#FileType'

class dartfx.rdf.pydantic.spdx.License(*, rdf_uri_generator: RdfUriGenerator = <factory>, license_id: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#licenseId, datatype=None, language=None, serializer=None, parser=None)] = None, name: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#name, datatype=None, language=None, serializer=None, parser=None)] = None, license_text: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#licenseText, datatype=None, language=None, serializer=None, parser=None)] = None, see_also: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#seeAlso, datatype=None, language=None, serializer=None, parser=None)] = None, comment: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#comment, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: SpdxResource

Base class for SPDX Licenses.

comment: Annotated[LocalizedStr | None, RdfProperty(SPDX.comment)]

license_id: Annotated[str | list[str] | None, RdfProperty(SPDX.licenseId)]

license_text: Annotated[LocalizedStr | None, RdfProperty(SPDX.licenseText)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: Annotated[LocalizedStr | None, RdfProperty(SPDX.name)]

see_also: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.seeAlso)]

class dartfx.rdf.pydantic.spdx.LicenseException(*, rdf_uri_generator: RdfUriGenerator = <factory>, license_exception_id: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#licenseExceptionId, datatype=None, language=None, serializer=None, parser=None)] = None, name: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#name, datatype=None, language=None, serializer=None, parser=None)] = None, license_exception_text: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#licenseExceptionText, datatype=None, language=None, serializer=None, parser=None)] = None, license_exception_template: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#licenseExceptionTemplate, datatype=None, language=None, serializer=None, parser=None)] = None, see_also: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#seeAlso, datatype=None, language=None, serializer=None, parser=None)] = None, comment: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#comment, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: SpdxResource

An SPDX License Exception.

comment: Annotated[LocalizedStr | None, RdfProperty(SPDX.comment)]

license_exception_id: Annotated[str | list[str] | None, RdfProperty(SPDX.licenseExceptionId)]

license_exception_template: Annotated[LocalizedStr | None, RdfProperty(SPDX.licenseExceptionTemplate)]

license_exception_text: Annotated[LocalizedStr | None, RdfProperty(SPDX.licenseExceptionText)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: Annotated[LocalizedStr | None, RdfProperty(SPDX.name)]

rdf_type: ClassVar[str | URIRef | None] = 'http://spdx.org/rdf/terms#LicenseException'

see_also: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.seeAlso)]

class dartfx.rdf.pydantic.spdx.OrLaterOperator(*, rdf_uri_generator: RdfUriGenerator = <factory>, license_id: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#licenseId, datatype=None, language=None, serializer=None, parser=None)] = None, name: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#name, datatype=None, language=None, serializer=None, parser=None)] = None, license_text: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#licenseText, datatype=None, language=None, serializer=None, parser=None)] = None, see_also: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#seeAlso, datatype=None, language=None, serializer=None, parser=None)] = None, comment: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#comment, datatype=None, language=None, serializer=None, parser=None)] = None, member: License] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#member, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: License

An SPDX Or Later Operator.

member: Annotated[str | URIRef | License | list[str | URIRef | License] | None, RdfProperty(SPDX.member)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://spdx.org/rdf/terms#OrLaterOperator'

class dartfx.rdf.pydantic.spdx.Package(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: SpdxResource

An SPDX Package.

attribution_text: Annotated[LocalizedStr | None, RdfProperty(SPDX.attributionText)]

checksum: Annotated[str | URIRef | Checksum | list[str | URIRef | Checksum] | None, RdfProperty(SPDX.checksum)]

comment: Annotated[LocalizedStr | None, RdfProperty(SPDX.comment)]

copyright_text: Annotated[LocalizedStr | None, RdfProperty(SPDX.copyrightText)]

description: Annotated[LocalizedStr | None, RdfProperty(SPDX.description)]

download_location: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.downloadLocation)]

external_ref: Annotated[str | URIRef | ExternalRef | list[str | URIRef | ExternalRef] | None, RdfProperty(SPDX.externalRef)]

has_file: Annotated[str | URIRef | File | list[str | URIRef | File] | None, RdfProperty(SPDX.hasFile)]

homepage: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.homepage)]

license_comments: Annotated[LocalizedStr | None, RdfProperty(SPDX.licenseComments)]

license_concluded: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.licenseConcluded)]

license_declared: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.licenseDeclared)]

license_info_from_files: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.licenseInfoFromFiles)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: Annotated[LocalizedStr | None, RdfProperty(SPDX.name)]

originator: Annotated[str | list[str] | None, RdfProperty(SPDX.originator)]

package_file_name: Annotated[str | list[str] | None, RdfProperty(SPDX.packageFileName)]

package_verification_code: Annotated[str | URIRef | PackageVerificationCode | list[str | URIRef | PackageVerificationCode] | None, RdfProperty(SPDX.packageVerificationCode)]

primary_package_purpose: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.primaryPackagePurpose)]

rdf_type: ClassVar[str | URIRef | None] = 'http://spdx.org/rdf/terms#Package'

source_info: Annotated[LocalizedStr | None, RdfProperty(SPDX.sourceInfo)]

summary: Annotated[LocalizedStr | None, RdfProperty(SPDX.summary)]

supplier: Annotated[str | list[str] | None, RdfProperty(SPDX.supplier)]

version_info: Annotated[str | list[str] | None, RdfProperty(SPDX.versionInfo)]

class dartfx.rdf.pydantic.spdx.PackageVerificationCode(*, rdf_uri_generator: RdfUriGenerator = <factory>, package_verification_code_value: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#packageVerificationCodeValue, datatype=None, language=None, serializer=None, parser=None)] = None, package_verification_code_excluded_file: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#packageVerificationCodeExcludedFile, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: SpdxResource

An SPDX Package Verification Code.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

package_verification_code_excluded_file: Annotated[str | list[str] | None, RdfProperty(SPDX.packageVerificationCodeExcludedFile)]

package_verification_code_value: Annotated[str | list[str] | None, RdfProperty(SPDX.packageVerificationCodeValue)]

rdf_type: ClassVar[str | URIRef | None] = 'http://spdx.org/rdf/terms#PackageVerificationCode'

class dartfx.rdf.pydantic.spdx.ReferenceType(*, rdf_uri_generator: RdfUriGenerator = <factory>, contextual_example: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#contextualExample, datatype=None, language=None, serializer=None, parser=None)] = None, external_reference_site: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#externalReferenceSite, datatype=None, language=None, serializer=None, parser=None)] = None, documentation: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#documentation, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: SpdxResource

An SPDX Reference Type.

contextual_example: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.contextualExample)]

documentation: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.documentation)]

external_reference_site: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.externalReferenceSite)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://spdx.org/rdf/terms#ReferenceType'

class dartfx.rdf.pydantic.spdx.Relationship(*, rdf_uri_generator: RdfUriGenerator = <factory>, relationship_type: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#relationshipType, datatype=None, language=None, serializer=None, parser=None)] = None, related_spdx_element: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#relatedSpdxElement, datatype=None, language=None, serializer=None, parser=None)] = None, comment: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#comment, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: SpdxResource

An SPDX Relationship.

comment: Annotated[LocalizedStr | None, RdfProperty(SPDX.comment)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://spdx.org/rdf/terms#Relationship'

related_spdx_element: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.relatedSpdxElement)]

relationship_type: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.relationshipType)]

class dartfx.rdf.pydantic.spdx.Review(*, rdf_uri_generator: RdfUriGenerator = <factory>, reviewer: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#reviewer, datatype=None, language=None, serializer=None, parser=None)] = None, review_date: datetime] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#reviewDate, datatype=None, language=None, serializer=None, parser=None)] = None, comment: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#comment, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: SpdxResource

An SPDX Review.

comment: Annotated[LocalizedStr | None, RdfProperty(SPDX.comment)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://spdx.org/rdf/terms#Review'

review_date: Annotated[str | datetime | list[str | datetime] | None, RdfProperty(SPDX.reviewDate)]

reviewer: Annotated[str | list[str] | None, RdfProperty(SPDX.reviewer)]

class dartfx.rdf.pydantic.spdx.SimpleLicensingInfo(*, rdf_uri_generator: RdfUriGenerator = <factory>, license_id: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#licenseId, datatype=None, language=None, serializer=None, parser=None)] = None, name: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#name, datatype=None, language=None, serializer=None, parser=None)] = None, license_text: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#licenseText, datatype=None, language=None, serializer=None, parser=None)] = None, see_also: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#seeAlso, datatype=None, language=None, serializer=None, parser=None)] = None, comment: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#comment, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: License

An SPDX Simple Licensing Info.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://spdx.org/rdf/terms#SimpleLicensingInfo'

class dartfx.rdf.pydantic.spdx.Snippet(*, rdf_uri_generator: RdfUriGenerator = <factory>, snippet_from_file: File] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#snippetFromFile, datatype=None, language=None, serializer=None, parser=None)] = None, snippet_byte_range: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#snippetByteRange, datatype=None, language=None, serializer=None, parser=None)] = None, snippet_line_range: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#snippetLineRange, datatype=None, language=None, serializer=None, parser=None)] = None, license_info_in_snippet: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#licenseInfoInSnippet, datatype=None, language=None, serializer=None, parser=None)] = None, license_concluded: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#licenseConcluded, datatype=None, language=None, serializer=None, parser=None)] = None, copyright_text: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#copyrightText, datatype=None, language=None, serializer=None, parser=None)] = None, comment: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#comment, datatype=None, language=None, serializer=None, parser=None)] = None, name: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#name, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: SpdxResource

An SPDX Snippet.

comment: Annotated[LocalizedStr | None, RdfProperty(SPDX.comment)]

copyright_text: Annotated[LocalizedStr | None, RdfProperty(SPDX.copyrightText)]

license_concluded: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.licenseConcluded)]

license_info_in_snippet: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.licenseInfoInSnippet)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: Annotated[LocalizedStr | None, RdfProperty(SPDX.name)]

rdf_type: ClassVar[str | URIRef | None] = 'http://spdx.org/rdf/terms#Snippet'

snippet_byte_range: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.snippetByteRange)]

snippet_from_file: Annotated[str | URIRef | File | list[str | URIRef | File] | None, RdfProperty(SPDX.snippetFromFile)]

snippet_line_range: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.snippetLineRange)]

class dartfx.rdf.pydantic.spdx.SpdxDocument(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: SpdxResource

An SPDX Document.

annotation: Annotated[str | URIRef | Annotation | list[str | URIRef | Annotation] | None, RdfProperty(SPDX.annotation)]

comment: Annotated[LocalizedStr | None, RdfProperty(SPDX.comment)]

creation_info: Annotated[str | URIRef | CreationInfo | list[str | URIRef | CreationInfo] | None, RdfProperty(SPDX.creationInfo)]

data_license: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.dataLicense)]

describes_package: Annotated[str | URIRef | Package | list[str | URIRef | Package] | None, RdfProperty(SPDX.describesPackage)]

document_namespace: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SPDX.documentNamespace)]

external_document_ref: Annotated[str | URIRef | ExternalDocumentRef | list[str | URIRef | ExternalDocumentRef] | None, RdfProperty(SPDX.externalDocumentRef)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: Annotated[LocalizedStr | None, RdfProperty(SPDX.name)]

rdf_type: ClassVar[str | URIRef | None] = 'http://spdx.org/rdf/terms#SpdxDocument'

relationship: Annotated[str | URIRef | Relationship | list[str | URIRef | Relationship] | None, RdfProperty(SPDX.relationship)]

spdx_version: Annotated[str | list[str] | None, RdfProperty(SPDX.spdxVersion)]

class dartfx.rdf.pydantic.spdx.SpdxResource(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: RdfBaseModel

Base class for SPDX resources.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_namespace: ClassVar = Namespace('http://spdx.org/rdf/terms#')

rdf_prefixes: ClassVar = {'spdx': Namespace('http://spdx.org/rdf/terms#')}

class dartfx.rdf.pydantic.spdx.WithExceptionOperator(*, rdf_uri_generator: RdfUriGenerator = <factory>, license_id: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#licenseId, datatype=None, language=None, serializer=None, parser=None)] = None, name: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#name, datatype=None, language=None, serializer=None, parser=None)] = None, license_text: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#licenseText, datatype=None, language=None, serializer=None, parser=None)] = None, see_also: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#seeAlso, datatype=None, language=None, serializer=None, parser=None)] = None, comment: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#comment, datatype=None, language=None, serializer=None, parser=None)] = None, member: License] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#member, datatype=None, language=None, serializer=None, parser=None)] = None, license_exception: LicenseException] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://spdx.org/rdf/terms#licenseException, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: License

An SPDX With Exception Operator.

license_exception: Annotated[str | URIRef | LicenseException | list[str | URIRef | LicenseException] | None, RdfProperty(SPDX.licenseException)]

member: Annotated[str | URIRef | License | list[str | URIRef | License] | None, RdfProperty(SPDX.member)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://spdx.org/rdf/terms#WithExceptionOperator'

VCARD: vCard / Virtual Contact File

VCARD vocabulary using Pydantic RDF models.

This module provides Pydantic-based models for the vCard ontology, allowing easy serialization to and from RDF formats.

References: - https://www.w3.org/TR/vcard-rdf/ - https://www.w3.org/2006/vcard/ns

class dartfx.rdf.pydantic.vcard.Acquaintance(*, rdf_uri_generator: RdfUriGenerator = <factory>, has_value: VCard] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#hasValue, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: Related

An acquaintance.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#Acquaintance'

class dartfx.rdf.pydantic.vcard.Address(*, rdf_uri_generator: RdfUriGenerator = <factory>, street_address: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#street-address, datatype=None, language=None, serializer=None, parser=None)] = None, locality: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#locality, datatype=None, language=None, serializer=None, parser=None)] = None, region: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#region, datatype=None, language=None, serializer=None, parser=None)] = None, postal_code: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#postal-code, datatype=None, language=None, serializer=None, parser=None)] = None, country_name: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#country-name, datatype=None, language=None, serializer=None, parser=None)] = None, post_office_box: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#post-office-box, datatype=None, language=None, serializer=None, parser=None)] = None, extended_address: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#extended-address, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: VcardResource

A delivery address.

country_name: Annotated[LocalizedStr | None, RdfProperty(VCARD['country-name'])]

extended_address: Annotated[LocalizedStr | None, RdfProperty(VCARD['extended-address'])]

locality: Annotated[LocalizedStr | None, RdfProperty(VCARD.locality)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

post_office_box: Annotated[str | list[str] | None, RdfProperty(VCARD['post-office-box'])]

postal_code: Annotated[str | list[str] | None, RdfProperty(VCARD['postal-code'])]

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#Address'

region: Annotated[LocalizedStr | None, RdfProperty(VCARD.region)]

street_address: Annotated[LocalizedStr | None, RdfProperty(VCARD['street-address'])]

class dartfx.rdf.pydantic.vcard.AddressType(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: VcardResource

Address type classifications.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class dartfx.rdf.pydantic.vcard.Agent(*, rdf_uri_generator: RdfUriGenerator = <factory>, has_value: VCard] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#hasValue, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: Related

An agent.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#Agent'

class dartfx.rdf.pydantic.vcard.Child(*, rdf_uri_generator: RdfUriGenerator = <factory>, has_value: VCard] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#hasValue, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: Related

A child.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#Child'

class dartfx.rdf.pydantic.vcard.CoResident(*, rdf_uri_generator: RdfUriGenerator = <factory>, has_value: VCard] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#hasValue, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: Related

A co-resident.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#CoResident'

class dartfx.rdf.pydantic.vcard.Colleague(*, rdf_uri_generator: RdfUriGenerator = <factory>, has_value: VCard] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#hasValue, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: Related

A colleague.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#Colleague'

class dartfx.rdf.pydantic.vcard.Coworker(*, rdf_uri_generator: RdfUriGenerator = <factory>, has_value: VCard] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#hasValue, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: Related

A coworker.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#Coworker'

class dartfx.rdf.pydantic.vcard.Email(*, rdf_uri_generator: RdfUriGenerator = <factory>, has_value: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#hasValue, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: VcardResource

An email address.

has_value: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(VCARD.hasValue)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#Email'

class dartfx.rdf.pydantic.vcard.EmailType(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: VcardResource

Email type classifications.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class dartfx.rdf.pydantic.vcard.Emergency(*, rdf_uri_generator: RdfUriGenerator = <factory>, has_value: VCard] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#hasValue, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: Related

An emergency contact.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#Emergency'

class dartfx.rdf.pydantic.vcard.Friend(*, rdf_uri_generator: RdfUriGenerator = <factory>, has_value: VCard] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#hasValue, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: Related

A friend.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#Friend'

class dartfx.rdf.pydantic.vcard.Gender(*, rdf_uri_generator: RdfUriGenerator = <factory>, sex: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#sex, datatype=None, language=None, serializer=None, parser=None)] = None, identity: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#identity, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: VcardResource

A gender.

identity: Annotated[LocalizedStr | None, RdfProperty(VCARD.identity)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#Gender'

sex: Annotated[LocalizedStr | None, RdfProperty(VCARD.sex)]

class dartfx.rdf.pydantic.vcard.Group(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: VCard

A group of persons or entities.

has_member: Annotated[str | URIRef | VCard | list[str | URIRef | VCard] | None, RdfProperty(VCARD.hasMember)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#Group'

class dartfx.rdf.pydantic.vcard.Individual(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: VCard

An individual person.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#Individual'

class dartfx.rdf.pydantic.vcard.Kin(*, rdf_uri_generator: RdfUriGenerator = <factory>, has_value: VCard] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#hasValue, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: Related

A kin.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#Kin'

class dartfx.rdf.pydantic.vcard.Kind(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: VcardResource

A kind of vCard.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#Kind'

class dartfx.rdf.pydantic.vcard.Location(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: VCard

A location.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#Location'

class dartfx.rdf.pydantic.vcard.Name(*, rdf_uri_generator: RdfUriGenerator = <factory>, family_name: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#family-name, datatype=None, language=None, serializer=None, parser=None)] = None, given_name: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#given-name, datatype=None, language=None, serializer=None, parser=None)] = None, additional_name: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#additional-name, datatype=None, language=None, serializer=None, parser=None)] = None, honorific_prefix: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#honorific-prefix, datatype=None, language=None, serializer=None, parser=None)] = None, honorific_suffix: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#honorific-suffix, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: VcardResource

A name component.

additional_name: Annotated[LocalizedStr | None, RdfProperty(VCARD['additional-name'])]

family_name: Annotated[LocalizedStr | None, RdfProperty(VCARD['family-name'])]

given_name: Annotated[LocalizedStr | None, RdfProperty(VCARD['given-name'])]

honorific_prefix: Annotated[LocalizedStr | None, RdfProperty(VCARD['honorific-prefix'])]

honorific_suffix: Annotated[LocalizedStr | None, RdfProperty(VCARD['honorific-suffix'])]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#Name'

class dartfx.rdf.pydantic.vcard.Neighbor(*, rdf_uri_generator: RdfUriGenerator = <factory>, has_value: VCard] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#hasValue, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: Related

A neighbor.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#Neighbor'

class dartfx.rdf.pydantic.vcard.Organization(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: VCard

An organization.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#Organization'

class dartfx.rdf.pydantic.vcard.Parent(*, rdf_uri_generator: RdfUriGenerator = <factory>, has_value: VCard] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#hasValue, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: Related

A parent.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#Parent'

class dartfx.rdf.pydantic.vcard.Related(*, rdf_uri_generator: RdfUriGenerator = <factory>, has_value: VCard] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#hasValue, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: VcardResource

A related entity.

has_value: Annotated[str | URIRef | VCard | list[str | URIRef | VCard] | None, RdfProperty(VCARD.hasValue)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#Related'

class dartfx.rdf.pydantic.vcard.Sibling(*, rdf_uri_generator: RdfUriGenerator = <factory>, has_value: VCard] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#hasValue, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: Related

A sibling.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#Sibling'

class dartfx.rdf.pydantic.vcard.Spouse(*, rdf_uri_generator: RdfUriGenerator = <factory>, has_value: VCard] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#hasValue, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: Related

A spouse.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#Spouse'

class dartfx.rdf.pydantic.vcard.Telephone(*, rdf_uri_generator: RdfUriGenerator = <factory>, has_value: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2006/vcard/ns#hasValue, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: VcardResource

A telephone number.

has_value: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(VCARD.hasValue)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#Telephone'

class dartfx.rdf.pydantic.vcard.TelephoneType(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: VcardResource

Telephone type classifications.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class dartfx.rdf.pydantic.vcard.Type(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: VcardResource

A property type.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#Type'

class dartfx.rdf.pydantic.vcard.VCard(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: VcardResource

A vCard - electronic business card.

adr: Annotated[str | URIRef | Address | list[str | URIRef | Address] | None, RdfProperty(VCARD.adr)]

bday: Annotated[str | list[str] | None, RdfProperty(VCARD.bday)]

category: Annotated[LocalizedStr | None, RdfProperty(VCARD.category)]

email: Annotated[str | URIRef | Email | list[str | URIRef | Email] | None, RdfProperty(VCARD.email)]

fn: Annotated[LocalizedStr | None, RdfProperty(VCARD.fn)]

has_email: Annotated[str | URIRef | Email | list[str | URIRef | Email] | None, RdfProperty(VCARD.hasEmail)]

has_gender: Annotated[str | URIRef | Gender | list[str | URIRef | Gender] | None, RdfProperty(VCARD.hasGender)]

has_geo: Annotated[str | URIRef | Location | list[str | URIRef | Location] | None, RdfProperty(VCARD.hasGeo)]

has_key: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(VCARD.hasKey)]

has_language: Annotated[str | list[str] | None, RdfProperty(VCARD.hasLanguage)]

has_logo: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(VCARD.hasLogo)]

has_note: Annotated[LocalizedStr | None, RdfProperty(VCARD.hasNote)]

has_photo: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(VCARD.hasPhoto)]

has_related: Annotated[str | URIRef | Related | list[str | URIRef | Related] | None, RdfProperty(VCARD.hasRelated)]

has_sound: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(VCARD.hasSound)]

has_telephone: Annotated[str | URIRef | Telephone | list[str | URIRef | Telephone] | None, RdfProperty(VCARD.hasTelephone)]

has_uid: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(VCARD.hasUID)]

has_url: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(VCARD.hasUrl)]

language: Annotated[str | list[str] | None, RdfProperty(VCARD.language)]

logo: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(VCARD.logo)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

n: Annotated[str | URIRef | Name | list[str | URIRef | Name] | None, RdfProperty(VCARD.n)]

nickname: Annotated[LocalizedStr | None, RdfProperty(VCARD.nickname)]

note: Annotated[LocalizedStr | None, RdfProperty(VCARD.note)]

org: Annotated[str | URIRef | Organization | list[str | URIRef | Organization] | None, RdfProperty(VCARD.org)]

organization_name: Annotated[LocalizedStr | None, RdfProperty(VCARD['organization-name'])]

organization_unit: Annotated[LocalizedStr | None, RdfProperty(VCARD['organization-unit'])]

photo: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(VCARD.photo)]

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2006/vcard/ns#VCard'

rev: Annotated[str | list[str] | None, RdfProperty(VCARD.rev)]

role: Annotated[LocalizedStr | None, RdfProperty(VCARD.role)]

tel: Annotated[str | URIRef | Telephone | list[str | URIRef | Telephone] | None, RdfProperty(VCARD.tel)]

title: Annotated[LocalizedStr | None, RdfProperty(VCARD.title)]

uid: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(VCARD.uid)]

url: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(VCARD.url)]

class dartfx.rdf.pydantic.vcard.VcardResource(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: RdfBaseModel

Base class for vCard resources.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_namespace: ClassVar = Namespace('http://www.w3.org/2006/vcard/ns#')

rdf_prefixes: ClassVar = {'vcard': Namespace('http://www.w3.org/2006/vcard/ns#')}

XKOS: SKOS extension for representing statistical classifications

XKOS (Extended Knowledge Organization System) vocabulary using Pydantic RDF models.

This module provides Pydantic-based models for the XKOS vocabulary, which extends SKOS for statistical classifications.

References: - http://rdf-vocabulary.ddialliance.org/xkos.html - https://rdf-vocabulary.ddialliance.org/xkos

class dartfx.rdf.pydantic.xkos.ClassificationLevel(*, rdf_uri_generator: RdfUriGenerator = <factory>, depth: Annotated[int | list[int] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#depth, datatype=None, language=None, serializer=None, parser=None)] = None, notations_equal: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#notationsEqual, datatype=None, language=None, serializer=None, parser=None)] = None, organizes: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#organizes, datatype=None, language=None, serializer=None, parser=None)] = None, covers: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#covers, datatype=None, language=None, serializer=None, parser=None)] = None, covers_exhaustively: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#coversExhaustively, datatype=None, language=None, serializer=None, parser=None)] = None, covers_mutually_exclusively: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#coversMutuallyExclusively, datatype=None, language=None, serializer=None, parser=None)] = None, organized_by: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#organizedBy, datatype=None, language=None, serializer=None, parser=None)] = None, notation_pattern: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#notationPattern, datatype=None, language=None, serializer=None, parser=None)] = None, max_length: Annotated[int | list[int] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#maxLength, datatype=None, language=None, serializer=None, parser=None)] = None, pref_label: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#prefLabel, datatype=None, language=None, serializer=None, parser=None)] = None, alt_label: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#altLabel, datatype=None, language=None, serializer=None, parser=None)] = None, note: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#note, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: XkosResource

An XKOS Classification Level - a level in a statistical classification.

alt_label: Annotated[LocalizedStr | None, RdfProperty(SKOS.altLabel)]

covers: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(XKOS.covers)]

covers_exhaustively: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(XKOS.coversExhaustively)]

covers_mutually_exclusively: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(XKOS.coversMutuallyExclusively)]

depth: Annotated[int | list[int] | None, RdfProperty(XKOS.depth)]

max_length: Annotated[int | list[int] | None, RdfProperty(XKOS.maxLength)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

notation_pattern: Annotated[str | list[str] | None, RdfProperty(XKOS.notationPattern)]

notations_equal: Annotated[str | list[str] | None, RdfProperty(XKOS.notationsEqual)]

note: Annotated[LocalizedStr | None, RdfProperty(SKOS.note)]

organized_by: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(XKOS.organizedBy)]

organizes: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(XKOS.organizes)]

pref_label: Annotated[LocalizedStr | None, RdfProperty(SKOS.prefLabel)]

rdf_type: ClassVar[str | URIRef | None] = 'http://rdf-vocabulary.ddialliance.org/xkos#ClassificationLevel'

class dartfx.rdf.pydantic.xkos.ConceptAssociation(*, rdf_uri_generator: RdfUriGenerator = <factory>, source_concept: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#sourceConcept, datatype=None, language=None, serializer=None, parser=None)] = None, target_concept: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#targetConcept, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: XkosResource

An XKOS Concept Association - a relationship between concepts in different classifications.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_type: ClassVar[str | URIRef | None] = 'http://rdf-vocabulary.ddialliance.org/xkos#ConceptAssociation'

source_concept: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(XKOS.sourceConcept)]

target_concept: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(XKOS.targetConcept)]

class dartfx.rdf.pydantic.xkos.Correspondence(*, rdf_uri_generator: RdfUriGenerator = <factory>, compares: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#compares, datatype=None, language=None, serializer=None, parser=None)] = None, pref_label: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#prefLabel, datatype=None, language=None, serializer=None, parser=None)] = None, alt_label: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#altLabel, datatype=None, language=None, serializer=None, parser=None)] = None, definition: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#definition, datatype=None, language=None, serializer=None, parser=None)] = None, made_of: ConceptAssociation] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#madeOf, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: XkosResource

An XKOS Correspondence - a mapping between two classifications.

alt_label: Annotated[LocalizedStr | None, RdfProperty(SKOS.altLabel)]

compares: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(XKOS.compares)]

definition: Annotated[LocalizedStr | None, RdfProperty(SKOS.definition)]

made_of: Annotated[str | URIRef | ConceptAssociation | list[str | URIRef | ConceptAssociation] | None, RdfProperty(XKOS.madeOf)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

pref_label: Annotated[LocalizedStr | None, RdfProperty(SKOS.prefLabel)]

rdf_type: ClassVar[str | URIRef | None] = 'http://rdf-vocabulary.ddialliance.org/xkos#Correspondence'

class dartfx.rdf.pydantic.xkos.ExplanatoryNote(*, rdf_uri_generator: RdfUriGenerator = <factory>, plain_text: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#plainText, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: XkosResource

An XKOS Explanatory Note - additional documentation for a concept.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

plain_text: Annotated[LocalizedStr | None, RdfProperty(XKOS.plainText)]

rdf_type: ClassVar[str | URIRef | None] = 'http://rdf-vocabulary.ddialliance.org/xkos#ExplanatoryNote'

class dartfx.rdf.pydantic.xkos.StatisticalClassification(*, rdf_uri_generator: RdfUriGenerator = <factory>, pref_label: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#prefLabel, datatype=None, language=None, serializer=None, parser=None)] = None, alt_label: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#altLabel, datatype=None, language=None, serializer=None, parser=None)] = None, definition: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#definition, datatype=None, language=None, serializer=None, parser=None)] = None, scope_note: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#scopeNote, datatype=None, language=None, serializer=None, parser=None)] = None, has_top_concept: StatisticalConcept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#hasTopConcept, datatype=None, language=None, serializer=None, parser=None)] = None, number_of_levels: Annotated[int | list[int] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#numberOfLevels, datatype=None, language=None, serializer=None, parser=None)] = None, has_level: ClassificationLevel] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#levels, datatype=None, language=None, serializer=None, parser=None)] = None, variant: StatisticalClassification] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#variant, datatype=None, language=None, serializer=None, parser=None)] = None, belongs_to: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#belongsTo, datatype=None, language=None, serializer=None, parser=None)] = None, follows: StatisticalClassification] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#follows, datatype=None, language=None, serializer=None, parser=None)] = None, supersedes: StatisticalClassification] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#supersedes, datatype=None, language=None, serializer=None, parser=None)] = None, succeeds: StatisticalClassification] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#succeeds, datatype=None, language=None, serializer=None, parser=None)] = None, disjoint: StatisticalClassification] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#disjoint, datatype=None, language=None, serializer=None, parser=None)] = None, introduction: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#introduction, datatype=None, language=None, serializer=None, parser=None)] = None, editorial_note: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#editorialNote, datatype=None, language=None, serializer=None, parser=None)] = None, change_note: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#changeNote, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: XkosResource

A SKOS Concept Scheme representing a statistical classification.

alt_label: Annotated[LocalizedStr | None, RdfProperty(SKOS.altLabel)]

belongs_to: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(XKOS.belongsTo)]

change_note: Annotated[LocalizedStr | None, RdfProperty(XKOS.changeNote)]

definition: Annotated[LocalizedStr | None, RdfProperty(SKOS.definition)]

disjoint: Annotated[str | URIRef | StatisticalClassification | list[str | URIRef | StatisticalClassification] | None, RdfProperty(XKOS.disjoint)]

editorial_note: Annotated[LocalizedStr | None, RdfProperty(XKOS.editorialNote)]

follows: Annotated[str | URIRef | StatisticalClassification | list[str | URIRef | StatisticalClassification] | None, RdfProperty(XKOS.follows)]

has_level: Annotated[str | URIRef | ClassificationLevel | list[str | URIRef | ClassificationLevel] | None, RdfProperty(XKOS.levels)]

has_top_concept: Annotated[str | URIRef | StatisticalConcept | list[str | URIRef | StatisticalConcept] | None, RdfProperty(SKOS.hasTopConcept)]

introduction: Annotated[LocalizedStr | None, RdfProperty(XKOS.introduction)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

number_of_levels: Annotated[int | list[int] | None, RdfProperty(XKOS.numberOfLevels)]

pref_label: Annotated[LocalizedStr | None, RdfProperty(SKOS.prefLabel)]

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2004/02/skos/core#ConceptScheme'

scope_note: Annotated[LocalizedStr | None, RdfProperty(SKOS.scopeNote)]

succeeds: Annotated[str | URIRef | StatisticalClassification | list[str | URIRef | StatisticalClassification] | None, RdfProperty(XKOS.succeeds)]

supersedes: Annotated[str | URIRef | StatisticalClassification | list[str | URIRef | StatisticalClassification] | None, RdfProperty(XKOS.supersedes)]

variant: Annotated[str | URIRef | StatisticalClassification | list[str | URIRef | StatisticalClassification] | None, RdfProperty(XKOS.variant)]

class dartfx.rdf.pydantic.xkos.StatisticalConcept(*, rdf_uri_generator: RdfUriGenerator = <factory>, pref_label: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#prefLabel, datatype=None, language=None, serializer=None, parser=None)] = None, alt_label: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#altLabel, datatype=None, language=None, serializer=None, parser=None)] = None, hidden_label: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#hiddenLabel, datatype=None, language=None, serializer=None, parser=None)] = None, notation: Annotated[str | list[str] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#notation, datatype=None, language=None, serializer=None, parser=None)] = None, definition: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#definition, datatype=None, language=None, serializer=None, parser=None)] = None, broader: StatisticalConcept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#broader, datatype=None, language=None, serializer=None, parser=None)] = None, narrower: StatisticalConcept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#narrower, datatype=None, language=None, serializer=None, parser=None)] = None, related: StatisticalConcept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#related, datatype=None, language=None, serializer=None, parser=None)] = None, in_scheme: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#inScheme, datatype=None, language=None, serializer=None, parser=None)] = None, top_concept_of: URIRef] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://www.w3.org/2004/02/skos/core#topConceptOf, datatype=None, language=None, serializer=None, parser=None)] = None, core_content_note: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#coreContentNote, datatype=None, language=None, serializer=None, parser=None)] = None, additional_content_note: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#additionalContentNote, datatype=None, language=None, serializer=None, parser=None)] = None, exclusion_note: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#exclusionNote, datatype=None, language=None, serializer=None, parser=None)] = None, inclusion_note: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#inclusionNote, datatype=None, language=None, serializer=None, parser=None)] = None, causal: StatisticalConcept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#causal, datatype=None, language=None, serializer=None, parser=None)] = None, causes: StatisticalConcept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#causes, datatype=None, language=None, serializer=None, parser=None)] = None, caused_by: StatisticalConcept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#causedBy, datatype=None, language=None, serializer=None, parser=None)] = None, sequential: StatisticalConcept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#sequential, datatype=None, language=None, serializer=None, parser=None)] = None, precedes: StatisticalConcept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#precedes, datatype=None, language=None, serializer=None, parser=None)] = None, follows: StatisticalConcept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#follows, datatype=None, language=None, serializer=None, parser=None)] = None, temporal: StatisticalConcept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#temporal, datatype=None, language=None, serializer=None, parser=None)] = None, before: StatisticalConcept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#before, datatype=None, language=None, serializer=None, parser=None)] = None, after: StatisticalConcept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#after, datatype=None, language=None, serializer=None, parser=None)] = None, is_part_of: StatisticalConcept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#isPartOf, datatype=None, language=None, serializer=None, parser=None)] = None, has_part: StatisticalConcept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#hasPart, datatype=None, language=None, serializer=None, parser=None)] = None, specializes: StatisticalConcept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#specializes, datatype=None, language=None, serializer=None, parser=None)] = None, generalizes: StatisticalConcept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#generalizes, datatype=None, language=None, serializer=None, parser=None)] = None, class_at: ClassificationLevel] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#classifiedUnder, datatype=None, language=None, serializer=None, parser=None)] = None, disjoint: StatisticalConcept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#disjoint, datatype=None, language=None, serializer=None, parser=None)] = None, broader_generic: StatisticalConcept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#broaderGeneric, datatype=None, language=None, serializer=None, parser=None)] = None, narrower_generic: StatisticalConcept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#narrowerGeneric, datatype=None, language=None, serializer=None, parser=None)] = None, broader_partitive: StatisticalConcept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#broaderPartitive, datatype=None, language=None, serializer=None, parser=None)] = None, narrower_partitive: StatisticalConcept] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#narrowerPartitive, datatype=None, language=None, serializer=None, parser=None)] = None, introduction: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#introduction, datatype=None, language=None, serializer=None, parser=None)] = None, editorial_note: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#editorialNote, datatype=None, language=None, serializer=None, parser=None)] = None, change_note: LangStringList, ~pydantic.functional_validators.BeforeValidator(func=~dartfx.rdf.pydantic._base._coerce_to_lang_string_list, json_schema_input_type=PydanticUndefined)] | None, ~dartfx.rdf.pydantic._base.RdfProperty(predicate=http://rdf-vocabulary.ddialliance.org/xkos#changeNote, datatype=None, language=None, serializer=None, parser=None)] = None)[source]

Bases: XkosResource

A SKOS Concept with XKOS extensions for statistical classifications.

additional_content_note: Annotated[LocalizedStr | None, RdfProperty(XKOS.additionalContentNote)]

after: Annotated[str | URIRef | StatisticalConcept | list[str | URIRef | StatisticalConcept] | None, RdfProperty(XKOS.after)]

alt_label: Annotated[LocalizedStr | None, RdfProperty(SKOS.altLabel)]

before: Annotated[str | URIRef | StatisticalConcept | list[str | URIRef | StatisticalConcept] | None, RdfProperty(XKOS.before)]

broader: Annotated[str | URIRef | StatisticalConcept | list[str | URIRef | StatisticalConcept] | None, RdfProperty(SKOS.broader)]

broader_generic: Annotated[str | URIRef | StatisticalConcept | list[str | URIRef | StatisticalConcept] | None, RdfProperty(XKOS.broaderGeneric)]

broader_partitive: Annotated[str | URIRef | StatisticalConcept | list[str | URIRef | StatisticalConcept] | None, RdfProperty(XKOS.broaderPartitive)]

causal: Annotated[str | URIRef | StatisticalConcept | list[str | URIRef | StatisticalConcept] | None, RdfProperty(XKOS.causal)]

caused_by: Annotated[str | URIRef | StatisticalConcept | list[str | URIRef | StatisticalConcept] | None, RdfProperty(XKOS.causedBy)]

causes: Annotated[str | URIRef | StatisticalConcept | list[str | URIRef | StatisticalConcept] | None, RdfProperty(XKOS.causes)]

change_note: Annotated[LocalizedStr | None, RdfProperty(XKOS.changeNote)]

class_at: Annotated[str | URIRef | ClassificationLevel | list[str | URIRef | ClassificationLevel] | None, RdfProperty(XKOS.classifiedUnder)]

core_content_note: Annotated[LocalizedStr | None, RdfProperty(XKOS.coreContentNote)]

definition: Annotated[LocalizedStr | None, RdfProperty(SKOS.definition)]

disjoint: Annotated[str | URIRef | StatisticalConcept | list[str | URIRef | StatisticalConcept] | None, RdfProperty(XKOS.disjoint)]

editorial_note: Annotated[LocalizedStr | None, RdfProperty(XKOS.editorialNote)]

exclusion_note: Annotated[LocalizedStr | None, RdfProperty(XKOS.exclusionNote)]

follows: Annotated[str | URIRef | StatisticalConcept | list[str | URIRef | StatisticalConcept] | None, RdfProperty(XKOS.follows)]

generalizes: Annotated[str | URIRef | StatisticalConcept | list[str | URIRef | StatisticalConcept] | None, RdfProperty(XKOS.generalizes)]

has_part: Annotated[str | URIRef | StatisticalConcept | list[str | URIRef | StatisticalConcept] | None, RdfProperty(XKOS.hasPart)]

hidden_label: Annotated[LocalizedStr | None, RdfProperty(SKOS.hiddenLabel)]

in_scheme: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SKOS.inScheme)]

inclusion_note: Annotated[LocalizedStr | None, RdfProperty(XKOS.inclusionNote)]

introduction: Annotated[LocalizedStr | None, RdfProperty(XKOS.introduction)]

is_part_of: Annotated[str | URIRef | StatisticalConcept | list[str | URIRef | StatisticalConcept] | None, RdfProperty(XKOS.isPartOf)]

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

narrower: Annotated[str | URIRef | StatisticalConcept | list[str | URIRef | StatisticalConcept] | None, RdfProperty(SKOS.narrower)]

narrower_generic: Annotated[str | URIRef | StatisticalConcept | list[str | URIRef | StatisticalConcept] | None, RdfProperty(XKOS.narrowerGeneric)]

narrower_partitive: Annotated[str | URIRef | StatisticalConcept | list[str | URIRef | StatisticalConcept] | None, RdfProperty(XKOS.narrowerPartitive)]

notation: Annotated[str | list[str] | None, RdfProperty(SKOS.notation)]

precedes: Annotated[str | URIRef | StatisticalConcept | list[str | URIRef | StatisticalConcept] | None, RdfProperty(XKOS.precedes)]

pref_label: Annotated[LocalizedStr | None, RdfProperty(SKOS.prefLabel)]

rdf_type: ClassVar[str | URIRef | None] = 'http://www.w3.org/2004/02/skos/core#Concept'

related: Annotated[str | URIRef | StatisticalConcept | list[str | URIRef | StatisticalConcept] | None, RdfProperty(SKOS.related)]

sequential: Annotated[str | URIRef | StatisticalConcept | list[str | URIRef | StatisticalConcept] | None, RdfProperty(XKOS.sequential)]

specializes: Annotated[str | URIRef | StatisticalConcept | list[str | URIRef | StatisticalConcept] | None, RdfProperty(XKOS.specializes)]

temporal: Annotated[str | URIRef | StatisticalConcept | list[str | URIRef | StatisticalConcept] | None, RdfProperty(XKOS.temporal)]

top_concept_of: Annotated[str | URIRef | list[str | URIRef] | None, RdfProperty(SKOS.topConceptOf)]

class dartfx.rdf.pydantic.xkos.XkosResource(*, rdf_uri_generator: RdfUriGenerator = <factory>)[source]

Bases: RdfBaseModel

Base class for XKOS resources.

model_config = {'arbitrary_types_allowed': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rdf_namespace: ClassVar = Namespace('http://rdf-vocabulary.ddialliance.org/xkos#')

rdf_prefixes: ClassVar = {'skos': Namespace(Namespace('http://www.w3.org/2004/02/skos/core#')), 'xkos': Namespace('http://rdf-vocabulary.ddialliance.org/xkos#')}