classify 2026.7.1__py3-none-any.whl

classify/__init__.py

@@ -0,0 +1,10 @@
+from .classification import classify
+from .exceptions import NotAClassError
+from .resolution import resolve
+
+
+__all__ = [
+    "NotAClassError",
+    "classify",
+    "resolve",
+]

classify/__main__.py

@@ -0,0 +1,5 @@
+from .main import run
+
+
+if __name__ == "__main__":
+    run()

classify/classification.py

@@ -0,0 +1,113 @@
+import builtins
+import collections
+import inspect
+import pydoc
+
+import structlog
+
+from .dataclasses import Attribute, Class, DataDescriptor, Member, Method, SimpleClass
+from .filters import (
+    is_attribute,
+    is_data_descriptor,
+    is_inner_class,
+    is_method,
+    is_property,
+)
+
+
+logger = structlog.get_logger()
+
+
+def classify[C](obj: type[C]) -> Class:
+    # flatten the MRO of the given class and flip the order so it's the first
+    # non-object class first
+    mro = [cls for cls in reversed(inspect.getmro(obj)) if cls is not builtins.object]
+
+    # build up dicts of attrs&methods, by name, because they can be defined on
+    # more than one class in the MRO
+    attributes = collections.defaultdict(list)
+    classes = []
+    data_descriptors = collections.defaultdict(list)
+    methods = collections.defaultdict(list)
+    properties = collections.defaultdict(list)
+
+    structlog.contextvars.clear_contextvars()
+    for cls in mro:
+        structlog.contextvars.bind_contextvars(**{"class": cls.__name__})
+        members = list(get_members(cls))
+
+        ## ATTRIBUTES
+        class_attrs = [m for m in members if is_attribute(m)]
+        for member in class_attrs:
+            structlog.contextvars.bind_contextvars(member=member)
+            attributes[member.name].append(Attribute.from_member(member))
+
+        ## CLASSES
+        inner_classes = [m for m in members if is_inner_class(m)]
+        classes.extend(classify(c.obj) for c in inner_classes)
+
+        ## METHODS
+        instance_methods = [m for m in members if is_method(m)]
+        for member in instance_methods:
+            structlog.contextvars.bind_contextvars(member=member)
+            methods[member.name].append(Method.from_member(member))
+
+        ## PROPERTIES
+        props = [m for m in members if is_property(m)]
+        for member in props:
+            logger.debug("extracting property", member=member)
+            prop = Method.from_func(member.obj.fget, member.cls)
+            properties[member.name].append(prop)
+
+        ## DATA DESCRIPTORS
+        descriptors = [m for m in members if is_data_descriptor(m)]
+        for member in descriptors:
+            structlog.contextvars.bind_contextvars(member=member)
+            data_descriptors[member.name].append(DataDescriptor.from_member(member))
+
+    ancestors = [SimpleClass.from_class(c) for c in mro[:-1]]
+
+    return Class(
+        name=obj.__name__,
+        module=obj.__module__,
+        docstring=pydoc.getdoc(obj),
+        ancestors=ancestors,
+        parents=get_parents(obj),
+        attributes=dict(sorted(attributes.items())),
+        classes=sorted(classes, key=lambda c: c.name),
+        properties=dict(sorted(properties.items())),
+        data_descriptors=dict(sorted(data_descriptors.items())),
+        methods=dict(sorted(methods.items())),
+    )
+
+
+def get_members(obj) -> list[Member]:
+    """
+    Get members from the given object
+
+    classify_class_attrs returns a tuple of:
+     - name
+     - kind
+     - class
+     - object
+    """
+    members = [
+        Member(name=name, kind=kind, cls=cls, obj=obj)
+        for name, kind, cls, obj in pydoc.classify_class_attrs(obj)
+    ]
+    # filter down to non-private items and those defined on the given object
+    return [
+        member
+        for member in members
+        if pydoc.visiblename(member.name, obj=obj) and member.cls == obj
+    ]
+
+
+def get_parents[C](obj: type[C]) -> list[str]:
+    tree = inspect.getclasstree([obj])
+
+    # getclasstree returns a list of tuples, containing a class, and tuple with
+    # that classes parents.  We just want the parents for the given obj.
+    raw_parents = tree[-1][0][1]
+
+    return [c for c in raw_parents if c is not builtins.object]

classify/contrib/django/settings.py

@@ -0,0 +1 @@
+SECRET_KEY = "foo"

classify/dataclasses.py

@@ -0,0 +1,150 @@
+import inspect
+import pydoc
+from typing import Any, Literal, Self
+
+import structlog
+from attrs import frozen
+
+
+logger = structlog.get_logger()
+
+Kind = Literal[
+    "class method",
+    "static method",
+    "property",
+    "method",
+    "data",
+    "data descriptor",
+    "readonly property",
+]
+
+
+@frozen
+class Attribute:
+    name: str
+    defining_class: "SimpleClass"
+    value: Any
+
+    @classmethod
+    def from_member(cls, member: "Member") -> Self:
+        logger.debug("extracting attribute", member=member)
+        return cls(
+            name=member.name,
+            defining_class=SimpleClass.from_class(member.cls),
+            value=member.obj,
+        )
+
+
+@frozen
+class Class:
+    name: str
+    module: str
+    docstring: str
+    ancestors: list[str]
+    parents: list[str]
+    attributes: dict[str, list[Attribute]]
+    classes: list["Class"]
+    properties: dict[str, list["Method"]]
+    data_descriptors: dict[str, list["DataDescriptor"]]
+    methods: dict[str, list["Method"]]
+
+
+@frozen
+class DataDescriptor:
+    name: str
+    getter: "Method | None"
+    setter: "Method | None"
+    deleter: "Method | None"
+
+    @classmethod
+    def from_member(cls, member: "Member") -> Self:
+        logger.debug("extracting data descriptor")
+
+        getter = (
+            Method.from_func(member.obj.fget, member.cls)
+            if hasattr(member.obj, "fget")
+            else None
+        )
+
+        setter = None
+        if fset := getattr(member.obj, "fset", None):
+            setter = Method.from_func(fset, member.cls)
+
+        # property() creates an fdel with the value `None`
+        deleter = None
+        if fdel := getattr(member.obj, "fdel", None):
+            deleter = Method.from_func(fdel, member.cls)
+
+        return cls(name=member.name, getter=getter, setter=setter, deleter=deleter)
+
+
+@frozen
+class Line:
+    start: int
+    total: int
+
+
+@frozen
+class Member[C]:
+    name: str
+    kind: Kind
+    cls: type[C]
+    obj: Any
+
+
+@frozen
+class Method:
+    name: str
+    docstring: str
+    defining_class: "SimpleClass"
+    arguments: str
+    code: str
+    lines: Line
+    file: str | None = None
+
+    @classmethod
+    def from_func(cls, func, defining_class) -> Self:
+        # get target of cached property decorators
+        if hasattr(func, "func"):
+            while getattr(func, "func", None):
+                func = func.func
+
+        # unwrap decorated methods and functions
+        if hasattr(func, "__wrapped__"):  # decorated methods
+            while getattr(func, "__wrapped__", None):
+                func = func.__wrapped__
+
+        arguments = str(inspect.signature(func))
+
+        # Get source line details
+        lines, start_line = inspect.getsourcelines(func)
+
+        file = inspect.getsourcefile(func)
+
+        return cls(
+            name=func.__name__,
+            docstring=pydoc.getdoc(func),
+            defining_class=SimpleClass.from_class(defining_class),
+            arguments=arguments,
+            code="".join(lines),
+            lines=Line(start=start_line, total=len(lines)),
+            file=file,
+        )
+
+    @classmethod
+    def from_member(cls, member: "Member") -> Self:
+        logger.debug("extracting method")
+        return cls.from_func(member.obj, member.cls)
+
+
+@frozen
+class SimpleClass:
+    name: str
+    module: str
+
+    @staticmethod
+    def from_class(klass):
+        return SimpleClass(
+            name=klass.__name__,
+            module=klass.__module__,
+        )

classify/django.py

@@ -0,0 +1,16 @@
+import os
+
+
+def setup_django(settings_path: str) -> None:
+    """
+    Bootstrap Django
+
+    When running classify against a Django project, rather than Django itself we
+    Django projects sometimes need
+    """
+    # default = "classify.contrib.django.settings"
+    os.environ["DJANGO_SETTINGS_MODULE"] = settings_path
+
+    import django  # noqa: PLC0415
+
+    django.setup()

classify/exceptions.py

@@ -0,0 +1,2 @@
+class NotAClassError(Exception):
+    pass

classify/filters.py

@@ -0,0 +1,45 @@
+import inspect
+
+from .dataclasses import Member
+
+
+def is_attribute(member: Member) -> bool:
+    return member.kind == "data" and not is_inner_class(member)
+
+
+def is_data_descriptor(member: Member) -> bool:
+    return (
+        member.kind == "data descriptor"
+        and not inspect.isgetsetdescriptor(member.obj)
+        and not inspect.ismemberdescriptor(member.obj)
+    )
+
+
+def is_inner_class(member: Member) -> bool:
+    if not inspect.isclass(member.obj):
+        return False
+
+    # inner class' __qualname__ will reflect that of the class they are defined
+    # on, eg the.module.MyClass.Inner.  This check uses member.cls to build up
+    # a prefix that can be removed from member.obj's __qualname__.  If the
+    # remainder matches member.name then we have an inner class.
+    name = member.obj.__qualname__.removeprefix(f"{member.cls.__qualname__}.")
+    return name == member.name and member.kind == "data"
+
+
+def is_method(member: Member) -> bool:
+    return (
+        member.kind
+        in [
+            "method",
+            "class method",
+            "static method",
+        ]
+        and not inspect.ismethoddescriptor(member.obj)
+        and not inspect.isgetsetdescriptor(member.obj)
+        and not inspect.isbuiltin(member.obj)
+    )
+
+
+def is_property(member: Member) -> bool:
+    return member.kind == "readonly property"

classify/main.py

@@ -0,0 +1,98 @@
+import logging
+import pydoc
+import sys
+from pathlib import Path
+
+import click
+import structlog
+from rich.syntax import DEFAULT_THEME
+
+from . import renderers
+from .classification import classify
+from .django import setup_django
+from .exceptions import NotAClassError
+from .renderers import Renderer
+from .resolution import resolve
+
+
+@click.command()
+@click.argument("klass")
+@click.option(
+    "--console-theme",
+    default=DEFAULT_THEME,
+    help="Pygments theme to render console output with",
+)
+@click.option("--debug", is_flag=True)
+@click.option("--django-settings")
+@click.option(
+    "--renderer",
+    default=Renderer.CONSOLE,
+    type=click.Choice(Renderer, case_sensitive=False),
+)
+@click.option(
+    "-o",
+    "--output",
+    "output_path",
+    default=None,
+    type=click.Path(file_okay=False, path_type=Path),
+    help="Relative path for output files to be saved",
+)
+@click.option("-p", "--port", default=8000, type=click.INT)
+@click.option("-s", "--serve", is_flag=True)
+@click.version_option()
+def run(
+    klass,
+    console_theme,
+    debug,
+    django_settings,
+    renderer: Renderer,
+    output_path,
+    port,
+    serve,
+) -> None:
+    if django_settings:
+        setup_django(django_settings)
+
+    default_log_level = logging.DEBUG if debug else logging.WARNING
+    structlog.configure(
+        processors=[
+            structlog.contextvars.merge_contextvars,
+            structlog.processors.StackInfoRenderer(),
+            structlog.dev.set_exc_info,
+            structlog.dev.ConsoleRenderer(),
+        ],
+        wrapper_class=structlog.make_filtering_bound_logger(default_log_level),
+    )
+
+    try:
+        obj = resolve(klass)
+    except ImportError:
+        click.echo(f"Could not import: {klass}", err=True)
+        sys.exit(1)
+    except pydoc.ErrorDuringImport as e:
+        click.echo(
+            f"Could not import '{klass}', the original error was:\n {e}", err=True
+        )
+        sys.exit(1)
+    except NotAClassError:
+        click.echo(
+            f"{klass} doesn't look like a class, please specify the path to a class",
+            err=True,
+        )
+        sys.exit(1)
+
+    structure = classify(obj)
+
+    match renderer:
+        case Renderer.CONSOLE:
+            renderers.to_console(structure, console_theme)
+        case Renderer.HTML:
+            renderers.to_html(structure, output_path, serve, port)
+        case Renderer.PAGER:  # pragma: no branch
+            # unclear why coverage thinks run() doesn't return, so marking as
+            # no branch for now
+            renderers.to_pager(structure, console_theme)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    run()

classify/renderers/__init__.py

@@ -0,0 +1,21 @@
+import enum
+
+from .console import to_console, to_pager
+from .html import to_html
+from .string import to_string
+
+
+class Renderer(enum.StrEnum):
+    CONSOLE = enum.auto()
+    HTML = enum.auto()
+    PAGER = enum.auto()
+    STRING = enum.auto()
+
+
+__all__ = [
+    "Renderer",
+    "to_console",
+    "to_html",
+    "to_pager",
+    "to_string",
+]

classify/renderers/console.py

@@ -0,0 +1,19 @@
+from rich.console import Console
+from rich.syntax import Syntax
+
+from .string import to_string
+
+
+def to_console(structure, theme, console=None):
+    if not console:
+        console = Console()
+
+    content = to_string(structure)
+    syntax = Syntax(content, "python", theme=theme)
+    console.print(syntax)
+
+
+def to_pager(structure, theme):
+    console = Console()
+    with console.pager(styles=True):
+        to_console(structure, theme, console=console)

classify/renderers/html.py

@@ -0,0 +1,75 @@
+import contextlib
+import functools
+import inspect
+import os
+import socketserver
+import tempfile
+import webbrowser
+from collections.abc import Generator
+from http.server import SimpleHTTPRequestHandler
+from pathlib import Path
+
+from ..dataclasses import Class
+
+
+class Handler(SimpleHTTPRequestHandler):  # pragma: no cover
+    def do_GET(self):
+        self.path = "classify.html"
+        return SimpleHTTPRequestHandler.do_GET(self)
+
+
+def attribute_value(value):
+    if isinstance(value, str):
+        return f'"{value}"'
+
+    if inspect.isclass(value):
+        return value.__name__
+
+    return value
+
+
+@functools.singledispatch
+@contextlib.contextmanager
+def resolve_path(output_path: Path) -> Generator:
+    output_path.mkdir(exist_ok=True)
+    yield output_path
+
+
+@resolve_path.register
+@contextlib.contextmanager
+def _(empty: None) -> Generator:  # noqa: ARG001
+    directory = tempfile.TemporaryDirectory(prefix="classify")
+
+    yield Path(directory.name)
+
+    directory.cleanup()
+
+
+def serve_output(port: int) -> None:  # pragma: no cover
+    httpd = socketserver.TCPServer(("", port), Handler)
+
+    if not os.environ.get("TEST_MODE", None):
+        print(f"Serving on port: {port}")
+        webbrowser.open_new_tab(f"http://localhost:{port}/")
+
+    httpd.serve_forever()
+
+
+def to_html(structure: Class, output_path: Path | None, serve: bool, port: int) -> None:
+    from jinja2 import Environment, PackageLoader  # noqa: PLC0415
+
+    env = Environment(loader=PackageLoader("classify", "templates"))
+    env.filters["attribute"] = attribute_value
+    template = env.get_template("web.html")
+    output = template.render(klass=structure)
+
+    with resolve_path(output_path) as path:
+        full_path = path / "classify.html"
+        full_path.write_text(output)
+
+        if not serve:
+            print(f"Wrote: {full_path}")
+            return
+
+        with contextlib.chdir(path):  # pragma: no cover
+            serve_output(port)

classify/renderers/string.py

@@ -0,0 +1,124 @@
+import inspect
+
+from ..dataclasses import Class, DataDescriptor, Method
+
+
+# define this here so we know what "1" indent is and can remove it for inner
+# class declarations
+DEFAULT_INDENT_WIDTH = 4
+
+
+def attributes(attributes, indent) -> str:
+    attrs = []
+    for name, definitions in attributes.items():
+        value = definitions[-1].value
+
+        if isinstance(value, str):
+            value = f'"{value}"'
+
+        if inspect.isclass(value):
+            value = value.__name__
+
+        attrs.append(f"{indent}{name} = {value}\n")
+    return "".join(attrs)
+
+
+def classes(classes, indent) -> str:
+    content = [to_string(c, indent=indent + indent) for c in classes]
+    return "".join(content)
+
+
+def declaration(name, parents, indent) -> str:
+    indent = indent[:-DEFAULT_INDENT_WIDTH]
+    content = f"{indent}class {name}"
+
+    if parents:
+        parents = ", ".join([p.__name__ for p in parents])
+        content = f"{content}({parents})"
+
+    return f"{content}:"
+
+
+def docstring(docstring, indent) -> str:
+    if not docstring:
+        return ""
+
+    quotes = f'{indent}"""\n'
+    lines = docstring.split("\n")
+    block = "".join([f"{indent}{line}\n" for line in lines])
+    return f"{quotes}{block}{quotes}"
+
+
+def methods(methods: dict[str, list[Method]], indent) -> str:
+    content = ""
+    for definitions in methods.values():
+        for i, method in enumerate(definitions):
+            if len(definitions) > 1 and i == 0:
+                content += f"{indent}# Defined on: {method.defining_class.name}\n"
+            lines = method.code.split("\n")[:-1]
+            for line in lines:
+                # TODO: dedent code at source so defined indent isn't tied to
+                # presentation indent
+                content += f"{indent}{line[4:]}\n"
+            content += "\n"
+
+    # add strip to remove the trailing newline, rather than polluting the loop
+    # with logic to work out if we're on the final loop iteration
+    return content.strip("\n")
+
+
+def properties(properties: dict[str, list[Method]], indent) -> str:
+    content = ""
+    for definitions in properties.values():
+        for i, prop in enumerate(definitions):
+            if len(definitions) > 1 and i == 0:
+                content += f"{indent}# Defined on: {prop.defining_class.name}\n"
+            lines = prop.code.split("\n")[:-1]
+            for line in lines:
+                # TODO: dedent code at source so defined indent isn't tied to
+                # presentation indent
+                content += f"{indent}{line[4:]}\n"
+            content += "\n"
+
+    return content
+
+
+def data_descriptors(data_descriptors: dict[str, list[DataDescriptor]], indent) -> str:
+    """
+    KISS to start: display any methods for a dd as a group
+    Loop the definitions of each name
+    try each of getter, setter, and deleter, outputting them as a method
+    """
+    content = ""
+    for definitions in data_descriptors.values():
+        for i, descriptor in enumerate(definitions):
+            for name in ["getter", "setter", "deleter"]:
+                func = getattr(descriptor, name, None)
+                if func is None:
+                    continue
+
+                if len(definitions) > 1 and i == 0:
+                    content += f"{indent}# Defined on: {func.defining_class.name}\n"
+
+                lines = func.code.split("\n")[:-1]
+                for line in lines:
+                    # TODO: dedent code at source so defined indent isn't tied
+                    # to presentation indent
+                    content += f"{indent}{line[4:]}\n"
+                content += "\n"
+
+    return content
+
+
+def to_string(structure: Class, indent: str = " " * DEFAULT_INDENT_WIDTH) -> str:
+    content = declaration(structure.name, structure.parents, indent)
+    content += "\n"
+    content += docstring(structure.docstring, indent) if docstring else ""
+    content += attributes(structure.attributes, indent)
+    content += "\n"
+    content += classes(structure.classes, indent)
+    content += properties(structure.properties, indent)
+    content += data_descriptors(structure.data_descriptors, indent)
+    content += methods(structure.methods, indent)
+
+    return content

classify/resolution.py

@@ -0,0 +1,17 @@
+import inspect
+import pydoc
+import sys
+
+from .exceptions import NotAClassError
+
+
+def resolve[C](thing: str) -> type[C]:
+    """Find the given thing and ensure it's a class"""
+    sys.path.insert(0, "")
+
+    obj, _ = pydoc.resolve(thing)  # ty: ignore[not-iterable]
+
+    if not inspect.isclass(obj):
+        raise NotAClassError
+
+    return obj

classify/templates/class.html

@@ -0,0 +1,65 @@
+<h1>class {{ klass.name }}</h1>
+
+{% if klass.docstring %}
+<pre>{{ klass.docstring }}</pre>
+{% endif %}
+
+{% if klass.ancestors %}
+  <h2>Ancestors (MRO)</h2>
+  <ol>
+    {% for ancestor in klass.ancestors %}
+    <li>{{ ancestor }}</li>
+    {% endfor %}
+  </ol>
+{% endif %}
+
+{% if klass.attributes %}
+  <h2>Attributes</h2>
+  <table>
+    <thead>
+      <tr>
+        <th>&nbsp;</th>
+        <th>Defined in</th>
+      </tr>
+    </thead>
+    <tbody>
+      {% for name, attributes in klass.attributes.items() %}
+        {% for attribute in attributes %}
+          <tr>
+            <td>
+              <code class="attribute{% if not loop.last %} overridden{% endif %}"{% if not loop.last %} style="text-decoration:line-through"{% endif %}>
+                {{ name }} = {{ attribute.value|attribute }}
+              </code>
+            </td>
+            <td>{{ attribute.defining_class.name }}.{{ attribute.defining_class.name }}</td>
+          </tr>
+        {% endfor %}
+      {% endfor %}
+    </tbody>
+  </table>
+{% endif %}
+
+{% if klass.classes %}
+  <h2>Inner classes</h2>
+
+  {% for foo in klass.classes %}
+    {% with klass=foo %}
+    {% include "class.html" %}
+    {% endwith %}
+  {% endfor %}
+
+{% endif %}
+
+{% if klass.methods %}
+  <h2>Methods</h2>
+  {% for name, declarations in klass.methods.items() %}
+    {% for declaration in declarations %}
+      <div class="method">
+        <h3>def {{ name }}{{ declaration.arguments }}: [{{ declaration.defining_class.name }}]</h3>
+        <p>{{ declaration.docstring|e }}</p>
+        <p>Found on lines {{ declaration.lines.start }} to {{ declaration.lines.start+declaration.lines.total }} of {{ declaration.file }}</p>
+        <pre>{{ declaration.code }}</pre>
+      </div>
+    {% endfor %}
+  {% endfor %}
+{% endif %}

classify/templates/web.html

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <title>{{ klass.name }}</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  </head>
+  <body>
+    <div class="container">
+      <article id="main">
+
+        {% include "class.html" %}
+
+      </article>
+    </div> <!-- /container -->
+  </body>
+</html>

classify-2026.7.1.dist-info/METADATA

@@ -0,0 +1,56 @@
+Metadata-Version: 2.3
+Name: classify
+Version: 2026.7.1
+Summary: Generate concrete Class documentation for Python Classes
+Author: George Hickman
+Author-email: George Hickman <george@ghickman.co.uk>
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Documentation
+Requires-Dist: attrs>=25.4.0
+Requires-Dist: click>=8.3.0
+Requires-Dist: jinja2>=2.7
+Requires-Dist: rich>=14.2.0
+Requires-Dist: structlog>=25.5.0
+Requires-Python: >=3.12
+Project-URL: Repository, https://github.com/ghickman/classify/
+Project-URL: Changelog, https://github.com/ghickman/classify/blob/main/CHANGELOG.md
+Description-Content-Type: text/markdown
+
+# Classify
+Generate concrete class API documentation for python Classes
+
+## Installation
+```bash
+    pip install classify
+```
+
+
+## Usage
+```bash
+    classify <path.to.Class>
+```
+
+This outputs the full class definition, including the methods defined on each parent class.
+
+You can change the theme to any [Pygments theme](https://pygments.org/styles/) with `--console-theme`.
+
+Output to your shell's pager with `--renderer pager`, or to [ccbv style pages](https://ccbv.co.uk) with `--renderer html`.
+
+By default HTML documents are saved to a temporary directory.
+To change this specify a relative location with the `--output` option.
+You can serve the output, regardless of where its written to with `--serve`, and change the port with `--port`.
+
+```bash
+    classify <path.to.Class> --renderer html --output output --serve --port 8080
+```
+
+
+## Why?
+[CCBV](https://ccbv.co.uk) has long been a part of my everyday toolkit for working with Django's generic class-based views.
+It's a fantastic resource for quick reference, but it only covers Django's GCBVs.
+
+Classify aims to provide this same level of utility for all your Python classes.

classify-2026.7.1.dist-info/RECORD

@@ -0,0 +1,22 @@
+classify/__init__.py,sha256=psLgRtKTm0YMV4ix3DcpdimKdHyE0pNjQo-BrW1zFYU,177
+classify/__main__.py,sha256=NIMCUi-VOkr0HqqSZmRwl-zkyeXTuqPVNEsQStcahbI,61
+classify/classification.py,sha256=WzcSWeIWQTak95LPCvnLc2f0-Ksy0LFATVcM9C3wRAQ,3708
+classify/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+classify/contrib/django/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+classify/contrib/django/settings.py,sha256=yZ9sk9lJ9DF39yadMr1iLzICopOJMUU51GOMGVmbRFk,19
+classify/dataclasses.py,sha256=VRlmalt7-Ry1E6LQULMQ5CUi6FxINuCmmkk0E4tm4rM,3444
+classify/django.py,sha256=9aq44rSVg0sPgKWQcEIGfDvFHq6PUoq1MTGGRqaBrEM,376
+classify/exceptions.py,sha256=8mES7kAGfsbV9rNJHM6VQmle03cdIN_hrj40b_F49ok,42
+classify/filters.py,sha256=xKvbpvQRbNypQITeA_3iOH-zb9v-m_zq90-m2j8Z_AM,1346
+classify/main.py,sha256=wRv4D1f-AeB55STJ8XAiN351ISrVfvHI1zgzhbav3U0,2635
+classify/renderers/__init__.py,sha256=M3MEjo9Qb787vf8fbF2NhiWzv1E2GtR4SH6ob8-f8Sc,339
+classify/renderers/console.py,sha256=ZE_FqG2pLzOG10dLrc1a8SDoRlYshwYuFfauUyty-tQ,456
+classify/renderers/html.py,sha256=f-bXhXVaH_3tvjpGfxW1TprFWFCo2qhuvVh70RHKqhA,1941
+classify/renderers/string.py,sha256=lLROHZk_FALeu_4GCvatwrRYXunNwW1X2xec3Wwl8Q8,4170
+classify/resolution.py,sha256=6BeSon5MLxu2LLsB2IWSmv65S5G8olFeMfAONALr0dY,344
+classify/templates/class.html,sha256=WwlY5N59TBof-0zP5zGligITbUAOuqx-AeTdy3afId8,1755
+classify/templates/web.html,sha256=ynhwyEWu-iUh7LSAvY1ZeuP0_kTKPKmURR-HRwALt9s,356
+classify-2026.7.1.dist-info/WHEEL,sha256=r-Se0i_n47Mj8pdnVuq7W628oP9YAKMaTjp4l3lQcns,81
+classify-2026.7.1.dist-info/entry_points.txt,sha256=OfzZe_nOc7EA4wbCvi_DtJgs77mkWlsp0NO7T49uHMw,48
+classify-2026.7.1.dist-info/METADATA,sha256=VRqvM3Y_uv156CRBpKh4rlqsLs8jvHNMrDainF0XHQM,1966
+classify-2026.7.1.dist-info/RECORD,,

classify-2026.7.1.dist-info/WHEEL

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

classify-2026.7.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+classify = classify.main:run
+