uncycle 0.1.0__py3-none-any.whl

uncycle/__init__.py

@@ -0,0 +1,17 @@
+"""Find the fewest import statements to remove to break all circular imports."""
+
+from .fas import minimum_feedback_arc_set
+from .graph import Edge, Graph, build_graph
+from .io import FORMATS, read_graph, write_graph
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "FORMATS",
+    "Edge",
+    "Graph",
+    "build_graph",
+    "minimum_feedback_arc_set",
+    "read_graph",
+    "write_graph",
+]

uncycle/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

uncycle/cli.py

@@ -0,0 +1,183 @@
+"""List the fewest import statements to remove to break all circular imports in a Python package."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from collections.abc import Iterable
+
+from .fas import minimum_feedback_arc_set
+from .graph import Edge, Graph, build_graph
+from .io import FORMATS, read_graph, write_graph
+
+BOLD, RED, GREEN, GREY = "1", "31", "32", "90"
+
+
+def colorize(text: str, *codes: str) -> str:
+    if "NO_COLOR" in os.environ:
+        return text
+    if not (sys.stdout.isatty() or "GITHUB_ACTIONS" in os.environ):
+        return text
+    return f"\033[{';'.join(codes)}m{text}\033[0m"
+
+
+def display(path: str) -> str:
+    """A path relative to the working directory when that is inside it, else as is."""
+    try:
+        relative = os.path.relpath(path)
+    except ValueError:  # another drive on Windows
+        return path
+    return path if relative.startswith("..") else relative
+
+
+def lines(graph: Graph, edges: Iterable[Edge]) -> list[str]:
+    """One ``path:line: imports module`` line per import statement behind the given edges,
+    in file order; ``module: imports module`` for a graph that has no locations."""
+    keyed: list[tuple[tuple[str, int, str], str]] = []
+    for edge in edges:
+        src, dst = graph.names([edge])[0]
+        where = graph.locations.get(edge)
+        if not where:
+            keyed.append(((src, 0, dst), f"{src}: imports {dst}"))
+        for path, line in where or ():
+            shown = display(path)
+            keyed.append(((shown, line, dst), f"{shown}:{line}: imports {dst}"))
+    return [text for _, text in sorted(keyed)]
+
+
+def print_lines(graph: Graph, edges: Iterable[Edge], *codes: str) -> None:
+    for line in lines(graph, edges):
+        print(colorize(line, *codes))
+
+
+def dependencies(n: int) -> str:
+    return f"{n} {'dependency' if n == 1 else 'dependencies'}"
+
+
+def summary(graph: Graph, fas: Iterable[Edge]) -> str:
+    """``2 dependencies to remove``, and when they span more import statements than that,
+    ``11 dependencies (14 import statements) to remove``."""
+    fas = list(fas)
+    statements = len(lines(graph, fas))
+    if statements == len(fas):
+        return f"{dependencies(len(fas))} to remove"
+    return f"{dependencies(len(fas))} ({statements} import statements) to remove"
+
+
+def compare(old: Graph, new: Graph) -> int:
+    """Print the import statements this change added to the solution, and the count."""
+    old_fas = minimum_feedback_arc_set(old)
+    new_fas = minimum_feedback_arc_set(new)
+    before, after = len(old_fas), len(new_fas)
+    difference = after - before
+
+    if difference <= 0:
+        print_lines(new, new_fas, GREY)
+        if difference == 0:
+            change = f"dependencies to remove unchanged at {after}"
+        else:
+            change = f"dependencies to remove decreased from {before} to {after}"
+        print(colorize(change, GREEN, BOLD))
+        return 0
+
+    # Solve the new graph again without the edges the old solution already blamed, so what is
+    # left to blame is what this change introduced. A heuristic: the old solution is not
+    # necessarily a subset of the new graph's edges.
+    excluded = set(new.indices(old.names(old_fas)))
+    blamed = minimum_feedback_arc_set(
+        Graph(new.nodes, [e for e in new.edges if e not in excluded], new.locations)
+    )
+    print_lines(new, blamed, RED)
+
+    # Breaking exactly those is not necessarily the cheapest way back to the old count.
+    if len(blamed) > difference:
+        print(f"removing any {difference} of the following would undo the increase:")
+        print_lines(new, new_fas, GREY)
+    change = f"dependencies to remove increased from {before} to {after}"
+    print(colorize(change, RED, BOLD))
+    return 1
+
+
+def load(
+    path: str, exclude: str | None, inline: bool, parser: argparse.ArgumentParser
+) -> Graph:
+    """A package directory to analyze, or a graph file dumped earlier."""
+    if os.path.isdir(path):
+        return build_graph(path, exclude, inline, warn)
+    if path.endswith(".py"):
+        raise ValueError(f"{path}: is a module; pass its package directory instead")
+    if exclude is not None or inline:
+        parser.error(f"--exclude and --inline do not apply to a graph file: {path}")
+    try:
+        with open(path, encoding="utf-8") as f:
+            return read_graph(f)
+    except ValueError as e:
+        raise ValueError(f"{path}: {e}") from None
+
+
+def warn(message: str) -> None:
+    print(colorize(f"uncycle: warning: {message}", GREY), file=sys.stderr)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(prog="uncycle", description=__doc__)
+    parser.add_argument(
+        "package",
+        metavar="PACKAGE",
+        help="a package directory, or a graph file written by --dump-graph",
+    )
+    parser.add_argument(
+        "--exclude",
+        metavar="REGEX",
+        help="regex searched in module names to leave out of the graph; a package that "
+        "matches is pruned along with everything under it",
+    )
+    parser.add_argument(
+        "--inline",
+        action="store_true",
+        help="include imports inside functions and classes",
+    )
+    parser.add_argument(
+        "--baseline",
+        metavar="OLD",
+        help="an older version of the package: list the import statements this version "
+        "added to the problem, and exit 1 if more dependencies have to go than before",
+    )
+    parser.add_argument(
+        "--dump-graph",
+        metavar="FILE",
+        help="write the import graph to FILE (- for stdout) instead of solving it",
+    )
+    parser.add_argument(
+        "--format",
+        choices=FORMATS,
+        help="format of the dumped graph; default: text if FILE ends in .txt, else json",
+    )
+    args = parser.parse_args()
+
+    try:
+        graph = load(args.package, args.exclude, args.inline, parser)
+
+        if args.dump_graph is not None:
+            file = args.dump_graph
+            format = args.format or ("text" if file.endswith(".txt") else "json")
+            if file == "-":
+                write_graph(graph, sys.stdout, format)
+            else:
+                with open(file, "w", encoding="utf-8") as f:
+                    write_graph(graph, f, format)
+            return 0
+
+        if args.baseline is not None:
+            return compare(
+                load(args.baseline, args.exclude, args.inline, parser), graph
+            )
+
+        fas = minimum_feedback_arc_set(graph)
+        print_lines(graph, fas, GREY)
+        print(colorize(summary(graph, fas), BOLD))
+        return 0
+    except (OSError, SyntaxError, ValueError) as e:
+        print(f"uncycle: {e}", file=sys.stderr)
+        return 2

uncycle/fas.py

@@ -0,0 +1,43 @@
+"""Compute a minimum feedback arc set with clingo."""
+
+from __future__ import annotations
+
+import clingo
+
+from .graph import Edge, Graph
+
+#: Drop as few edges as possible to make the graph acyclic. #edge is clingo's acyclicity
+#: propagator: it rejects any model whose edges form a cycle. An edge from a package to
+#: one of its own submodules is fixed: the point of the package is to expose the
+#: submodule, so dropping that import is not a real option. A cycle cannot consist of
+#: fixed edges alone, since names strictly lengthen along one, so a model always exists.
+ENCODING = """\
+#defined fixed/2.
+{ del(X,Y) } :- edge(X,Y), not fixed(X,Y).
+#edge (X,Y) : edge(X,Y), not del(X,Y).
+#minimize { 1,X,Y : del(X,Y) }.
+#show del/2.
+"""
+
+
+def minimum_feedback_arc_set(graph: Graph) -> list[Edge]:
+    """A smallest set of edges whose removal makes the graph acyclic."""
+    if not graph.edges:
+        return []
+    ctl = clingo.Control(["--opt-strategy=usc"])
+    facts = "".join(f"edge({src},{dst})." for src, dst in graph.edges)
+    facts += "".join(
+        f"fixed({src},{dst})."
+        for src, dst in graph.edges
+        if graph.nodes[dst].startswith(f"{graph.nodes[src]}.")
+    )
+    ctl.add("base", [], ENCODING + facts)
+    ctl.ground([("base", [])])
+    fas: list[Edge] = []
+    with ctl.solve(yield_=True) as handle:
+        for model in handle:
+            arguments = (x.arguments for x in model.symbols(shown=True))
+            fas = [(a.number, b.number) for a, b in arguments]
+        if not handle.get().exhausted:
+            raise RuntimeError("clingo did not prove this set minimal")
+    return sorted(fas)

uncycle/graph.py

@@ -0,0 +1,200 @@
+"""Build the import graph of a Python package."""
+
+from __future__ import annotations
+
+import ast
+import dataclasses
+import os
+import re
+import warnings
+from collections.abc import Callable, Iterable
+from importlib.util import resolve_name
+
+#: an edge as a pair of indices into :attr:`Graph.nodes`
+Edge = tuple[int, int]
+#: where an import statement is: absolute file path and 1-based line number
+Location = tuple[str, int]
+
+
+@dataclasses.dataclass
+class Graph:
+    """A module import graph: sorted module names, edges as index pairs into them, and per
+    edge the import statements behind it, which a graph read from a file does not have."""
+
+    nodes: list[str]
+    edges: list[Edge]
+    locations: dict[Edge, list[Location]] = dataclasses.field(
+        default_factory=dict, compare=False
+    )
+
+    def names(self, edges: Iterable[Edge]) -> list[tuple[str, str]]:
+        """The given edges as pairs of module names."""
+        return [(self.nodes[i], self.nodes[j]) for i, j in edges]
+
+    def indices(self, named: Iterable[tuple[str, str]]) -> list[Edge]:
+        """Edges by name in this graph's index space; edges it does not have are dropped."""
+        index = {name: i for i, name in enumerate(self.nodes)}
+        edges = set(self.edges)
+        pairs = ((index[a], index[b]) for a, b in named if a in index and b in index)
+        return sorted(edge for edge in pairs if edge in edges)
+
+
+def _is_type_checking(test: ast.expr) -> bool:
+    if isinstance(test, ast.Name):
+        return test.id == "TYPE_CHECKING"
+    return isinstance(test, ast.Attribute) and test.attr == "TYPE_CHECKING"
+
+
+def _is_main(test: ast.expr) -> bool:
+    """``__name__ == "__main__"``, in either order."""
+    if not isinstance(test, ast.Compare) or len(test.ops) != 1:
+        return False
+    if not isinstance(test.ops[0], ast.Eq):
+        return False
+    sides = (test.left, test.comparators[0])
+    name = any(isinstance(s, ast.Name) and s.id == "__name__" for s in sides)
+    main = any(isinstance(s, ast.Constant) and s.value == "__main__" for s in sides)
+    return name and main
+
+
+def _runs_on_import(test: ast.expr) -> bool:
+    """Whether the body of ``if test:`` can run while the module is being imported."""
+    return not _is_type_checking(test) and not _is_main(test)
+
+
+_SCOPES = (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)
+
+
+def collect_imports(
+    tree: ast.AST,
+    resolve: Callable[[str, str], str],
+    current_pkg: str,
+    inline: bool,
+    warn: Callable[[str], None],
+    path: str,
+) -> dict[str, set[int]]:
+    """The modules a module imports, each with the lines of the statements that do so.
+
+    Iterative rather than a NodeVisitor, since a generated file with a very long
+    expression nests deeper than the recursion limit."""
+    imported: dict[str, set[int]] = {}
+    stack: list[ast.AST] = [tree]
+    while stack:
+        node = stack.pop()
+        if isinstance(node, ast.Import):
+            # import statements are always absolute
+            for alias in node.names:
+                imported.setdefault(alias.name, set()).add(node.lineno)
+        elif isinstance(node, ast.ImportFrom):
+            # from imports can be relative, and the alias can be a submodule or attribute
+            try:
+                module = resolve_name(
+                    "." * node.level + (node.module or ""), current_pkg
+                )
+            except ImportError:
+                # such a statement fails at runtime too; it is in a template or dead code
+                warn(
+                    f"{path}:{node.lineno}: relative import beyond the package, skipped"
+                )
+                continue
+            for alias in node.names:
+                imported.setdefault(resolve(module, alias.name), set()).add(node.lineno)
+        elif isinstance(node, ast.If) and not _runs_on_import(node.test):
+            # the body of if TYPE_CHECKING and of if __name__ == "__main__" does not run
+            # on import, but the else branch of either does
+            stack.extend(node.orelse)
+        elif isinstance(node, _SCOPES) and not inline:
+            continue
+        else:
+            stack.extend(ast.iter_child_nodes(node))
+    return imported
+
+
+def _is_package_dir(entry: os.DirEntry[str]) -> bool:
+    return (
+        entry.name.isidentifier()
+        and entry.is_dir(follow_symlinks=False)
+        and os.path.isfile(os.path.join(entry.path, "__init__.py"))
+    )
+
+
+def _is_module_file(entry: os.DirEntry[str]) -> bool:
+    return entry.is_file(follow_symlinks=False) and entry.name.endswith(".py")
+
+
+def build_graph(
+    package_dir: str,
+    exclude: str | None = None,
+    inline: bool = False,
+    warn: Callable[[str], None] = warnings.warn,
+) -> Graph:
+    """The import graph of a package. Modules whose name matches the ``exclude`` regex are left
+    out; ``inline`` includes imports inside functions and classes. Statements that cannot be
+    imports of anything, such as a relative import above the package, go to ``warn``."""
+    package_dir = os.path.abspath(package_dir)
+    root, pkg = os.path.split(package_dir)
+    if not pkg.isidentifier():
+        raise ValueError(f"{package_dir}: {pkg!r} is not a valid package name")
+    if not os.path.isfile(os.path.join(package_dir, "__init__.py")):
+        raise ValueError(f"{package_dir}: not a package, it has no __init__.py")
+
+    cache: dict[tuple[str, str], str] = {}
+
+    def resolve(module: str, attr: str) -> str:
+        """``from foo import bar`` is ``foo.bar`` when bar is a submodule, else ``foo``."""
+        key = (module, attr)
+        if key not in cache:
+            path = os.path.join(root, module.replace(".", os.sep), attr)
+            is_module = os.path.isfile(f"{path}.py") or os.path.isfile(
+                os.path.join(path, "__init__.py")
+            )
+            cache[key] = f"{module}.{attr}" if is_module else module
+        return cache[key]
+
+    inside = re.compile(rf"{re.escape(pkg)}(\.|$)").match
+    excluded = re.compile(exclude).search if exclude else lambda _: False
+
+    def keep(module: str) -> bool:
+        """The graph holds this package's own modules, minus the excluded ones."""
+        return bool(inside(module)) and not excluded(module)
+
+    stack = [package_dir]
+    modules: set[str] = set()
+    edges: dict[tuple[str, str], list[Location]] = {}
+
+    while stack:
+        sub_pkg_dir = stack.pop()
+        subpkg = os.path.relpath(sub_pkg_dir, root).replace(os.sep, ".")
+
+        if not keep(subpkg):
+            continue
+
+        with os.scandir(sub_pkg_dir) as it:
+            for entry in it:
+                if _is_package_dir(entry):
+                    stack.append(entry.path)
+                elif _is_module_file(entry):
+                    if entry.name == "__init__.py":
+                        current = subpkg
+                    else:
+                        current = f"{subpkg}.{entry.name[:-3]}"
+                    if not keep(current):
+                        continue
+                    modules.add(current)
+                    # bytes, so that ast honors a PEP 263 coding cookie
+                    with open(entry.path, "rb") as f:
+                        tree = ast.parse(f.read(), filename=entry.path)
+                    imported = collect_imports(
+                        tree, resolve, subpkg, inline, warn, entry.path
+                    )
+                    for m, lines in imported.items():
+                        # a self-loop is a cycle no reshuffling of imports can break
+                        if m != current and keep(m):
+                            edges.setdefault((current, m), []).extend(
+                                (entry.path, line) for line in sorted(lines)
+                            )
+
+    nodes = sorted(modules | {dst for _, dst in edges})
+    index = {node: i for i, node in enumerate(nodes)}
+    locations = {(index[src], index[dst]): where for (src, dst), where in edges.items()}
+    return Graph(nodes, sorted(locations), locations)

uncycle/io.py

@@ -0,0 +1,55 @@
+"""Read and write import graphs and their feedback arc sets."""
+
+from __future__ import annotations
+
+import json
+from typing import TextIO
+
+from .graph import Graph
+
+#: the graph file formats, see the README
+FORMATS = ("json", "text")
+
+
+def write_graph(graph: Graph, f: TextIO, format: str = "json") -> None:
+    if format == "json":
+        json.dump(
+            {"nodes": graph.nodes, "edges": [list(edge) for edge in graph.edges]}, f
+        )
+        f.write("\n")
+    elif format == "text":
+        print(len(graph.nodes), file=f)
+        for node in graph.nodes:
+            print(node, file=f)
+        print(len(graph.edges), file=f)
+        for src, dst in graph.edges:
+            print(src, dst, file=f)
+    else:
+        raise ValueError(f"unknown graph format: {format}")
+
+
+def read_graph(f: TextIO) -> Graph:
+    """Read a graph in either format; the first character tells them apart."""
+    text = f.read()
+    if text.lstrip().startswith("{"):
+        data = json.loads(text)
+        return Graph(list(data["nodes"]), [(int(a), int(b)) for a, b in data["edges"]])
+    words = text.split()
+    if not words or not words[0].isdigit():
+        raise ValueError(
+            "not a graph file: expected json, or a node count on the first line"
+        )
+    node_count = int(words[0])
+    nodes = words[1 : 1 + node_count]
+    try:
+        edge_count = int(words[1 + node_count])
+        numbers = [
+            int(x) for x in words[2 + node_count : 2 + node_count + 2 * edge_count]
+        ]
+    except (IndexError, ValueError):
+        raise ValueError(
+            f"truncated graph file: it declares {node_count} nodes"
+        ) from None
+    if len(numbers) != 2 * edge_count:
+        raise ValueError(f"truncated graph file: it declares {edge_count} edges")
+    return Graph(nodes, list(zip(numbers[::2], numbers[1::2])))

uncycle-0.1.0.dist-info/METADATA

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: uncycle
+Version: 0.1.0
+Summary: Find the fewest import statements to remove to break all circular imports
+Project-URL: Homepage, https://github.com/haampie/uncycle
+Project-URL: Repository, https://github.com/haampie/uncycle
+Author-email: Harmen Stoppels <me@harmenstoppels.nl>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: circular imports,feedback arc set,imports,static analysis
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.9
+Requires-Dist: clingo
+Provides-Extra: dev
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# uncycle
+
+A Python tool to find the fewest `import` statements to remove to break all circular imports.
+
+![A five-module import graph with two cycles; one edge, shown dashed, breaks both](https://raw.githubusercontent.com/haampie/uncycle/main/docs/feedback-arc-set.svg)
+
+It gives you short and actionable feedback to structure your Python package better.
+
+It works by computing the so-called [Feedback Arc Set][1] on the graph of Python modules (nodes) and import statements (edges).
+
+## Usage
+
+```
+uncycle [--exclude REGEX] [--inline] [--baseline OLD] [--dump-graph FILE] PACKAGE
+```
+
+### Listing problematic import statements
+
+Use `uncycle path/to/pkg` to list the minimal import statements to delete to break all circular imports:
+
+```console
+$ uncycle werkzeug-3.1.8/src/werkzeug
+werkzeug-3.1.8/src/werkzeug/http.py:1442: imports werkzeug.datastructures
+werkzeug-3.1.8/src/werkzeug/http.py:1443: imports werkzeug.sansio.http
+2 dependencies to remove
+```
+
+### Finding regressions
+
+Use `--baseline` to see whether a new commit or version regresses the number of dependencies to remove:
+
+```console
+$ uncycle Werkzeug-2.2.0/src/werkzeug --baseline Werkzeug-2.1.2/src/werkzeug
+Werkzeug-2.2.0/src/werkzeug/http.py:1305: imports werkzeug.sansio.http
+dependencies to remove increased from 1 to 2
+```
+
+This check is useful in CI:
+
+```yaml
+- uses: actions/checkout@v5
+  with: { ref: "${{ github.event.pull_request.base.sha }}", path: old }
+- uses: actions/checkout@v5
+  with: { path: new }
+- run: pip install uncycle
+- run: uncycle new/src/mypkg --baseline old/src/mypkg
+```
+
+## Install
+
+```
+pip install uncycle
+```
+
+## Options
+
+- `--exclude REGEX`: exclude certain modules, for example: `'^app\.(vendor|tests)\b'`.
+- `--inline`: also count imports inside functions and classes.
+- `--baseline OLD`: an older version of the package. Lists the import statements this version added to the problem, and exits 1 if more dependencies have to go than before.
+- `--dump-graph FILE`: write the import graph to `FILE` (`-` for stdout) instead of solving it.
+- `--format json|text`: format of the dumped graph. Defaults to `text` when `FILE` ends in `.txt`, otherwise `json`.
+
+## Exit status
+
+- `0`: the dependencies were listed, or no more of them have to go than in the baseline.
+- `1`: more dependencies have to go than in the baseline.
+- `2`: a file could not be read or parsed, or the arguments were invalid.
+
+## Python API
+
+```python
+import uncycle
+
+graph = uncycle.build_graph("src/app", exclude=r"^app\.tests\b")
+fas = uncycle.minimum_feedback_arc_set(graph)
+print(graph.names(fas))  # [('app.db', 'app.models')]
+```
+
+## The import graph
+
+The import graph is constructed statically using AST parsing. Imports under `if TYPE_CHECKING` and `if __name__ == "__main__"` are dropped. Dynamic imports inside functions and classes only count with `--inline`.
+
+## Notes
+
+Imports of *submodules* are never reported to make things actionable. Consider a module `foo` that imports a submodule `foo.bar` to re-export some of its API: it's practically impossible to eliminate this import. Technically this means that we're computing a constrained version of the feedback arc set.
+
+Also notice there are typically many optimal solutions, but only one (arbitrary) solution is printed. For example a trivial cycle `a -> b -> c -> a` can be made acyclic by removing any edge.
+
+## See also
+
+- pylint's [`cyclic-import`][2], [pycycle][3] and [import-linter][4] report every cycle they find, one chain of modules per cycle. In a package with many cycles that is a long list; `uncycle` reports the few imports that break all of them.
+- The minimum is exact, computed with [clingo](https://potassco.org/clingo/).
+
+[1]: https://en.wikipedia.org/wiki/Feedback_arc_set
+[2]: https://pylint.readthedocs.io/en/stable/user_guide/messages/refactor/cyclic-import.html
+[3]: https://github.com/bndr/pycycle
+[4]: https://github.com/seddonym/import-linter

uncycle-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+uncycle/__init__.py,sha256=pfp50H-fNxFFBZI1Wl9AwHTHstyHr_LNe9QDTm16h6M,383
+uncycle/__main__.py,sha256=E6Gls0DNz8GQK2K-kOUIx8cYhgANW_CH54VKrfCfs14,52
+uncycle/cli.py,sha256=IzbvcIYxS69jNFnqBDofZJ9OnwyakiaF-MrKF3m4MEw,6664
+uncycle/fas.py,sha256=YJzKFXq9y-PVD1ikgNp6EiwLuA5KhHOpXoYgVNAAV5M,1629
+uncycle/graph.py,sha256=Zpmbyxo2JbnUxuHTqssG3E5rLvEsRoY_5g3jcXN8pWs,7960
+uncycle/io.py,sha256=UR1JcZPbEBuDjA0vp9iD6I3Ewvf-9JNG1pzsy27t2Us,1842
+uncycle-0.1.0.dist-info/METADATA,sha256=kU0ZwzkVKTiD2fpGH06S9W5l8GrDhFLG62-cVmqu8rI,4794
+uncycle-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uncycle-0.1.0.dist-info/entry_points.txt,sha256=eMkcGHg6KFDkG-rzN5V4d_D7_OxLKxnjGSEQK5CjnAQ,45
+uncycle-0.1.0.dist-info/licenses/LICENSE,sha256=__SLj47S7iVBRcTgxVBsHkJLf-2jfkCcn41E-10ixSw,1072
+uncycle-0.1.0.dist-info/RECORD,,

uncycle-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

uncycle-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+uncycle = uncycle.cli:main

uncycle-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Harmen Stoppels
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.