Graphinate 0.5.1__tar.gz → 0.7.0__tar.gz

{graphinate-0.5.1 → graphinate-0.7.0}/.github/workflows/publish.yml

@@ -28,7 +28,7 @@ jobs:
     - name: Build package
       run: python -m build
     - name: Publish package
-      uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29
+      uses: pypa/gh-action-pypi-publish@76f52bc884231f62b9a034ebfe128415bbaabdfc
       with:
         user: __token__
         password: ${{ secrets.PYPI_API_TOKEN }}

{graphinate-0.5.1 → graphinate-0.7.0}/.github/workflows/test.yml

@@ -40,7 +40,7 @@ jobs:
           python -m pip install faker pytest pytest-asyncio pytest-cov pytest-randomly pytest-xdist starlette-prometheus uvicorn[standard]
           pytest tests --cov=src --cov-branch --cov-report=xml --junitxml=test_results.xml -n auto
       - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v4
+        uses: codecov/codecov-action@v5
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
       - name: Run codacy-coverage-reporter

{graphinate-0.5.1 → graphinate-0.7.0}/.gitignore

@@ -781,4 +781,5 @@ cython_debug/
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
 
-/.idea/**
+/.idea/**
+.qodo

{graphinate-0.5.1 → graphinate-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Graphinate
-Version: 0.5.1
+Version: 0.7.0
 Summary: 𝔾raphinate. Data to Graphs.
 Project-URL: Homepage, https://erivlis.github.io/graphinate
 Project-URL: Documentation, https://erivlis.github.io/graphinate
@@ -30,6 +30,7 @@ Requires-Python: >=3.10
 Requires-Dist: click
 Requires-Dist: inflect
 Requires-Dist: loguru
+Requires-Dist: mappingtools
 Requires-Dist: matplotlib
 Requires-Dist: networkx
 Requires-Dist: strawberry-graphql[asgi,opentelemetry]
@@ -221,6 +222,8 @@ Options:
 
 #### Server
 
+> TIP: requires the `server` extra to be installed. e.g., `pip install graphinate[server]`
+
 ```text
 Usage: python -m graphinate server [OPTIONS]
 

{graphinate-0.5.1 → graphinate-0.7.0}/README.md

@@ -179,6 +179,8 @@ Options:
 
 #### Server
 
+> TIP: requires the `server` extra to be installed. e.g., `pip install graphinate[server]`
+
 ```text
 Usage: python -m graphinate server [OPTIONS]
 

graphinate-0.7.0/docs/examples/social.md

@@ -0,0 +1,15 @@
+# Social
+
+## Music
+
+=== "Music"
+
+    ``` python title="examples/social/music.py" linenums="1"
+    --8<-- "examples/social/music.py"
+    ```
+
+=== "Dependencies"
+
+    ``` text title="examples/social/requirements.txt" linenums="1"
+    --8<-- "examples/social/requirements.txt"
+    ```

{graphinate-0.5.1 → graphinate-0.7.0}/docs/intro.md

@@ -15,21 +15,25 @@ In addition, there are several modes of output to enable examination of the Grap
 
 ### What is a Graph?
 
-“In a mathematician's terminology, a graph is a collection of points and lines connecting some (possibly empty) subset
-of them.
-The points of a graph are most commonly known as graph *vertices*, but may also be called *nodes* or *points*.
-Similarly, the lines connecting the vertices of a graph are most commonly known as graph *edges*, but may also
-be called *arcs* or *lines*.”
+!!! quote
 
-— [https://mathworld.wolfram.com/Graph.html](https://mathworld.wolfram.com/Graph.html)
+    “In a mathematician's terminology, a graph is a collection of points and lines connecting some (possibly empty) subset
+    of them.
+    The points of a graph are most commonly known as graph *vertices*, but may also be called *nodes* or *points*.
+    Similarly, the lines connecting the vertices of a graph are most commonly known as graph *edges*, but may also
+    be called *arcs* or *lines*.”
+
+    — [https://mathworld.wolfram.com/Graph.html](https://mathworld.wolfram.com/Graph.html)
 
 ### What is Data?
 
-“...data is a collection of discrete or continuous values that convey information, describing the quantity, quality,
-fact, statistics, other basic units of meaning, or simply sequences of symbols that may be further interpreted
-formally.”
+!!! quote
 
-— [https://en.wikipedia.org/wiki/Data](https://en.wikipedia.org/wiki/Data)
+    “...data is a collection of discrete or continuous values that convey information, describing the quantity, quality,
+    fact, statistics, other basic units of meaning, or simply sequences of symbols that may be further interpreted
+    formally.”
+   
+    — [https://en.wikipedia.org/wiki/Data](https://en.wikipedia.org/wiki/Data)
 
 ## How?
 

{graphinate-0.5.1 → graphinate-0.7.0}/docs/usage/cli.md

@@ -28,6 +28,14 @@ Options:
 
 ### Server
 
+!!! tip
+
+    requires the `server` extra to be installed.
+
+      ```shell
+      pip install graphinate[server]
+      ```
+
 ```console
 Usage: python -m graphinate server [OPTIONS]
 

graphinate-0.7.0/examples/code/html_dom.py

@@ -0,0 +1,61 @@
+import base64
+
+import requests
+from bs4 import BeautifulSoup, Tag
+
+import graphinate
+
+
+def load_html_from_url(url="https://www.google.com"):
+    response = requests.get(url)
+    return response.text
+
+
+def load_html(file_path):
+    with open(file_path) as file:
+        return file.read()
+
+
+def html_dom_graph_model(html_content):
+    graph_model = graphinate.model(name="HTML DOM Graph")
+    soup = BeautifulSoup(html_content, 'html.parser')
+
+    def node_type(tag: Tag):
+        return tag.name.strip('[]')
+
+    def node_key(tag: Tag):
+        return str((tag.sourceline, tag.sourcepos)) if isinstance(tag, Tag) else base64.b64encode(
+            tag.encode()).decode()
+
+    def node_label(tag: Tag):
+        return str(tag)
+
+    @graph_model.node(node_type, key=node_key, label=node_label)
+    def html_node():
+        for tag in soup.descendants:
+            if tag.name is not None:
+                yield tag
+
+    @graph_model.edge()
+    def contains():
+        for tag in soup.descendants:
+            if tag.name is not None:
+                for child in tag.children:
+                    if child.name is not None:
+                        yield {
+                            'source': node_key(tag),
+                            'target': node_key(child)
+                        }
+
+    return graph_model
+
+
+if __name__ == '__main__':
+    html_content = load_html_from_url()
+    dom_model = html_dom_graph_model(html_content)
+    graphinate.materialize(
+        dom_model,
+        builder=graphinate.builders.GraphQLBuilder,
+        builder_output_handler=graphinate.graphql
+    )
+

{graphinate-0.5.1 → graphinate-0.7.0}/examples/code/python_ast.py

@@ -79,14 +79,14 @@ def ast_graph_model():
     def target(value):
         return endpoint(value, 'target')
 
-    @graph_model.node(_type=node_type,
+    @graph_model.node(type_=node_type,
                       key=key,
                       label=node_label,
-                      uniqueness=True)
+                      unique=True)
     def ast_node(**kwargs):
         yield from _ast_nodes([root_ast_node])
 
-    @graph_model.edge(_type='edge',
+    @graph_model.edge(type_='edge',
                       source=source,
                       target=target,
                       label=operator.itemgetter('type'))

graphinate-0.7.0/examples/code/tokens.py

@@ -0,0 +1,53 @@
+import itertools
+import operator
+import sys
+
+from pygments import lex
+from pygments.lexers import guess_lexer_for_filename
+
+import graphinate
+
+
+def load_file(file_path):
+    with open(file_path) as file:
+        return file.read()
+
+
+def tokenize_file(file_path):
+    content = load_file(file_path)
+    lexer = guess_lexer_for_filename(file_path, content)
+    return lex(content, lexer)
+
+
+def token_graph_model(file_path):
+    graph_model = graphinate.model(name="Token Graph")
+
+    def token_type(v):
+        return str(v[0]).replace('.', '_')
+
+    def token_key(v):
+        return f"{v[0]}-{v[1]}"
+
+    @graph_model.node(token_type, key=token_key)
+    def token():
+        yield from tokenize_file(file_path)
+
+    @graph_model.edge(source=operator.itemgetter(0), target=operator.itemgetter(1))
+    def edge():
+        yield from itertools.pairwise(token_key(t) for t in tokenize_file(file_path))
+
+    return graph_model
+
+
+if __name__ == '__main__':
+    if len(sys.argv) != 2:
+        print("Usage: python tokens.py <file_path>")
+        sys.exit(1)
+
+    file_path = sys.argv[1]
+    token_model = token_graph_model(file_path)
+    graphinate.materialize(
+        token_model,
+        builder=graphinate.builders.GraphQLBuilder,
+        builder_output_handler=graphinate.graphql
+    )

{graphinate-0.5.1 → graphinate-0.7.0}/examples/github/repositories.py

@@ -18,7 +18,7 @@ def repo_graph_model():  # noqa: C901
 
     graph_model = graphinate.model(name='GitHub Repository Graph')
 
-    @graph_model.edge
+    @graph_model.edge()
     def github(user_id: Optional[str] = None,
                repository_id: Optional[str] = None,
                commit_id: Optional[str] = None,
@@ -56,7 +56,7 @@ def repo_graph_model():  # noqa: C901
                                    label=commit_label)
 
     file_node = graph_model.node(parent_type='commit',
-                                 uniqueness=True,
+                                 unique=True,
                                  key=operator.attrgetter('filename'),
                                  value=operator.attrgetter('raw_data'),
                                  label=operator.itemgetter('filename'))

{graphinate-0.5.1 → graphinate-0.7.0}/examples/math/graph_atlas.py

@@ -38,13 +38,9 @@ def model(items: list[tuple[str, nx.Graph]]) -> graphinate.GraphModel:
     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))
+    @graph_model.edge(operator.itemgetter('type'))
     def edge():
-        yield from g.edges.data('type')
+        yield from ({'source': e[0], 'target': e[1], **e[2]} for e in g.edges.data())
 
     return graph_model
 
@@ -54,7 +50,7 @@ if __name__ == '__main__':
 
     graph_atlas = graphs.atlas()
 
-    listbox_chooser = ListboxChooser('Choose Graph', graph_atlas)
+    listbox_chooser = ListboxChooser('Choose Graph/s', graph_atlas)
     choices = list(listbox_chooser.get_choices())
     model = model(choices)
 

graphinate-0.7.0/examples/math/requirements.txt

@@ -0,0 +1,2 @@
+graphinate
+networkx

graphinate-0.7.0/examples/social/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.7.0/examples/social/music_artists.py

@@ -0,0 +1,149 @@
+import logging
+import operator
+import pathlib
+from functools import reduce
+from time import sleep
+
+import diskcache
+import musicbrainzngs
+
+import graphinate
+
+# logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def initialize_musicbrainz():
+    musicbrainzngs.set_useragent(
+        "MusicArtistGraph",
+        "0.1.0",
+        "https://github.com/erivlis/graphinate"
+    )
+
+
+initialize_musicbrainz()
+
+
+def cache_dir():
+    current_script_path = pathlib.Path(__file__).resolve()
+    parent_dir = current_script_path.parent
+    return (parent_dir / 'cache').as_posix()
+
+
+def music_graph_model(name: str, max_depth: int = 0):
+    graph_model = graphinate.model(f"{name.capitalize()} Graph")
+
+    artists_cache = diskcache.Cache(directory=cache_dir(), eviction_policy='none')
+
+    result = musicbrainzngs.search_artists(query=name, strict=True, artist=name)
+    sleep(1)
+    root_artist = result.get('artist-list', [])[0] if result else None
+
+    def artists(parent_artist, artist, depth):
+        logger.info(f"Current depth: {depth}")
+        artist_id = artist.get('id')
+        if artist_id not in artists_cache:
+            artists_cache[artist_id] = musicbrainzngs.get_artist_by_id(id=artist_id, includes=['artist-rels']).get(
+                'artist')
+            sleep(0.1)
+
+        artist = artists_cache.get(artist_id)
+
+        yield parent_artist, artist
+
+        if depth < max_depth:
+            related_artist_ids = set()
+            for item in artist.get('artist-relation-list', []):
+                related_artist = item.get('artist')
+                related_artist_id = related_artist.get('id')
+                if related_artist_id not in related_artist_ids:
+                    related_artist_ids.add(related_artist_id)
+                    yield from artists(artist, related_artist, depth + 1)
+
+    def artist_type(value):
+        return value.get('type', '_UNKNOWN_')
+
+    @graph_model.node(artist_type,
+                      key=operator.itemgetter('id'),
+                      label=operator.itemgetter('name'),
+                      multiplicity=graphinate.Multiplicity.FIRST)
+    def node():
+        yielded = set()
+        for a, b in artists(None, root_artist, 0):
+            if a and ((a_id := a.get('id')) not in yielded):
+                yielded.add(a_id)
+                yield a
+            if b and ((b_id := b.get('id')) not in yielded):
+                yielded.add(b_id)
+                yield b
+
+    @graph_model.edge()
+    def edge():
+        for a, b in artists(None, root_artist, 0):
+            if a:
+                yield {'source': a.get('id'), 'target': b.get('id')}
+
+    return graph_model
+
+
+if __name__ == '__main__':
+    from gui import ListboxChooser
+
+    artist_names = [
+        'Alice in Chains',
+        'Beatles',
+        'Caravan',
+        'Charles Mingus',
+        'Dave Brubeck',
+        'Dave Douglas',
+        'David Bowie',
+        'Deep Purple',
+        'Dire Straits',
+        'Emerson, Lake & Palmer',
+        'Foo Fighters',
+        'Frank Zappa',
+        'Genesis',
+        'Gentle Giant',
+        'Herbie Hancock',
+        'Jethro Tull',
+        'John Coltrane',
+        'John Scofield',
+        'John Zorn',
+        'Ken Vandermark',
+        'King Crimson',
+        'Led Zeppelin',
+        'Mahavishnu Orchestra',
+        'Miles Davis',
+        'Nirvana',
+        'Ornette Coleman',
+        'Paul McCartney',
+        'Pearl Jam',
+        'Pink Floyd',
+        'Police',
+        'Porcupine Tree',
+        'Radiohead',
+        'Red Hot Chili Peppers',
+        'Return to Forever',
+        'Rush',
+        'Smashing Pumpkins',
+        'Soft Machine',
+        'Soundgarden',
+        'Stone Temple Pilots',
+        'System of a Down',
+        'Thelonious Monk',
+        'Weather Report',
+        'Wings',
+        'Yes',
+    ]
+
+    listbox_chooser = ListboxChooser('Choose Artist/s', {name: name for name in artist_names})
+
+    models = (music_graph_model(a, 2) for _, a in listbox_chooser.get_choices())
+
+    model = reduce(operator.add, models)
+
+    graphinate.materialize(
+        model,
+        builder=graphinate.builders.GraphQLBuilder,
+        builder_output_handler=graphinate.graphql
+    )

graphinate-0.7.0/examples/social/requirements.txt

@@ -0,0 +1,3 @@
+diskcache
+graphinate
+musicbrainzngs