The Base DataModels

We provide different backend-dependent DataModels to use.

These data models provide basic functionality for GraphRAGs, Agents etc.

The user can build new data models by inheriting from these base models.

The checking functions works for every type of data models, e.g. SymbolicDataModel, JsonDataModel, DataModel or Variable.

ChatMessage

Bases: DataModel

A chat message

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.ChatMessage",
        "synalinks.ChatMessage",
    ]
)
class ChatMessage(DataModel):
    """A chat message"""

    role: ChatRole
    content: str

ChatMessages

Bases: DataModel

A list of chat messages

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.ChatMessages",
        "synalinks.ChatMessages",
    ]
)
class ChatMessages(DataModel):
    """A list of chat messages"""

    messages: List[ChatMessage] = []

ChatRole

Bases: str, Enum

The chat message roles

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.ChatRole",
        "synalinks.ChatRole",
    ]
)
class ChatRole(str, Enum):
    """The chat message roles"""

    SYSTEM = "system"
    USER = "user"
    ASSISTANT = "assistant"

Document

Bases: Entity

A document

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.Document",
        "synalinks.Document",
    ]
)
class Document(Entity):
    """A document"""

    label: str = "Document"
    text: str

Edge

Bases: Entity, Weight

An edge entity

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.Edge",
        "synalinks.Edge",
    ]
)
class Edge(Entity, Weight):
    """An edge entity"""

    source: str
    target: str

Embedding

Bases: DataModel

An embedding vector

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.Embedding",
        "synalinks.Embedding",
    ]
)
class Embedding(DataModel):
    """An embedding vector"""

    embedding: List[float] = []

Embeddings

Bases: DataModel

A list of embeddings

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.Embeddings",
        "synalinks.Embeddings",
    ]
)
class Embeddings(DataModel):
    """A list of embeddings"""

    embeddings: List[List[float]] = []

Entities

Bases: DataModel

A list of entities

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.Entities",
        "synalinks.Entities",
    ]
)
class Entities(DataModel):
    """A list of entities"""

    entities: List[Entity] = []

Entity

Bases: Unique, Embeddings, Label, Stamp

An entity data model

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.Entity",
        "synalinks.Entity",
    ]
)
class Entity(Unique, Embeddings, Label, Stamp):
    """An entity data model"""

    pass

GenericIO

Bases: DataModel

A pair of generic inputs/outputs

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.GenericIO",
        "synalinks.GenericIO",
    ]
)
class GenericIO(DataModel):
    """A pair of generic inputs/outputs"""

    inputs: Dict[str, Any]
    outputs: Dict[str, Any]

GenericInputs

Bases: DataModel

A generic inputs

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.GenericInputs",
        "synalinks.GenericInputs",
    ]
)
class GenericInputs(DataModel):
    """A generic inputs"""

    inputs: Dict[str, Any]

GenericOutputs

Bases: DataModel

A generic outputs

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.GenericOutputs",
        "synalinks.GenericOutputs",
    ]
)
class GenericOutputs(DataModel):
    """A generic outputs"""

    outputs: Dict[str, Any]

Instructions

Bases: Entity

The generator's instructions

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.Instructions",
        "synalinks.Instructions",
    ]
)
class Instructions(Entity):
    """The generator's instructions"""

    label: str = "Instructions"
    instructions: List[str]
    reward: Optional[float] = None  # None if not yet backpropagated

KnowledgeGraph

Bases: DataModel

A knowledge graph data model

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.KnowledgeGraph",
        "synalinks.KnowledgeGraph",
    ]
)
class KnowledgeGraph(DataModel):
    """A knowledge graph data model"""

    nodes: List[Entity] = []
    edges: List[Edge] = []

KnowledgeGraphs

Bases: DataModel

A list of knowledge graphs

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.KnowledgeGraphs",
        "synalinks.KnowledgeGraphs",
    ]
)
class KnowledgeGraphs(DataModel):
    """A list of knowledge graphs"""

    knowledge_graphs: List[KnowledgeGraph] = []

Label

Bases: DataModel

A labelled data model

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export("synalinks.backend.Label")
class Label(DataModel):
    """A labelled data model"""

    label: str

Prediction

Bases: Entity, GenericIO

The generator's prediction

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.Prediction",
        "synalinks.Prediction",
    ]
)
class Prediction(Entity, GenericIO):
    """The generator's prediction"""

    label: str = "Prediction"
    reward: Optional[float] = None  # None if not yet backpropagated

Reward

Bases: DataModel

A rewarded data model

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export("synalinks.backend.Reward")
class Reward(DataModel):
    """A rewarded data model"""

    reward: float = 0.0
    count: int = 0

Stamp

Bases: DataModel

A stamped data model

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export("synalinks.backend.Stamp")
class Stamp(DataModel):
    """A stamped data model"""

    created_at: datetime = datetime.now()

Unique

Bases: DataModel

A unique data model

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export("synalinks.backend.Unique")
class Unique(DataModel):
    """A unique data model"""

    uuid: str = str(uuid.uuid4())

Weight

Bases: DataModel

A weighted data model

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export("synalinks.backend.Weight")
class Weight(DataModel):
    """A weighted data model"""

    weight: float = 1.0

is_chat_message(x)

Checks if the given data model is a chat message

Parameters:

Name	Type	Description	Default
x	DataModel | JsonDataModel | SymbolicDataModel | Variable	The data model to check.	required

Returns:

Type	Description
bool	True if the condition is met

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.is_chat_message",
        "synalinks.is_chat_message",
    ]
)
def is_chat_message(x):
    """Checks if the given data model is a chat message

    Args:
        x (DataModel | JsonDataModel | SymbolicDataModel | Variable):
            The data model to check.

    Returns:
        (bool): True if the condition is met
    """
    if contains_schema(x.get_schema(), ChatMessage.get_schema()):
        return True
    return False

is_chat_messages(x)

Checks if the given data model are chat messages

Parameters:

Name	Type	Description	Default
x	DataModel | JsonDataModel | SymbolicDataModel | Variable	The data model to check.	required

Returns:

Type	Description
bool	True if the condition is met

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.is_chat_messages",
        "synalinks.is_chat_messages",
    ]
)
def is_chat_messages(x):
    """Checks if the given data model are chat messages

    Args:
        x (DataModel | JsonDataModel | SymbolicDataModel | Variable):
            The data model to check.

    Returns:
        (bool): True if the condition is met
    """
    if contains_schema(x.get_schema(), ChatMessages.get_schema()):
        return True
    return False

is_document(x)

Checks if the given data model is a document

Parameters:

Name	Type	Description	Default
x	DataModel | JsonDataModel | SymbolicDataModel | Variable	The data model to check.	required

Returns:

Type	Description
bool	True if the condition is met

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.is_document",
        "synalinks.is_document",
    ]
)
def is_document(x):
    """Checks if the given data model is a document

    Args:
        x (DataModel | JsonDataModel | SymbolicDataModel | Variable):
            The data model to check.

    Returns:
        (bool): True if the condition is met
    """
    if contains_schema(x.get_schema(), Document.get_schema()):
        return True
    return False

is_edge(x)

Checks if the given data model is an edge

Parameters:

Name	Type	Description	Default
x	DataModel | JsonDataModel | SymbolicDataModel | Variable	The data model to check.	required

Returns:

Type	Description
bool	True if the condition is met

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.is_edge",
        "synalinks.is_edge",
    ]
)
def is_edge(x):
    """Checks if the given data model is an edge

    Args:
        x (DataModel | JsonDataModel | SymbolicDataModel | Variable):
            The data model to check.

    Returns:
        (bool): True if the condition is met
    """
    if contains_schema(x.get_schema(), Edge.get_schema()):
        return True
    return False

is_embedding(x)

Checks if the given data model is an embedding

Parameters:

Name	Type	Description	Default
x	DataModel | JsonDataModel | SymbolicDataModel | Variable	The data model to check.	required

Returns:

Type	Description
bool	True if the condition is met

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.is_embedding",
        "synalinks.is_embedding",
    ]
)
def is_embedding(x):
    """Checks if the given data model is an embedding

    Args:
        x (DataModel | JsonDataModel | SymbolicDataModel | Variable):
            The data model to check.

    Returns:
        (bool): True if the condition is met
    """
    if contains_schema(x.get_schema(), Embedding.get_schema()):
        return True
    return False

is_embeddings(x)

Checks if the given data model are embeddings

Parameters:

Name	Type	Description	Default
x	DataModel | JsonDataModel | SymbolicDataModel | Variable	The data model to check.	required

Returns:

Type	Description
bool	True if the condition is met

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.is_embeddings",
        "synalinks.is_embeddings",
    ]
)
def is_embeddings(x):
    """Checks if the given data model are embeddings

    Args:
        x (DataModel | JsonDataModel | SymbolicDataModel | Variable):
            The data model to check.

    Returns:
        (bool): True if the condition is met
    """
    if contains_schema(x.get_schema(), Embeddings.get_schema()):
        return True
    return False

is_entities(x)

Checks if the given data model are entities

Parameters:

Name	Type	Description	Default
x	DataModel | JsonDataModel | SymbolicDataModel | Variable	The data model to check.	required

Returns:

Type	Description
bool	True if the condition is met

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.is_entities",
        "synalinks.is_entities",
    ]
)
def is_entities(x):
    """Checks if the given data model are entities

    Args:
        x (DataModel | JsonDataModel | SymbolicDataModel | Variable):
            The data model to check.

    Returns:
        (bool): True if the condition is met
    """
    if contains_schema(x.get_schema(), Entities.get_schema()):
        return True
    return False

is_entity(x)

Checks if the given data model is an entity

Parameters:

Name	Type	Description	Default
x	DataModel | JsonDataModel | SymbolicDataModel | Variable	The data model to check.	required

Returns:

Type	Description
bool	True if the condition is met

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.is_entity",
        "synalinks.is_entity",
    ]
)
def is_entity(x):
    """Checks if the given data model is an entity

    Args:
        x (DataModel | JsonDataModel | SymbolicDataModel | Variable):
            The data model to check.

    Returns:
        (bool): True if the condition is met
    """
    if contains_schema(x.get_schema(), Entity.get_schema()):
        return True
    return False

is_instructions(x)

Checks if the given data model is a instructions

Parameters:

Name	Type	Description	Default
x	DataModel | JsonDataModel | SymbolicDataModel | Variable	The data model to check.	required

Returns:

Type	Description
bool	True if the condition is met

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.is_instructions",
        "synalinks.is_instructions",
    ]
)
def is_instructions(x):
    """Checks if the given data model is a instructions

    Args:
        x (DataModel | JsonDataModel | SymbolicDataModel | Variable):
            The data model to check.

    Returns:
        (bool): True if the condition is met
    """
    if contains_schema(x.get_schema(), Instructions.get_schema()):
        return True
    return False

is_knowledge_graph(x)

Checks if the given data model is a knowledge graph

Parameters:

Name	Type	Description	Default
x	DataModel | JsonDataModel | SymbolicDataModel | Variable	The data model to check.	required

Returns:

Type	Description
bool	True if the condition is met

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.is_knowledge_graph",
        "synalinks.is_knowledge_graph",
    ]
)
def is_knowledge_graph(x):
    """Checks if the given data model is a knowledge graph

    Args:
        x (DataModel | JsonDataModel | SymbolicDataModel | Variable):
            The data model to check.

    Returns:
        (bool): True if the condition is met
    """
    if contains_schema(x.get_schema(), KnowledgeGraph.get_schema()):
        return True
    return False

is_knowledge_graphs(x)

Checks if the given data model are knowledge graphs

Parameters:

Name	Type	Description	Default
x	DataModel | JsonDataModel | SymbolicDataModel | Variable	The data model to check.	required

Returns:

Type	Description
bool	True if the condition is met

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.is_knowledge_graphs",
        "synalinks.is_knowledge_graphs",
    ]
)
def is_knowledge_graphs(x):
    """Checks if the given data model are knowledge graphs

    Args:
        x (DataModel | JsonDataModel | SymbolicDataModel | Variable):
            The data model to check.

    Returns:
        (bool): True if the condition is met
    """
    if contains_schema(x.get_schema(), KnowledgeGraphs.get_schema()):
        return True
    return False

is_prediction(x)

Checks if the given data model is a prediction

Parameters:

Name	Type	Description	Default
x	DataModel | JsonDataModel | SymbolicDataModel | Variable	The data model to check.	required

Returns:

Type	Description
bool	True if the condition is met

Source code in synalinks/src/backend/pydantic/base.py

@synalinks_export(
    [
        "synalinks.backend.is_prediction",
        "synalinks.is_prediction",
    ]
)
def is_prediction(x):
    """Checks if the given data model is a prediction

    Args:
        x (DataModel | JsonDataModel | SymbolicDataModel | Variable):
            The data model to check.

    Returns:
        (bool): True if the condition is met
    """
    if contains_schema(x.get_schema(), Prediction.get_schema()):
        return True
    return False