Skip to content

BaseHypergraphDB Class

hyperdb.base.BaseHypergraphDB dataclass 

BaseHypergraphDB(
    storage_file: Union[str, Path] = "my_hypergraph.hgdb",
)

Base class for hypergraph database.

Attributes

storage_file class-attribute instance-attribute 

storage_file: Union[str, Path] = field(
    default="my_hypergraph.hgdb", compare=False
)

all_v cached property 

all_v: Set[Any]

Return a set of all vertices in the hypergraph.

all_e cached property 

all_e: Set[Tuple]

Return a set of all hyperedges in the hypergraph.

num_v cached property 

num_v: int

Return the number of vertices in the hypergraph.

num_e cached property 

num_e: int

Return the number of hyperedges in the hypergraph.

Functions

save 

save(file_path: Union[str, Path]) -> bool

Save the hypergraph to a file.

Args: file_path (Union[str, Path]): The file path to save the hypergraph.

Returns: bool: True if successful, False otherwise.

Source code in hyperdb/base.py 
15
16
17
18
19
20
21
22
23
24
25
26
def save(self, file_path: Union[str, Path]) -> bool:
    r"""
    Save the hypergraph to a file.

    Args:
        ``file_path`` (``Union[str, Path]``): The file path to save the
            hypergraph.

    Returns:
        ``bool``: True if successful, False otherwise.
    """
    raise NotImplementedError

save_as 

save_as(format: str, file_path: Union[str, Path])

Save the hypergraph to a specific format.

Args: format (str): The export format (e.g., "json", "csv", "graphml"). file_path (Union[str, Path]): The file path to export the hypergraph.

Source code in hyperdb/base.py 
28
29
30
31
32
33
34
35
36
def save_as(self, format: str, file_path: Union[str, Path]):
    r"""
    Save the hypergraph to a specific format.

    Args:
        ``format`` (``str``): The export format (e.g., "json", "csv", "graphml").
        ``file_path`` (``Union[str, Path]``): The file path to export the hypergraph.
    """
    raise NotImplementedError

load 

load(file_path: Union[str, Path]) -> bool

Load the hypergraph from a file.

Args: file_path (Union[str, Path]): The file path to load the hypergraph from.

Returns: bool: True if successful, False otherwise.

Source code in hyperdb/base.py 
38
39
40
41
42
43
44
45
46
47
48
def load(self, file_path: Union[str, Path]) -> bool:
    r"""
    Load the hypergraph from a file.

    Args:
        ``file_path`` (``Union[str, Path]``): The file path to load the hypergraph from.

    Returns:
        ``bool``: True if successful, False otherwise.
    """
    raise NotImplementedError

load_from 

load_from(format: str, file_path: Union[str, Path])

Load a hypergraph from a specific format.

Args: format (str): The import format (e.g., "json", "csv", "graphml"). file_path (Union[str, Path]): The file path to import the hypergraph from.

Source code in hyperdb/base.py 
50
51
52
53
54
55
56
57
58
def load_from(self, format: str, file_path: Union[str, Path]):
    r"""
    Load a hypergraph from a specific format.

    Args:
        ``format`` (``str``): The import format (e.g., "json", "csv", "graphml").
        ``file_path`` (``Union[str, Path]``): The file path to import the hypergraph from.
    """
    raise NotImplementedError

v 

v(v_id: Any, default: Any = None) -> dict

Return the vertex data.

Args: v_id (Any): The vertex id. default (Any): The default value if the vertex does not exist.

Source code in hyperdb/base.py 
66
67
68
69
70
71
72
73
74
def v(self, v_id: Any, default: Any = None) -> dict:
    r"""
    Return the vertex data.

    Args:
        ``v_id`` (``Any``): The vertex id.
        ``default`` (``Any``): The default value if the vertex does not exist.
    """
    raise NotImplementedError

e 

e(
    e_tuple: Union[List, Set, Tuple], default: Any = None
) -> dict

Return the hyperedge data.

Args: e_tuple (Union[List, Set, Tuple]): The hyperedge tuple: (v1_name, v2_name, ..., vn_name). default (Any): The default value if the hyperedge does not exist.

Source code in hyperdb/base.py 
76
77
78
79
80
81
82
83
84
def e(self, e_tuple: Union[List, Set, Tuple], default: Any = None) -> dict:
    r"""
    Return the hyperedge data.

    Args:
        ``e_tuple`` (``Union[List, Set, Tuple]``): The hyperedge tuple: (v1_name, v2_name, ..., vn_name).
        ``default`` (``Any``): The default value if the hyperedge does not exist.
    """
    raise NotImplementedError

encode_e 

encode_e(e_tuple: Union[List, Set, Tuple]) -> Tuple

Sort and check the hyperedge tuple.

Args: e_tuple (Union[List, Set, Tuple]): The hyperedge tuple: (v1_name, v2_name, ..., vn_name).

Source code in hyperdb/base.py 
86
87
88
89
90
91
92
93
def encode_e(self, e_tuple: Union[List, Set, Tuple]) -> Tuple:
    r"""
    Sort and check the hyperedge tuple.

    Args:
        ``e_tuple`` (``Union[List, Set, Tuple]``): The hyperedge tuple: (v1_name, v2_name, ..., vn_name).
    """
    raise NotImplementedError

add_v 

add_v(v_id: Any, v_data: Optional[Dict] = None)

Add a vertex to the hypergraph.

Args: v_id (Any): The vertex id. v_data (Dict, optional): The vertex data. Defaults to None.

Source code in hyperdb/base.py 
123
124
125
126
127
128
129
130
131
def add_v(self, v_id: Any, v_data: Optional[Dict] = None):
    r"""
    Add a vertex to the hypergraph.

    Args:
        ``v_id`` (``Any``): The vertex id.
        ``v_data`` (``Dict``, optional): The vertex data. Defaults to None.
    """
    raise NotImplementedError

add_e 

add_e(e_tuple: Tuple, e_data: Optional[Dict] = None)

Add a hyperedge to the hypergraph.

Args: e_tuple (Tuple): The hyperedge tuple: (v1_name, v2_name, ..., vn_name). e_data (Dict, optional): The hyperedge data.

Source code in hyperdb/base.py 
133
134
135
136
137
138
139
140
141
def add_e(self, e_tuple: Tuple, e_data: Optional[Dict] = None):
    r"""
    Add a hyperedge to the hypergraph.

    Args:
        ``e_tuple`` (``Tuple``): The hyperedge tuple: (v1_name, v2_name, ..., vn_name).
        ``e_data`` (``Dict``, optional): The hyperedge data.
    """
    raise NotImplementedError

remove_v 

remove_v(v_id: Any)

Remove a vertex from the hypergraph.

Args: v_id (Any): The vertex id.

Source code in hyperdb/base.py 
143
144
145
146
147
148
149
150
def remove_v(self, v_id: Any):
    r"""
    Remove a vertex from the hypergraph.

    Args:
        ``v_id`` (``Any``): The vertex id.
    """
    raise NotImplementedError

remove_e 

remove_e(e_tuple: Tuple)

Remove a hyperedge from the hypergraph.

Args: e_tuple (Tuple): The hyperedge tuple: (v1_name, v2_name, ..., vn_name).

Source code in hyperdb/base.py 
152
153
154
155
156
157
158
159
def remove_e(self, e_tuple: Tuple):
    r"""
    Remove a hyperedge from the hypergraph.

    Args:
        ``e_tuple`` (``Tuple``): The hyperedge tuple: (v1_name, v2_name, ..., vn_name).
    """
    raise NotImplementedError

update_v 

update_v(v_id: Any, v_data: Dict[Any, Any])

Update the vertex data.

Args: v_id (Any): The vertex id. v_data (Dict[Any, Any]): The vertex data.

Source code in hyperdb/base.py 
161
162
163
164
165
166
167
168
169
def update_v(self, v_id: Any, v_data: Dict[Any, Any]):
    r"""
    Update the vertex data.

    Args:
        ``v_id`` (``Any``): The vertex id.
        ``v_data`` (``Dict[Any, Any]``): The vertex data.
    """
    raise NotImplementedError

update_e 

update_e(
    e_tuple: Union[List[Any], Set[Any], Tuple[Any, ...]],
    e_data: Dict[Any, Any],
)

Update the hyperedge data.

Args: e_tuple (Union[List[Any], Set[Any], Tuple[Any, ...]]): The hyperedge tuple. e_data (Dict[Any, Any]): The hyperedge data.

Source code in hyperdb/base.py 
171
172
173
174
175
176
177
178
179
def update_e(self, e_tuple: Union[List[Any], Set[Any], Tuple[Any, ...]], e_data: Dict[Any, Any]):
    r"""
    Update the hyperedge data.

    Args:
        ``e_tuple`` (``Union[List[Any], Set[Any], Tuple[Any, ...]]``): The hyperedge tuple.
        ``e_data`` (``Dict[Any, Any]``): The hyperedge data.
    """
    raise NotImplementedError

has_v 

has_v(v_id: Any) -> bool

Return True if the vertex exists in the hypergraph.

Args: v_id (Any): The vertex id.

Source code in hyperdb/base.py 
181
182
183
184
185
186
187
188
def has_v(self, v_id: Any) -> bool:
    r"""
    Return True if the vertex exists in the hypergraph.

    Args:
        ``v_id`` (``Any``): The vertex id.
    """
    raise NotImplementedError

has_e 

has_e(e_tuple: Tuple) -> bool

Return True if the hyperedge exists in the hypergraph.

Args: e_tuple (Tuple): The hyperedge tuple: (v1_name, v2_name, ..., vn_name).

Source code in hyperdb/base.py 
190
191
192
193
194
195
196
197
def has_e(self, e_tuple: Tuple) -> bool:
    r"""
    Return True if the hyperedge exists in the hypergraph.

    Args:
        ``e_tuple`` (``Tuple``): The hyperedge tuple: (v1_name, v2_name, ..., vn_name).
    """
    raise NotImplementedError

degree_v 

degree_v(v_id: Any) -> int

Return the degree of the vertex.

Args: v_id (Any): The vertex id.

Source code in hyperdb/base.py 
199
200
201
202
203
204
205
206
def degree_v(self, v_id: Any) -> int:
    r"""
    Return the degree of the vertex.

    Args:
        ``v_id`` (``Any``): The vertex id.
    """
    raise NotImplementedError

degree_e 

degree_e(e_tuple: Tuple) -> int

Return the degree of the hyperedge.

Args: e_tuple (Tuple): The hyperedge tuple: (v1_name, v2_name, ..., vn_name).

Source code in hyperdb/base.py 
208
209
210
211
212
213
214
215
def degree_e(self, e_tuple: Tuple) -> int:
    r"""
    Return the degree of the hyperedge.

    Args:
        ``e_tuple`` (``Tuple``): The hyperedge tuple: (v1_name, v2_name, ..., vn_name).
    """
    raise NotImplementedError

nbr_e_of_v 

nbr_e_of_v(v_id: Any) -> set

Return the hyperedge neighbors of the vertex.

Args: v_id (Any): The vertex id.

Source code in hyperdb/base.py 
217
218
219
220
221
222
223
224
def nbr_e_of_v(self, v_id: Any) -> set:
    r"""
    Return the hyperedge neighbors of the vertex.

    Args:
        ``v_id`` (``Any``): The vertex id.
    """
    raise NotImplementedError

nbr_v_of_e 

nbr_v_of_e(e_tuple: Tuple) -> set

Return the vertex neighbors of the hyperedge.

Args: e_tuple (Tuple): The hyperedge tuple: (v1_name, v2_name, ..., vn_name).

Source code in hyperdb/base.py 
226
227
228
229
230
231
232
233
def nbr_v_of_e(self, e_tuple: Tuple) -> set:
    r"""
    Return the vertex neighbors of the hyperedge.

    Args:
        ``e_tuple`` (``Tuple``): The hyperedge tuple: (v1_name, v2_name, ..., vn_name).
    """
    raise NotImplementedError

nbr_v 

nbr_v(v_id: Any, exclude_self: bool = True) -> set

Return the vertex neighbors of the vertex.

Args: v_id (Any): The vertex id. exclude_self (bool): Whether to exclude the vertex itself from neighbors.

Source code in hyperdb/base.py 
235
236
237
238
239
240
241
242
243
def nbr_v(self, v_id: Any, exclude_self: bool = True) -> set:
    r"""
    Return the vertex neighbors of the vertex.

    Args:
        ``v_id`` (``Any``): The vertex id.
        ``exclude_self`` (``bool``): Whether to exclude the vertex itself from neighbors.
    """
    raise NotImplementedError

sub 

sub(v_name_list: List[str])

Return the sub-hypergraph.

Args: v_name_list (List[str]): The list of vertex ids.

Source code in hyperdb/base.py 
245
246
247
248
249
250
251
252
def sub(self, v_name_list: List[str]):
    r"""
    Return the sub-hypergraph.

    Args:
        ``v_name_list`` (``List[str]``): The list of vertex ids.
    """
    raise NotImplementedError

sub_from_v 

sub_from_v(v_id: Any, depth: int)

Return the sub-hypergraph from the vertex.

Args: v_id (Any): The vertex id. depth (int): The depth of the sub-hypergraph.

Source code in hyperdb/base.py 
254
255
256
257
258
259
260
261
262
def sub_from_v(self, v_id: Any, depth: int):
    r"""
    Return the sub-hypergraph from the vertex.

    Args:
        ``v_id`` (``Any``): The vertex id.
        ``depth`` (``int``): The depth of the sub-hypergraph.
    """
    raise NotImplementedError

query_v 

query_v(filters: Dict[str, Any]) -> List[str]

Query and return vertices that match the given filters.

Args: filters (Dict[str, Any]): A dictionary of conditions to filter vertices.

Source code in hyperdb/base.py 
264
265
266
267
268
269
270
271
def query_v(self, filters: Dict[str, Any]) -> List[str]:
    r"""
    Query and return vertices that match the given filters.

    Args:
        ``filters`` (``Dict[str, Any]``): A dictionary of conditions to filter vertices.
    """
    raise NotImplementedError

query_e 

query_e(filters: Dict[str, Any]) -> List[Tuple]

Query and return hyperedges that match the given filters.

Args: filters (Dict[str, Any]): A dictionary of conditions to filter hyperedges.

Source code in hyperdb/base.py 
273
274
275
276
277
278
279
280
def query_e(self, filters: Dict[str, Any]) -> List[Tuple]:
    r"""
    Query and return hyperedges that match the given filters.

    Args:
        ``filters`` (``Dict[str, Any]``): A dictionary of conditions to filter hyperedges.
    """
    raise NotImplementedError

stats 

stats() -> dict

Return basic statistics of the hypergraph.

Source code in hyperdb/base.py 
282
283
284
285
286
def stats(self) -> dict:
    r"""
    Return basic statistics of the hypergraph.
    """
    raise NotImplementedError

draw 

draw(
    port: int = 8080,
    open_browser: bool = True,
    blocking: bool = True,
)

Draw the hypergraph data of the current HyperDB instance

Args: port: Server port number, defaults to 8080 open_browser: Whether to automatically open the browser, defaults to True blocking: Whether to block the main thread, defaults to True. Set to False for non-blocking mode.

Returns: HypergraphViewer instance

Source code in hyperdb/base.py 
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
def draw(self, port: int = 8080, open_browser: bool = True, blocking: bool = True):
    """
    Draw the hypergraph data of the current HyperDB instance

    Args:
        ``port``: Server port number, defaults to 8080
        ``open_browser``: Whether to automatically open the browser, defaults to True
        ``blocking``: Whether to block the main thread, defaults to True. Set to False for non-blocking mode.

    Returns:
        HypergraphViewer instance
    """
    from .draw import draw_hypergraph

    return draw_hypergraph(hypergraph_db=self, port=port, open_browser=open_browser, blocking=blocking)