Graphinate 0.4.0__tar.gz → 0.5.0__tar.gz

{graphinate-0.4.0 → graphinate-0.5.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: Graphinate
-Version: 0.4.0
-Summary: Graphinate. Data to Graphs.
+Version: 0.5.0
+Summary: 𝔾raphinate. Data to Graphs.
 Project-URL: Homepage, https://erivlis.github.io/graphinate
 Project-URL: Documentation, https://erivlis.github.io/graphinate
 Project-URL: Bug Tracker, https://github.com/erivlis/graphinate/issues
@@ -58,7 +58,7 @@ Requires-Dist: pytest-randomly; extra == 'test'
 Requires-Dist: pytest-xdist; extra == 'test'
 Description-Content-Type: text/markdown
 
-# [Graphinate. Data to Graphs.](https://erivlis.github.io/graphinate/)
+# [𝔾raphinate. Data to Graphs.](https://erivlis.github.io/graphinate/)
 
 <img height="360" src="https://github.com/erivlis/graphinate/assets/9897520/dae41f9f-69e5-4eb5-a488-87ce7f51fa32" alt="Graphinate. Data to Graphs.">
 
@@ -120,10 +120,14 @@ Description-Content-Type: text/markdown
       <a href="https://snyk.io/test/github/erivlis/graphinate"><img alt="Snyk" src="https://snyk.io/test/github/erivlis/Graphinate/badge.svg"></a>
     </td>
   </tr>
+  <tr>
+    <td>Badge</td>
+    <td>
+       <a href="https://img.shields.io/badge/%F0%9D%94%BE%3D%7B%F0%9D%95%8D%2C%F0%9D%94%BC%7D-Graphinate-darkviolet"><img alt="Graphinate" src="https://img.shields.io/badge/%F0%9D%94%BE%3D%7B%F0%9D%95%8D%2C%F0%9D%94%BC%7D-Graphinate-darkviolet"></a>
+    </td>
+  </tr>
 </table>
 
----------------------
-
 ## Introduction
 
 ### What is Graphinate?

{graphinate-0.4.0 → graphinate-0.5.0}/README.md

@@ -1,4 +1,4 @@
-# [Graphinate. Data to Graphs.](https://erivlis.github.io/graphinate/)
+# [𝔾raphinate. Data to Graphs.](https://erivlis.github.io/graphinate/)
 
 <img height="360" src="https://github.com/erivlis/graphinate/assets/9897520/dae41f9f-69e5-4eb5-a488-87ce7f51fa32" alt="Graphinate. Data to Graphs.">
 
@@ -60,10 +60,14 @@
       <a href="https://snyk.io/test/github/erivlis/graphinate"><img alt="Snyk" src="https://snyk.io/test/github/erivlis/Graphinate/badge.svg"></a>
     </td>
   </tr>
+  <tr>
+    <td>Badge</td>
+    <td>
+       <a href="https://img.shields.io/badge/%F0%9D%94%BE%3D%7B%F0%9D%95%8D%2C%F0%9D%94%BC%7D-Graphinate-darkviolet"><img alt="Graphinate" src="https://img.shields.io/badge/%F0%9D%94%BE%3D%7B%F0%9D%95%8D%2C%F0%9D%94%BC%7D-Graphinate-darkviolet"></a>
+    </td>
+  </tr>
 </table>
 
----------------------
-
 ## Introduction
 
 ### What is Graphinate?

graphinate-0.5.0/examples/math/graph_atlas.py

@@ -0,0 +1,69 @@
+import operator
+
+import graphs
+import networkx as nx
+
+import graphinate
+from graphinate.materializers import Materializers
+
+
+def model(items: list[tuple[str, nx.Graph]]) -> graphinate.GraphModel:
+    """
+    Generate a graph model based on the provided iterable of graphs.
+    The function creates a graph model named 'Graph Atlas' using the 'graphinate' library.
+    It then combines all the graphs from the input iterable into a single disjoint union graph using NetworkX library.
+    The function defines edges for the combined graph by iterating over all edges in the disjoint union graph and
+    yielding dictionaries with 'source' and 'target' keys representing the edge connections.
+    Finally, the function yields the created graph model containing the combined graph with defined edges.
+
+    Args:
+        items: A list containing graphs to be combined into a single graph model.
+
+    Yields:
+        GraphModel: A graph model containing the combined graph with defined edges.
+    """
+
+    def items_iter(recs):
+        for name, g in recs:
+            print(name)
+            yield g
+
+    g = nx.disjoint_union_all(items_iter(items)) if len(items) > 1 else items[0][1]
+
+    graph_model = graphinate.model('Graph Atlas')
+
+    @graph_model.node(operator.itemgetter(1),
+                      key=operator.itemgetter(0),
+                      value=operator.itemgetter(0))
+    def nodes():
+        yield from g.nodes(data='type')
+
+    @graph_model.edge(operator.itemgetter(2),
+                      source=operator.itemgetter(0),
+                      target=operator.itemgetter(1),
+                      label=operator.itemgetter(0, 1),
+                      value=operator.itemgetter(0, 1))
+    def edge():
+        yield from g.edges.data('type')
+
+    return graph_model
+
+
+if __name__ == '__main__':
+    from gui import ListboxChooser, RadiobuttonChooser
+
+    graph_atlas = graphs.atlas()
+
+    listbox_chooser = ListboxChooser('Choose Graph', graph_atlas)
+    choices = list(listbox_chooser.get_choices())
+    model = model(choices)
+
+    # or
+    # model(graph_atlas.values())
+
+    radiobutton_chooser = RadiobuttonChooser('Choose Materializer',
+                                             options={m.name: m.value for m in Materializers},
+                                             default=(None, None))
+    result = radiobutton_chooser.get_choice()
+    builder, handler = result[1]
+    graphinate.materialize(model, builder=builder, builder_output_handler=handler)

{graphinate-0.4.0 → graphinate-0.5.0}/examples/math/graphs.py

@@ -1,4 +1,5 @@
 import itertools
+import re
 from collections.abc import Iterable
 from typing import NewType
 
@@ -692,18 +693,20 @@ SPECIAL_GRAPHS_ADJACENCY_LISTS = {
 AdjacencyList = NewType('AdjacencyList', dict[int, list[int]])
 
 
-def ladder_ring_graph(size: int):
-    ring = nx.ladder_graph(size)
-    ring.add_edge(size, size * 2 - 1)
-    ring.add_edge(0, size - 1)
-    return ladder_ring_graph
+def ladder_ring_graph(size: int) -> nx.Graph:
+    g: nx.Graph = nx.ladder_graph(size)
+    g.add_edge(size, size * 2 - 1)
+    g.add_edge(0, size - 1)
+    g.name = f'Ladder Ring[{size}]'
+    return g
 
 
-def ladder_mobius_graph(size: int):
-    mobius = nx.ladder_graph(size)
-    mobius.add_edge(size, size - 1)
-    mobius.add_edge(0, size * 2 - 1)
-    return mobius
+def ladder_mobius_graph(size: int) -> nx.Graph:
+    g = nx.ladder_graph(size)
+    g.add_edge(size, size - 1)
+    g.add_edge(0, size * 2 - 1)
+    g.name = f'Ladder Möbius Ring[{size}]'
+    return g
 
 
 def _cylinder_edges(circumference: int, length: int) -> Iterable[tuple[int, int]]:
@@ -721,7 +724,9 @@ def _cylinder_edges(circumference: int, length: int) -> Iterable[tuple[int, int]
 
 
 def cylinder_graph(circumference: int, length: int) -> nx.Graph:
-    return nx.Graph(_cylinder_edges(circumference, length))
+    g = nx.Graph(_cylinder_edges(circumference, length))
+    g.name = f'Cylinder[circumference={circumference},length={length}]'
+    return g
 
 
 def _spiral_edges(n, k) -> Iterable[tuple[int, int]]:
@@ -733,7 +738,9 @@ def _spiral_edges(n, k) -> Iterable[tuple[int, int]]:
 
 
 def spiral_graph(n, k) -> nx.Graph:
-    return nx.Graph(_spiral_edges(n, k))
+    g = nx.Graph(_spiral_edges(n, k))
+    g.name = f'Spiral[n={n},k={k}]'
+    return g
 
 
 def _spiral_torus_edges(n, k) -> Iterable[tuple[int, int]]:
@@ -744,7 +751,20 @@ def _spiral_torus_edges(n, k) -> Iterable[tuple[int, int]]:
 
 
 def spiral_torus_graph(n, k) -> nx.Graph:
-    return nx.Graph(_spiral_torus_edges(n, k))
+    g = nx.Graph(_spiral_torus_edges(n, k))
+    g.name = f'Spiral Torus[n={n},k={k}]'
+    return g
+
+
+def k_regular_edges(n, k) -> Iterable[tuple[int, int]]:
+    yield from itertools.chain.from_iterable(
+        ((i, j) for j in range(i + 1, i + k + 1))
+        for i in range(n-k))
+
+def k_regular_graph(n, k) -> nx.Graph:
+    g = nx.Graph(k_regular_edges(n, k))
+    g.name = f'Generalized Buckyball[n={n},k={k}]'
+    return g
 
 
 def adjacency_edges(adjacency_list: AdjacencyList) -> Iterable[tuple[int, int]]:
@@ -786,23 +806,57 @@ def atlas():
     """
 
     graph_atlas = {
+        'Triangle': nx.cycle_graph(3),
+        'Square': nx.cycle_graph(4),
+        'Square Lattice[3,3]': nx.grid_2d_graph(3, 3),
+        'Pentagon': nx.cycle_graph(5),
+        'Hexagon': nx.cycle_graph(6),
+        'Heptagon': nx.cycle_graph(7),
+        'Octagon': nx.cycle_graph(8),
         'Tetrahedron': nx.tetrahedral_graph(),
         'Cube': nx.hypercube_graph(3),
         'Octahedron': nx.octahedral_graph(),
         'Dodecahedron': nx.dodecahedral_graph(),
         'Icosahedron': nx.icosahedral_graph(),
         'Tesseract': nx.hypercube_graph(4),
+        'Hypercube[5]': nx.hypercube_graph(5),
         'Truncated Cube': nx.truncated_cube_graph(),
         'Truncated Tetrahedron': nx.truncated_tetrahedron_graph(),
-        'Ladder': nx.ladder_graph(16),
-        'Ring': ladder_ring_graph(16),
-        'Möbius': ladder_mobius_graph(16),
-        'Cylinder': cylinder_graph(6, 8),
-        'Spiral': spiral_graph(18, 8),
-        'Spiral Torus': spiral_torus_graph(128, 8),
-        'Circulant[10,[2]]': nx.circulant_graph(10, [2])
+        'Ladder[16]': nx.ladder_graph(16),
+        'Ladder Ring[16]': ladder_ring_graph(16),
+        'Ladder Möbius Ring[16]': ladder_mobius_graph(16),
+        'Cylinder[6,8]': cylinder_graph(6, 8),
+        'Spiral[128,8]': spiral_graph(128, 8),
+        'Spiral Torus[128,8]': spiral_torus_graph(128, 8),
+        'Chvátal': nx.chvatal_graph(),
+        'Circulant[10,[2]]': nx.circulant_graph(10, [2]),
+        'Desargues': nx.desargues_graph(),
+        'Dorogovtsev-Goltsev-Mendes[4]': nx.dorogovtsev_goltsev_mendes_graph(4),
+        'Frucht': nx.frucht_graph(),
+        'Heawood': nx.heawood_graph(),
+        'Hoffman-Singleton': nx.hoffman_singleton_graph(),
+        # 'Margulis-Gabber-Galil[8]': nx.margulis_gabber_galil_graph(8),
+        'Papus': nx.pappus_graph(),
+        'Petersen': nx.petersen_graph(),
+        'Sedgewick Maze': nx.sedgewick_maze_graph(),
+        'Tutte': nx.tutte_graph(),
     }
 
     graph_atlas.update(special_graphs())
 
+    def clean(s: str):
+        # Remove invalid characters
+        s = re.sub('[^0-9a-zA-Z_]', '_', s)
+
+        # Remove leading characters until we find a letter or underscore
+        s = re.sub('^[^a-zA-Z_]+', '', s)
+
+        return s
+
+    for name, g in graph_atlas.items():
+        _type = clean(name).capitalize()
+        nx.set_node_attributes(g, _type, 'type')
+        nx.set_edge_attributes(g, _type, 'type')
+
     return graph_atlas
+

graphinate-0.5.0/examples/math/gui.py

@@ -0,0 +1,108 @@
+import platform
+import tkinter as tk
+from tkinter import ttk
+
+
+class ModalWindow(tk.Tk):
+    def __init__(self, title: str):
+        super().__init__()
+        self.title(title)
+        self.configure_window()
+
+    def configure_window(self):
+        if platform.system().lower() == 'windows':
+            self.wm_attributes('-toolwindow', 'True')
+        self.wm_attributes('-topmost', 'True')
+        self.resizable(False, False)
+
+
+class RadiobuttonChooser(ModalWindow):
+    """
+    Usage Example:
+    ```python
+    radiobutton_chooser = RadiobuttonChooser("Choose an option", {"Option 1": 1, "Option 2": 2})
+    choice, value = radiobutton_chooser.get_choice()
+    print(choice, value)
+    ```
+    """
+
+    def __init__(self, window_title: str, options: dict, default=None):
+        super().__init__(window_title)
+        self.exit_button = None
+        self.choice_var = tk.StringVar(self, None)
+        self.default = default
+        self.options = options
+        self.create_widgets()
+        self.mainloop()
+
+    def create_widgets(self):
+        frame = ttk.Frame(self, borderwidth=5, relief='solid')
+        frame.pack(padx=4, pady=4)
+
+        ttk.Label(frame, text="Output Mode:").pack()
+
+        for option in self.options:
+            ttk.Radiobutton(
+                frame,
+                text=option,
+                variable=self.choice_var,
+                value=option,
+                command=self.enable_exit_button,
+                padding=4
+            ).pack(side=tk.TOP, anchor="w")
+
+        self.exit_button = ttk.Button(self, text="OK", command=self.destroy, state=tk.DISABLED)
+        self.exit_button.pack(pady=4, side=tk.BOTTOM)
+
+    def enable_exit_button(self):
+        self.exit_button['state'] = tk.NORMAL
+
+    def get_choice(self):
+        return self.choice_var.get(), self.options.get(self.choice_var.get(), self.default)
+
+
+class ListboxChooser(ModalWindow):
+    """
+    Usage Example:
+
+    ```python
+    listbox_chooser = ListboxChooser("Choose options", {"Option 1": 1, "Option 2": 2, "Option 3": 3})
+    for choice, value in listbox_chooser.get_choices():
+    print(choice, value)
+    ```
+    """
+
+    def __init__(self, window_title: str, options: dict, default=None):
+        super().__init__(window_title)
+        self.exit_button = None
+        self.choices = list(options.keys())
+        self.options = options
+        self.default = default
+        self.selection_var = tk.Variable(self)
+        self.create_widgets()
+        self.mainloop()
+
+    def create_widgets(self):
+        frame = ttk.Frame(self)
+        frame.pack(padx=2, pady=2)
+
+        listbox = tk.Listbox(frame, listvariable=tk.Variable(self, value=self.choices), selectmode="multiple",
+                             height=min(len(self.choices), 50), width=max(len(c) for c in self.choices))
+        listbox.pack(side=tk.LEFT, fill=tk.BOTH)
+
+        scrollbar = ttk.Scrollbar(frame, command=listbox.yview)
+        scrollbar.pack(side=tk.RIGHT, fill=tk.BOTH)
+        listbox.config(yscrollcommand=scrollbar.set)
+
+        listbox.bind("<<ListboxSelect>>", self.on_select)
+
+        self.exit_button = ttk.Button(self, text="OK", command=self.destroy, state=tk.DISABLED)
+        self.exit_button.pack(pady=4, side=tk.BOTTOM)
+
+    def on_select(self, event):
+        self.exit_button['state'] = tk.NORMAL
+        self.selection_var.set(event.widget.curselection())
+
+    def get_choices(self):
+        for choice in self.selection_var.get():
+            yield self.choices[choice], self.options.get(self.choices[choice], self.default)

{graphinate-0.4.0 → graphinate-0.5.0}/examples/web/page_links.py

@@ -1,4 +1,4 @@
-from urllib.parse import urljoin, urlparse
+from urllib.parse import urlparse
 
 import requests
 from bs4 import BeautifulSoup
@@ -28,13 +28,17 @@ def page_links_graph_model(max_depth: int = DEFAULT_MAX_DEPTH):
         for link in soup.find_all('a', href=True):
             child_url = link.get('href')
 
-            if child_url.startswith('javascript:'):
+            if child_url.startswith('javascript:'):  # Skip JavaScript links
                 continue
-            elif child_url.startswith('//'):
+
+            if child_url.startswith('//'):  # Handle protocol-relative URLs
                 child_url = f"https:{child_url}"
-            elif not bool(urlparse(child_url).netloc):
-                child_url = urljoin(url, child_url)
-            elif not child_url.startswith('http'):
+
+            if not bool(urlparse(child_url).netloc):  # Skip relative URLs
+                # child_url = urljoin(url, child_url)
+                continue
+
+            if not child_url.startswith('http'):  # Skip non-HTTP URLs
                 continue
 
             yield {'source': url, 'target': child_url}
@@ -62,7 +66,7 @@ if __name__ == '__main__':
         model=model,
         graph_type=graphinate.GraphType.DiGraph,
         default_node_attributes={'type': 'url'},
-        builder=graphinate.builders.NetworkxBuilder,
-        builder_output_handler=graphinate.materializers.matplotlib.plot,
+        builder=graphinate.builders.GraphQLBuilder,
+        builder_output_handler=graphinate.graphql,
         **params
     )

{graphinate-0.4.0 → graphinate-0.5.0}/pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name = "Graphinate"
-version = "0.4.0"
+version = "0.5.0"
 authors = [
     { name = "Eran Rivlis", email = "eran@rivlis.info" },
 ]
-description = "Graphinate. Data to Graphs."
+description = "𝔾raphinate. Data to Graphs."
 readme = "README.md"
 requires-python = ">=3.10"
 classifiers = [

{graphinate-0.4.0 → graphinate-0.5.0}/src/graphinate/builders.py

@@ -203,7 +203,7 @@ class NetworkxBuilder(Builder):
             if node_type == 'tuple':
                 node_type = node_model.type.lower()
 
-            logger.debug("Adding node: '{}'", node_id)
+            logger.debug("Adding node: '{}'", node.value)
 
             if node_id in self._graph:
                 self._graph.nodes[node_id]['value'].append(node.value)
@@ -231,16 +231,16 @@ class NetworkxBuilder(Builder):
             self._populate_node_type(node_model.type, **new_kwargs)
 
     def _populate_edges(self, **kwargs):
-        for edge_type, edge_generators in self.model.edge_generators.items():
+        for edge_model, edge_generators in self.model.edge_generators.items():
             for edge_generator in edge_generators:
                 for edge in edge_generator(**kwargs):
                     edge_id = ((edge.source,), (edge.target,))
                     edge_weight = edge.weight or 1.0
-                    logger.debug("Adding edge from: '{}' to: '{}'", edge.source, edge.target)
+                    edge_type = edge.type.lower()
+                    logger.debug("Adding edge from: '{}' to: '{}'", *edge_id)
 
                     if isinstance(self._graph, nx.MultiGraph) or edge_id not in self._graph.edges:
-                        self._graph.add_edge((edge.source,),
-                                             (edge.target,),
+                        self._graph.add_edge(*edge_id,
                                              label=edge.label,
                                              type=edge_type,
                                              value=[edge.value],

{graphinate-0.4.0 → graphinate-0.5.0}/src/graphinate/modeling.py

@@ -4,7 +4,7 @@ from collections.abc import Callable, Iterable, Mapping
 from dataclasses import dataclass
 from typing import Any, Optional, Union
 
-from .typing import Edge, Edges, Element, Extractor, Items, Node, Nodes, NodeTypeAbsoluteId, UniverseNode
+from .typing import Edge, Element, Extractor, Items, Node, NodeTypeAbsoluteId, UniverseNode
 
 
 class GraphModelError(Exception):
@@ -59,17 +59,14 @@ def elements(iterable: Iterable[Any],
     Returns:
         Iterable of Elements.
     """
+    for item in iterable:
+        _type = element_type(item) if element_type and callable(element_type) else element_type
+        if not _type.isidentifier():
+            raise ValueError(f"Invalid Type: {_type}. Must be a valid Python identifier.")
 
-    if element_type and callable(element_type):
-        for item in iterable:
-            create_element = element(element_type(item), getters.keys())
-            kwargs = {k: extractor(item, v) for k, v in getters.items()}
-            yield create_element(**kwargs)
-    else:
-        create_element = element(element_type, getters.keys())
-        for item in iterable:
-            kwargs = {k: extractor(item, v) for k, v in getters.items()}
-            yield create_element(**kwargs)
+        create_element = element(_type, getters.keys())
+        kwargs = {k: extractor(item, v) for k, v in getters.items()}
+        yield create_element(**kwargs)
 
 
 @dataclass
@@ -92,7 +89,7 @@ class NodeModel:
     parent_type: Optional[str] = UniverseNode
     uniqueness: bool = False
     parameters: set[str] | None = None
-    generator: Nodes | None = None
+    generator: Callable[[], Iterable[Node]] | None = None
     label: Callable[[Any], str | None] = None
 
     @property
@@ -114,7 +111,7 @@ class GraphModel:
         self.name: str = name
         self._node_models: dict[NodeTypeAbsoluteId, NodeModel] = {}
         self._node_children: dict[str, list[str]] = defaultdict(list)
-        self._edge_generators: dict[str, list[Edges]] = defaultdict(list)
+        self._edge_generators: dict[str, list[Callable[[], Iterable[Edge]]]] = defaultdict(list)
         self._networkx_graph = None
 
     def __add__(self, other: 'GraphModel'):
@@ -225,7 +222,7 @@ class GraphModel:
         return register_node
 
     def edge(self,
-             _type: Optional[str] = None,
+             _type: Optional[Extractor] = None,
              source: Extractor = 'source',
              target: Extractor = 'target',
              label: Optional[Extractor] = str,
@@ -252,6 +249,8 @@ class GraphModel:
             edge_type = _type or f.__name__
             self._validate_type(edge_type)
 
+            model_type = f.__name__ if callable(edge_type) else edge_type
+
             getters = {
                 'source': source,
                 'target': target,
@@ -264,7 +263,7 @@ class GraphModel:
             def edge_generator(**kwargs) -> Iterable[Edge]:
                 yield from elements(f(**kwargs), edge_type, **getters)
 
-            self._edge_generators[edge_type].append(edge_generator)
+            self._edge_generators[model_type].append(edge_generator)
 
         return register_edge
 

graphinate-0.5.0/src/graphinate/server/web/static/images/logo.svg

@@ -0,0 +1,50 @@
+<svg width="200" height="200" xmlns="http://www.w3.org/2000/svg">
+    <!-- Filters for shadow -->
+    <defs>
+        <filter id="circle-shadow" x="-50%" y="-50%" width="200%" height="500%">
+            <feDropShadow dx="6" dy="6" stdDeviation="1" flood-color="rgba(0, 0, 0, 0.8)"/>
+        </filter>
+        <filter id="text-shadow" x="-50%" y="-50%" width="200%" height="500%">
+            <feDropShadow dx="5" dy="5" stdDeviation="1" flood-color="rgba(0, 0, 0, 0.6)"/>
+        </filter>
+    </defs>
+
+    <text x="10" y="30"
+          font-family="serif"
+          font-size="40"
+          font-weight="500"
+          fill="darkviolet"
+          stroke="indigo"
+          stroke-width="0.5"
+          filter="url(#text-shadow)">&#120126;raphinate
+    </text>
+    <!-- Background -->
+    <!--rect width="100%" height="100%" fill="#2E004F" /-->
+
+    <!-- Circle with shadow -->
+    <circle cx="100" cy="100" r="60" fill="indigo" stroke="rebeccapurple" stroke-width="0.5"
+            filter="url(#circle-shadow)"/>
+    <!-- Double-struck G with shadow -->
+    <text x="99" y="113"
+          font-family="serif"
+          font-size="108"
+          fill="darkviolet"
+          text-anchor="middle"
+          stroke="indigo"
+          stroke-width="0.5"
+          alignment-baseline="middle"
+          filter="url(#text-shadow)">
+        &#120126;
+    </text>
+
+
+        <text x="10" y="190"
+          font-family="serif"
+          font-size="40"
+          font-weight="500"
+          fill="darkviolet"
+          stroke="indigo"
+          stroke-width="0.5"
+          filter="url(#text-shadow)">&#120126;raphinate
+    </text>
+</svg>