smallgraphlib 0.6.2__tar.gz → 0.7.1__tar.gz

{smallgraphlib-0.6.2 → smallgraphlib-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: smallgraphlib
-Version: 0.6.2
+Version: 0.7.1
 Summary: Simple library for handling small graphs, including Tikz code generation.
 Home-page: https://github.com/wxgeo/smallgraphlib
 License: GPL-3.0-or-later
@@ -12,6 +12,7 @@ Classifier: License :: OSI Approved :: GNU General Public License v3 or later (G
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Project-URL: Repository, https://github.com/wxgeo/smallgraphlib
 Description-Content-Type: text/markdown
 

{smallgraphlib-0.6.2 → smallgraphlib-0.7.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "smallgraphlib"
-version = "0.6.2"
+version = "0.7.1"
 description = "Simple library for handling small graphs, including Tikz code generation."
 authors = ["Nicolas Pourcelot <nicolas.pourcelot@gmail.com>"]
 repository = "https://github.com/wxgeo/smallgraphlib"
@@ -11,7 +11,7 @@ keywords = ["graph", "tikz", "latex"]
 [tool.poetry.dependencies]
 python = "^3.10"
 
-[tool.poetry.dev-dependencies]
+[tool.poetry.group.dev.dependencies]
 pytest = "^7"
 mypy = "^1.0"
 flake8 = "^6"
@@ -22,13 +22,19 @@ sphinx-rtd-theme = "^1.0.0"#
 myst-parser = "^0.18.0"
 # To test compatibility with sympy.
 sympy = "^1.10.1"
+# Version 7.29+ are buggy !
+python-semantic-release = "7.28.1"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]
 build-backend = "poetry.core.masonry.api"
 
+[tool.semantic_release]
+version_variable = "pyproject.toml:version"
+
 [tool.mypy]
 implicit_optional = true
+warn_unused_ignores = true
 
 [tool.black]
 line-length = 110
@@ -46,5 +52,5 @@ commands =
     poetry run black smallgraphlib tests
     poetry run pytest tests
     poetry run mypy smallgraphlib tests
-    poetry run flake8 --max-line-length 110 --ignore=E203,W503,W391
+    poetry run flake8 --max-line-length 110 --ignore=E203,W503,W391 --per-file-ignores="tests/test_latex_export.py:E501"
 """

{smallgraphlib-0.6.2 → smallgraphlib-0.7.1}/smallgraphlib/core.py

@@ -231,6 +231,8 @@ class AbstractGraph(ABC, Generic[Node]):
         >>> g.is_isomorphic_to(g2)
         True
         """
+        # Sort nodes before shuffling, to make shuffling deterministic with a given random.seed.
+        # nodes = sorted(self.nodes)
         nodes = list(self.nodes)
         random.shuffle(nodes)
         self.rename_nodes(dict((old_name, new_name) for old_name, new_name in zip(self.nodes, nodes)))

smallgraphlib-0.7.1/smallgraphlib/huffman.py

@@ -0,0 +1,150 @@
+from collections import Counter
+from operator import attrgetter
+
+from smallgraphlib.custom_types import Node
+
+
+class Tree:
+    branches: tuple["Tree", ...]
+
+    def __init__(self, root: Node, *branches: "Tree") -> None:
+        self.root = root
+        self.branches = branches
+
+
+class HuffmanTree(Tree):
+    branches: tuple["HuffmanTree", ...]
+
+    def __init__(self, *branches: "HuffmanTree", char: str = None, weight: int = None) -> None:
+        if len(branches) == 2:
+            if char is not None or weight is not None:
+                raise ValueError("Char and weight can't be set, except for leaves.")
+        elif len(branches) == 0:
+            if char is None or weight is None:
+                raise ValueError("Char and weight must be set for leaves.")
+        else:
+            raise ValueError(f"There must be either 0 or 2 branches, not {len(branches)}.")
+        char = min(branch.char for branch in branches) if branches else char
+        weight = sum(branch.weight for branch in branches) if branches else weight
+        super().__init__((weight, char), *branches)
+
+    @classmethod
+    def from_text(cls, text: str) -> "HuffmanTree":
+        trees = {
+            HuffmanTree(char=letter, weight=occurrences) for letter, occurrences in Counter(text).items()
+        }
+        sort_func = attrgetter("root")
+        while len(trees) >= 2:
+            # Select the two smallest values
+            tree1 = min(trees, key=sort_func)
+            trees.remove(tree1)
+            tree2 = min(trees, key=sort_func)
+            trees.remove(tree2)
+            trees.add(HuffmanTree(tree1, tree2))
+        assert len(trees) == 1
+        return trees.pop()
+
+    @property
+    def weight(self):
+        return self.root[0]
+
+    @property
+    def char(self):
+        return self.root[1]
+
+    @property
+    def is_leaf(self) -> bool:
+        return len(self.branches) == 0
+
+    @property
+    def left_branch(self) -> "HuffmanTree":
+        return self.branches[0]
+
+    @property
+    def right_branch(self) -> "HuffmanTree":
+        return self.branches[1]
+
+    def compress(self, text: str) -> bytes:
+        compressed = []
+        buffer = ""
+        for char in text:
+            buffer += self.labels[char]
+            while len(buffer) >= 8:
+                compressed.append(sum(2**i * int(c) for i, c in enumerate(buffer[:8])))
+                buffer = buffer[8:]
+        # On finit de vider le buffer.
+        # Cela revient à ajouter des bits nuls, puisque le nombre de bits final doit
+        # être un multiple de 8 (on ne peut renvoyer que des octets complets).
+        # Si on voulait créer un logiciel de compression réellement utilisable, il faudrait donc
+        # soit avoir un caractère de fin de chaîne, soit préciser le nombre de bits finaux
+        # inutiles (entre 0 et 7).
+        # On pourrait par exemple décider que par convention les 3 premiers bits servent à encoder le
+        # nombre de bits finaux inutiles.
+        # Accessoirement, il faudrait aussi que la chaîne de caractères intègre le dictionnaire de compression
+        # en début de chaîne, et donc se mettre d'accord sur un format, etc.
+        if buffer:
+            compressed.append(sum(2**i * int(c) for i, c in enumerate(buffer[:8])))
+        return bytes(compressed)
+
+    def uncompress(self, bits: bytes) -> str:
+        position = self
+        read: list[str] = []
+        for byte in bits:
+            for i in range(8):
+                digit, byte = byte % 2, byte // 2
+                position = position.branches[digit]
+                if position.is_leaf:
+                    read.append(position.char)
+                    position = self
+        return "".join(read)
+
+    def decode(self, bits: str) -> str:
+        position = self
+        read: list[str] = []
+        for digit in bits:
+            position = position.branches[int(digit)]
+            if position.is_leaf:
+                read.append(position.char)
+                position = self
+        return "".join(read)
+
+    def encode(self, text: str) -> str:
+        return "".join(self.labels[char] for char in text)
+
+    @property
+    def labels(self) -> dict[str, str]:
+        """Binary labels."""
+        if self.is_leaf:
+            return {self.char: ""}
+        return {
+            key: str(i) + value
+            for i, branch in enumerate(self.branches)
+            for key, value in branch.labels.items()
+        }
+
+    def __repr__(self):
+        if self.is_leaf:
+            return f"HuffmanTree(char={self.char}, weight={self.weight})"
+        return f"HuffmanTree({self.left_branch!r}, {self.right_branch!r})"
+
+    def __str__(self):
+        lines = []
+        shift = len(str(self.weight)) + 1
+        for n, line in enumerate(str(self.left_branch).split("\n")):
+            if n == 0:
+                # lines.append("\u252C\u2500\u2500" + line)
+                lines.append(f"{self.weight}\u2500\u2500" + line)
+            else:
+                lines.append("\u2502" + shift * " " + line)
+        for n, line in enumerate(str(self.right_branch).split("\n")):
+            if n == 0:
+                lines.append("\u2514" + shift * "\u2500" + line)
+            else:
+                lines.append((shift + 1) * " " + line)
+        return "\n".join(lines)
+
+
+def encode(text: str) -> str:
+    """Return a string of `0` and `1` representing the bits of a text encoded using Huffman algorithm."""
+    tree = HuffmanTree.from_text(text)
+    return tree.encode(text)

smallgraphlib-0.7.1/smallgraphlib/latex_export.py

@@ -0,0 +1,108 @@
+import math
+from typing import Iterable
+
+from smallgraphlib.core import AbstractGraph
+from smallgraphlib.custom_types import Node
+
+
+def latex_Dijkstra(graph: AbstractGraph[Node], start: Node, end: Node = None) -> str:
+    """Generate the LaTeX code of a table corresponding to Dijkstra algorithm's steps.
+
+    If `end` is `None`, only stop when the shorter path to all other nodes have been found.
+    """
+    nodes = graph.nodes
+    num_cols = len(nodes) + 2
+    lines: list[str] = [
+        rf"\begin{{tabular}}{{|*{num_cols}{{c |}}}}\cline{{2-{num_cols}}}",
+        r"\multicolumn{1}{c|}{} & "
+        + " & ".join(sorted(f"${node}$" for node in nodes))
+        + r" & Selected\\\hline",
+    ]
+    # Nodes which have been already visited, but still not archived:
+    # visited: dict[Node, tuple[float, list[Node]]] = {start: (0, [start])}
+    # format: {node: [distance from start, [previous node, alternative previous node, ...]]}
+
+    previous_nodes: dict[Node, set[Node]] = {node: set() for node in graph.nodes}
+    distance_from_start: dict[Node, float] = {node: math.inf for node in graph.nodes}
+    being_processed: set[Node] = {start}
+    completed: set[Node] = set()
+    distance_from_start[start] = 0
+
+    # Nodes which will not change anymore (shorter path from start has been found):
+    # archived: dict[Node, tuple[float, list[Node]]] = {}
+
+    def cell_content(node: Node) -> str:
+        """Used to print the node in the table."""
+        dist = distance_from_start[node]
+        previous = previous_nodes[node]
+        if dist == math.inf:
+            return r"$+\infty$"
+        if node in completed:
+            return r"\cellcolor{lightgray}"
+        printing = str(dist)
+        if node != start:
+            printing += f" $({','.join(sorted(str(node) for node in previous))})$"
+        if node == current:
+            printing = rf"\cellcolor{{blue!20}}\textbf{{{printing}}}"
+        return printing
+
+    current: Node
+    first_cell = r"\text{start}"
+    while being_processed and end != (
+        current := min(being_processed, key=(lambda n: distance_from_start[n]))
+    ):
+        lines.append(
+            f"${first_cell}$ & "
+            + " & ".join(cell_content(node) for node in nodes)
+            + rf" & {current} {cell_content(current)}\\\hline"
+        )
+        first_cell = str(current)
+        being_processed.remove(current)
+        completed.add(current)
+        # We update the distances
+        for neighbor in graph.successors(current):
+            if neighbor not in completed:
+                being_processed.add(neighbor)
+                # best distance found until now between neighbor and start
+                current_distance = distance_from_start[neighbor]
+                # new distance found using current node:
+                new_distance = distance_from_start[current] + graph.weight(current, neighbor)
+                # replace with new distance only if better
+                if new_distance < current_distance:
+                    distance_from_start[neighbor] = new_distance
+                    previous_nodes[neighbor] = {current}
+                elif new_distance == current_distance:
+                    previous_nodes[neighbor].add(current)
+
+    lines.append("\\end{tabular}")
+    lines.append("")
+
+    def shortest_paths() -> str:
+        paths_in_construction = [[target]]
+        completed_paths = []
+        while paths_in_construction:
+            partial_path = paths_in_construction.pop()
+            assert len(partial_path) > 0
+            for previous in previous_nodes[partial_path[0]]:
+                if previous == start:
+                    completed_paths.append([previous] + partial_path)
+                else:
+                    paths_in_construction.append([previous] + partial_path)
+
+        def path_to_str(path: Iterable[Node]):
+            return "-".join(str(node) for node in path)
+
+        return ",".join(path_to_str(path) for path in completed_paths)
+
+    targets = list(nodes) if end is None else [end]
+
+    for target in targets:
+        if target != start:
+            distance = distance_from_start[target]
+            lines.append(
+                f"Shorter(s) path(s) from ${start}$ to ${target}$: "
+                f"${shortest_paths()}$ (length: {distance})."
+            )
+            lines.append("")
+
+    return "\n" + "\n".join(lines)

{smallgraphlib-0.6.2 → smallgraphlib-0.7.1}/smallgraphlib/tikz_export.py

@@ -212,7 +212,7 @@ class TikzPrinter(Generic[Node]):
             r"\usepackage{tikz}",
             r"\usetikzlibrary{arrows.meta}",
             r"\usepackage[outline]{contour}",
-            r"\contourlength{0.5pt}",
+            r"\contourlength{0.15em}",
         ]
 
     def tikz_code(self, graph, *, shuffle_nodes=False, options="") -> str:
@@ -226,7 +226,7 @@ class TikzPrinter(Generic[Node]):
         For labeled graphs, it is recommended to load `contour` package too::
 
             \usepackage[outline]{contour}
-            \contourlength{0.5pt}
+            \contourlength{0.15em}
 
         """
         self.graph = graph

smallgraphlib-0.6.2/setup.py

@@ -1,26 +0,0 @@
-# -*- coding: utf-8 -*-
-from setuptools import setup
-
-packages = \
-['smallgraphlib']
-
-package_data = \
-{'': ['*']}
-
-setup_kwargs = {
-    'name': 'smallgraphlib',
-    'version': '0.6.2',
-    'description': 'Simple library for handling small graphs, including Tikz code generation.',
-    'long_description': '# Small Graph Lib\n\n## Installing\n\n    $ git clone https://github.com/wxgeo/smallgraphlib\n\n    $ pip install --user smallgraphlib\n\n## Usage\n\nMain classes are `Graph`, `DirectedGraph`, `WeightedGraph` and `WeightedDirectedGraph`:\n\n    >>> from smallgraphlib import DirectedGraph\n    >>> g = DirectedGraph(["A", "B", "C"], ("A", "B"), ("B", "A"), ("B", "C"))\n    >>> g.is_simple\n    True\n    >>> g.is_complete\n    False\n    >>> g.is_directed\n    True\n    >>> g.adjacency_matrix\n    [[0, 1, 0], [1, 0, 1], [0, 0, 0]]\n    >>> g.degree\n    3\n    >>> g.order\n    3\n    >>> g.is_eulerian\n    False\n    >>> g.is_semi_eulerian\n    True\n\nSpecial graphs may be generated using factory functions:\n    \n    >>> from smallgraphlib import complete_graph, complete_bipartite_graph\n    >>> K5 = complete_graph(5)\n    >>> len(K5.greedy_coloring)\n    5\n    >>> K33 = complete_bipartite_graph(3, 3)\n    >>> K33.degree\n    6\n    >>> K33.diameter\n    2\n    \nIf the graph is not too complex, Tikz code may be generated:\n\n    >>> g.as_tikz()\n    ...\n\n## Development\n\n1. Get last version:\n   \n       $ git clone https://github.com/wxgeo/smallgraphlib\n\n2. Install Poetry.\n    \n   Poetry is a tool for dependency management and packaging in Python.\n\n   Installation instructions are here:\n   https://python-poetry.org/docs/#installation\n\n3. Install developments tools:\n    \n       $ poetry install\n\n4. Optionally, update development tools:\n      \n       $ poetry update\n\n5. Optionally, install library in editable mode:\n\n       $ pip install -e smallgraphlib\n\n6. Make changes, add tests.\n  \n7. Launch tests:\n\n        $ tox\n\n8. Everything\'s OK ? Commit. :)',
-    'author': 'Nicolas Pourcelot',
-    'author_email': 'nicolas.pourcelot@gmail.com',
-    'maintainer': 'None',
-    'maintainer_email': 'None',
-    'url': 'https://github.com/wxgeo/smallgraphlib',
-    'packages': packages,
-    'package_data': package_data,
-    'python_requires': '>=3.10,<4.0',
-}
-
-
-setup(**setup_kwargs)