Skip to content

graflo.onto

Core ontology and base classes for graph database operations.

This module provides the fundamental data structures and base classes used throughout the graph database system. It includes base classes for enums and database-specific configurations.

Key Components
  • BaseEnum: Base class for string-based enumerations with flexible membership testing
  • ExpressionFlavor: Enum for expression language types
  • AggregationType: Enum for supported aggregation operations
Example

class MyEnum(BaseEnum): ... VALUE1 = "value1" ... VALUE2 = "value2" "value1" in MyEnum # True "invalid" in MyEnum # False

Attributes

DB_TYPE_TO_EXPRESSION_FLAVOR = {DBType.ARANGO: ExpressionFlavor.AQL, DBType.NEO4J: ExpressionFlavor.CYPHER, DBType.FALKORDB: ExpressionFlavor.CYPHER, DBType.MEMGRAPH: ExpressionFlavor.CYPHER, DBType.NEBULA: ExpressionFlavor.NGQL, DBType.TIGERGRAPH: ExpressionFlavor.GSQL, DBType.GRAFLO_BACKEND: ExpressionFlavor.AQL} module-attribute

DEFAULT_ENDPOINT_AMBIGUITY = 'all' module-attribute

EndpointAmbiguityPolicy = Literal['all', 'first', 'skip', 'error'] module-attribute

PRIMARY_IDENTITY_SELECTOR = 'identity' module-attribute

SECONDARY_IDENTITY_SUGAR = 'secondary' module-attribute

Classes

AggregationType

Bases: BaseEnum

Supported aggregation operations.

This enum defines the supported aggregation operations for data analysis.

Attributes:

Name Type Description
COUNT

Count operation
MAX

Maximum value
MIN

Minimum value
AVERAGE

Average value
SORTED_UNIQUE

Sorted unique values
Source code in graflo/onto.py 
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
class AggregationType(BaseEnum):
    """Supported aggregation operations.

    This enum defines the supported aggregation operations for data analysis.

    Attributes:
        COUNT: Count operation
        MAX: Maximum value
        MIN: Minimum value
        AVERAGE: Average value
        SORTED_UNIQUE: Sorted unique values
    """

    COUNT = "COUNT"
    MAX = "MAX"
    MIN = "MIN"
    AVERAGE = "AVERAGE"
    SORTED_UNIQUE = "SORTED_UNIQUE"

Attributes

AVERAGE = 'AVERAGE' class-attribute instance-attribute
COUNT = 'COUNT' class-attribute instance-attribute
MAX = 'MAX' class-attribute instance-attribute
MIN = 'MIN' class-attribute instance-attribute
SORTED_UNIQUE = 'SORTED_UNIQUE' class-attribute instance-attribute

BaseEnum

Bases: StrEnum

Base class for string-based enumerations.

This class provides a foundation for string-based enums with flexible membership testing through the MetaEnum metaclass.

Source code in graflo/onto.py 
58
59
60
61
62
63
64
65
66
67
68
69
70
71
class BaseEnum(StrEnum, metaclass=MetaEnum):
    """Base class for string-based enumerations.

    This class provides a foundation for string-based enums with flexible
    membership testing through the MetaEnum metaclass.
    """

    def __str__(self) -> str:
        """Return the enum value as string for proper serialization."""
        return self.value

    def __repr__(self) -> str:
        """Return the enum value as string for proper serialization."""
        return self.value

Methods:

__repr__()

Return the enum value as string for proper serialization.

Source code in graflo/onto.py 
69
70
71
def __repr__(self) -> str:
    """Return the enum value as string for proper serialization."""
    return self.value
__str__()

Return the enum value as string for proper serialization.

Source code in graflo/onto.py 
65
66
67
def __str__(self) -> str:
    """Return the enum value as string for proper serialization."""
    return self.value

DBType

Bases: StrEnum

Enum representing different types of databases.

Includes both graph databases and source databases (SQL, NoSQL, etc.).

Source code in graflo/onto.py 
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
class DBType(StrEnum, metaclass=MetaEnum):
    """Enum representing different types of databases.

    Includes both graph databases and source databases (SQL, NoSQL, etc.).
    """

    # Graph databases
    ARANGO = "arango"
    NEO4J = "neo4j"
    TIGERGRAPH = "tigergraph"
    FALKORDB = "falkordb"
    MEMGRAPH = "memgraph"
    NEBULA = "nebula"
    GRAFLO_BACKEND = "graflo_backend"

    # Source databases (SQL, NoSQL, RDF)
    POSTGRES = "postgres"
    MYSQL = "mysql"
    MONGODB = "mongodb"
    SQLITE = "sqlite"
    SPARQL = "sparql"

Attributes

ARANGO = 'arango' class-attribute instance-attribute
FALKORDB = 'falkordb' class-attribute instance-attribute
GRAFLO_BACKEND = 'graflo_backend' class-attribute instance-attribute
MEMGRAPH = 'memgraph' class-attribute instance-attribute
MONGODB = 'mongodb' class-attribute instance-attribute
MYSQL = 'mysql' class-attribute instance-attribute
NEBULA = 'nebula' class-attribute instance-attribute
NEO4J = 'neo4j' class-attribute instance-attribute
POSTGRES = 'postgres' class-attribute instance-attribute
SPARQL = 'sparql' class-attribute instance-attribute
SQLITE = 'sqlite' class-attribute instance-attribute
TIGERGRAPH = 'tigergraph' class-attribute instance-attribute

ExpressionFlavor

Bases: BaseEnum

Supported expression language types for filter/query rendering.

Uses the actual query language names: AQL (ArangoDB), CYPHER (Neo4j, FalkorDB, Memgraph), NGQL (NebulaGraph 3.x), GSQL (TigerGraph), SQL for WHERE clauses, PYTHON for in-memory evaluation.

Attributes:

Name Type Description
AQL

ArangoDB AQL expressions
CYPHER

OpenCypher expressions (Neo4j, FalkorDB, Memgraph, NebulaGraph 5.x)
NGQL

NebulaGraph nGQL expressions (v3.x: dot-access, == equality)
GSQL

TigerGraph GSQL expressions (including REST++ filter format)
SQL

SQL WHERE clause fragments (column names, single-quoted values)
PYTHON

Python expression evaluation
Source code in graflo/onto.py 
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
class ExpressionFlavor(BaseEnum):
    """Supported expression language types for filter/query rendering.

    Uses the actual query language names: AQL (ArangoDB), CYPHER (Neo4j,
    FalkorDB, Memgraph), NGQL (NebulaGraph 3.x), GSQL (TigerGraph),
    SQL for WHERE clauses, PYTHON for in-memory evaluation.

    Attributes:
        AQL: ArangoDB AQL expressions
        CYPHER: OpenCypher expressions (Neo4j, FalkorDB, Memgraph, NebulaGraph 5.x)
        NGQL: NebulaGraph nGQL expressions (v3.x: dot-access, == equality)
        GSQL: TigerGraph GSQL expressions (including REST++ filter format)
        SQL: SQL WHERE clause fragments (column names, single-quoted values)
        PYTHON: Python expression evaluation
    """

    AQL = "aql"
    CYPHER = "cypher"
    NGQL = "ngql"
    GSQL = "gsql"
    SQL = "sql"
    PYTHON = "python"

Attributes

AQL = 'aql' class-attribute instance-attribute
CYPHER = 'cypher' class-attribute instance-attribute
GSQL = 'gsql' class-attribute instance-attribute
NGQL = 'ngql' class-attribute instance-attribute
PYTHON = 'python' class-attribute instance-attribute
SQL = 'sql' class-attribute instance-attribute

MetaEnum

Bases: EnumMeta

Metaclass for flexible enumeration membership testing.

This metaclass allows checking if a value is a valid member of an enum using the in operator, even if the value hasn't been instantiated as an enum member.

Example

class MyEnum(BaseEnum): ... VALUE = "value" "value" in MyEnum # True "invalid" in MyEnum # False

Source code in graflo/onto.py 
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
class MetaEnum(EnumMeta):
    """Metaclass for flexible enumeration membership testing.

    This metaclass allows checking if a value is a valid member of an enum
    using the `in` operator, even if the value hasn't been instantiated as
    an enum member.

    Example:
        >>> class MyEnum(BaseEnum):
        ...     VALUE = "value"
        >>> "value" in MyEnum  # True
        >>> "invalid" in MyEnum  # False
    """

    def __contains__(self, member: object) -> bool:
        """Check if an item is a valid member of the enum.

        Args:
            member: Value to check for membership

        Returns:
            bool: True if the item is a valid enum member, False otherwise
        """
        if isinstance(member, self):
            return True
        try:
            self(member)
            return True
        except ValueError:
            return False

Methods:

__contains__(member)

Check if an item is a valid member of the enum.

Parameters:

Name Type Description Default
member object

Value to check for membership

 required

Returns:

Name Type Description
bool bool

True if the item is a valid enum member, False otherwise
Source code in graflo/onto.py 
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
def __contains__(self, member: object) -> bool:
    """Check if an item is a valid member of the enum.

    Args:
        member: Value to check for membership

    Returns:
        bool: True if the item is a valid enum member, False otherwise
    """
    if isinstance(member, self):
        return True
    try:
        self(member)
        return True
    except ValueError:
        return False