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: List[str]

Return a list of all vertices in the hypergraph.

all_e cached property 

all_e: List[Tuple]

Return a list 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])

Save the hypergraph to a file.

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

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

    Args:
        ``file_path`` (``Union[str, Path]``): The file path to save the hypergraph.
    """
    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 
24
25
26
27
28
29
30
31
32
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 staticmethod 

load(file_path: Union[str, Path])

Load the hypergraph from a file.

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

Source code in hyperdb/base.py 
34
35
36
37
38
39
40
41
42
@staticmethod
def load(self, file_path: Union[str, Path]):
    r"""
    Load the hypergraph from a file.

    Args:
        ``file_path`` (``Union[str, Path]``): The file path to load the hypergraph from.
    """
    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 
44
45
46
47
48
49
50
51
52
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 
60
61
62
63
64
65
66
67
68
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 
70
71
72
73
74
75
76
77
78
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 
80
81
82
83
84
85
86
87
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 
117
118
119
120
121
122
123
124
125
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 
127
128
129
130
131
132
133
134
135
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 
137
138
139
140
141
142
143
144
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 
146
147
148
149
150
151
152
153
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)

Update the vertex data.

Args: v_id (Any): The vertex id.

Source code in hyperdb/base.py 
155
156
157
158
159
160
161
162
def update_v(self, v_id: Any):
    r"""
    Update the vertex data.

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

update_e 

update_e(e_tuple: Tuple)

Update the hyperedge data.

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

Source code in hyperdb/base.py 
164
165
166
167
168
169
170
171
def update_e(self, e_tuple: Tuple):
    r"""
    Update the hyperedge data.

    Args:
        ``e_tuple`` (``Tuple``): The hyperedge tuple: (v1_name, v2_name, ..., vn_name).
    """
    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 
173
174
175
176
177
178
179
180
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 
182
183
184
185
186
187
188
189
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 
191
192
193
194
195
196
197
198
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 
200
201
202
203
204
205
206
207
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) -> list

Return the hyperedge neighbors of the vertex.

Args: v_id (Any): The vertex id.

Source code in hyperdb/base.py 
209
210
211
212
213
214
215
216
def nbr_e_of_v(self, v_id: Any) -> list:
    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) -> list

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 
218
219
220
221
222
223
224
225
def nbr_v_of_e(self, e_tuple: Tuple) -> list:
    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) -> list

Return the vertex neighbors of the vertex.

Args: v_id (Any): The vertex id.

Source code in hyperdb/base.py 
227
228
229
230
231
232
233
234
def nbr_v(self, v_id: Any) -> list:
    r"""
    Return the vertex neighbors of the vertex.

    Args:
        ``v_id`` (``Any``): The vertex id.
    """
    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 
244
245
246
247
248
249
250
251
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 
253
254
255
256
257
258
259
260
261
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 
263
264
265
266
267
268
269
270
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 
272
273
274
275
276
277
278
279
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 
281
282
283
284
285
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 
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
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
    )