dobermann 0.1.0__py3-none-any.whl

dobermann/__init__.py

@@ -0,0 +1,18 @@
+# Public facing API
+from .document import Document
+from .evaluators import EvaluationResult, SegmentationEvaluator
+from .segmenters import (
+    GraphSegEmbeddings,
+    SegmentationResult,
+    TextTilingEmbeddings,
+)
+
+__all__ = [
+    "Document",
+    "TextTiling",
+    "TextTilingEmbeddings",
+    "GraphSegEmbeddings",
+    "SegmentationEvaluator",
+    "EvaluationResult",
+    "SegmentationResult",
+]

dobermann/document.py

@@ -0,0 +1,20 @@
+# TODO: implement document import
+# create document from dataset
+# create document from raw text, document from text file.
+# create document from HTML
+# create document from URL
+
+from dataclasses import dataclass
+
+import nltk
+
+
+@dataclass
+class Document:
+    sentences: list[str]
+
+    @classmethod
+    def from_text(cls, text: str) -> "Document":
+        sentences = nltk.sent_tokenize(text)
+
+        return cls(sentences=sentences)

dobermann/evaluators/__init__.py

@@ -0,0 +1,3 @@
+from .segmentation_evaluator import SegmentationEvaluator, EvaluationResult
+
+__all__ = ["SegmentationEvaluator", "EvaluationResult"]

dobermann/evaluators/segmentation_evaluator.py

@@ -0,0 +1,207 @@
+import time
+from dataclasses import dataclass
+
+import numpy as np
+from nltk.metrics import ghd as ghd
+from nltk.metrics import pk as pk
+from nltk.metrics import windowdiff as wd
+
+# NOTE: only set k window size if segment lengths are highly variable
+
+
+@dataclass(slots=True, frozen=True)
+class EvaluationResult:
+    """Segmentation evluation result container.
+
+    Attributes:
+        hyp_str: Hypothesized segmentation string representation.
+        ref_str: Reference (ground truth) segmentation string representation.
+        pk: Pk error metrics under different settings.
+        wd: WindowDiff error metrics under different settings.
+        ghd: Generalized Hamming Distance error metric
+        runtime: Evaluation process execution time in seconds.
+    """
+
+    hyp_str: str
+    ref_str: str
+    pk: dict[str, float]
+    wd: dict[str, float]
+    ghd: float
+    runtime: float
+
+    def __str__(self) -> str:
+        """Evaluation result container summary tostring function.
+
+        Returns:
+            str: Multi-line human-readable and interpretable summary of evaluation result.
+        """
+        width = 34
+
+        lines = [
+            "EvaluationResult",
+            "-" * width,
+            f"{'Metric':<20}{'Value':>14}",
+            "-" * width,
+            f"{'Pk (small)':<20}{self.pk['small']:>14.4f}",
+            f"{'Pk (default)':<20}{self.pk['default']:>14.4f}",
+            f"{'Pk (large)':<20}{self.pk['large']:>14.4f}",
+            f"{'Pk (nltk)':<20}{self.pk['nltk']:>14.4f}",
+            "",
+            f"{'WD (small)':<20}{self.wd['small']:>14.4f}",
+            f"{'WD (default)':<20}{self.wd['default']:>14.4f}",
+            f"{'WD (large)':<20}{self.wd['large']:>14.4f}",
+            "",
+            f"{'GHD':<20}{self.ghd:>14.4f}",
+            f"{'Runtime (s)':<20}{self.runtime:>14.4f}",
+            "-" * width,
+            f"REF {self.ref_str}",
+            f"HYP {self.hyp_str}",
+        ]
+        return "\n".join(lines)
+
+
+class SegmentationEvaluator:
+    """Stateful evaluator for comparing segmentation results against ground truth.
+
+    Attributes:
+        ins_cost: Cost of inserting a boundary.
+        del_cost: Cost of deleting a boundary.
+        shift_cost_coeff: Cost of shifting a boundary.
+        boundary_symbol: Character symbol that denotes a boundary.
+    """
+
+    def __init__(
+        self,
+        ins_cost=2.0,
+        del_cost=2.0,
+        shift_cost_coeff=1.0,
+        boundary_symbol="1",
+    ):
+
+        self.ins_cost = ins_cost
+        self.del_cost = del_cost
+        self.shift_cost_coeff = shift_cost_coeff
+        self.boundary_symbol = boundary_symbol
+
+    def evaluate(
+        self,
+        ref_len: list[int],
+        hyp_len: list[int],
+    ) -> EvaluationResult:
+        """Evaluation function
+
+        Args:
+            ref_len: Reference (ground truth) segment lengths.
+            hyp_len: Hypothesized segment lengths.
+
+        Returns:
+            EvaluationResult: Evaluation result container.
+        """
+        start_time = time.perf_counter()
+
+        self._validate_input(ref_len, hyp_len)
+
+        # string boundary representation
+        ref_str = self._lengths_to_str(ref_len)
+        hyp_str = self._lengths_to_str(hyp_len)
+
+        self._validate_conversion(str_rep=ref_str, len_rep=ref_len)
+        self._validate_conversion(str_rep=hyp_str, len_rep=hyp_len)
+
+        ghd_score = ghd(
+            ref_str,
+            hyp_str,
+            self.ins_cost,
+            self.del_cost,
+            self.shift_cost_coeff,
+            boundary=self.boundary_symbol,
+        )
+
+        pk_scores = {}
+        wd_scores = {}
+
+        k_values = self._k_values(ref_str, ref_len)
+        for k_name, k in k_values.items():
+            pk_scores[k_name] = pk(ref_str, hyp_str, k=k, boundary=self.boundary_symbol)
+            wd_scores[k_name] = wd(ref_str, hyp_str, k=k, boundary=self.boundary_symbol)
+
+        # optional: include nltk default (k=None)
+        pk_scores["nltk"] = pk(ref_str, hyp_str, k=None, boundary=self.boundary_symbol)
+
+        end_time = time.perf_counter()
+        runtime = end_time - start_time
+
+        return EvaluationResult(
+            hyp_str=hyp_str,
+            ref_str=ref_str,
+            pk=pk_scores,
+            wd=wd_scores,
+            ghd=ghd_score,
+            runtime=runtime,
+        )
+
+    def _lengths_to_str(self, lengths: list[int]) -> str:
+        s = []
+        for i, length in enumerate(lengths):
+            s.extend(["0"] * (length - 1))
+            if i != len(lengths) - 1:
+                s.append("1")
+        return "".join(s)
+
+    def _k_values(self, ref_str, ref_lengths: list[int]) -> dict[str, int]:
+
+        # percentile approach
+        k_small = max(1, int(round(np.percentile(ref_lengths, 25) / 2)))
+        # k_default = max(1, int(round(np.mean(ref_lengths) / 2)))
+        k_default = self._nltk_default_k(ref_str)
+        k_large = max(1, int(round(np.percentile(ref_lengths, 75) / 2)))
+
+        # min and max approach
+        # k_small = max(1, int(round(min(ref_lengths) / 2)))
+        # k_default = int(round((sum(ref_lengths) / len(ref_lenghts)) / 2))
+        # k_large = int(round(max(ref_lengths) / 2))
+
+        return {
+            "small": k_small,
+            "default": k_default,
+            "large": k_large,
+        }
+
+    def _validate_input(self, ref_len, hyp_len):
+        # TODO: add more meaningful error messages
+        ref_sum = sum(ref_len)
+        hyp_sum = sum(hyp_len)
+
+        if ref_sum != hyp_sum:
+            raise ValueError(
+                f"Segmentations must cover the same total length "
+                f"(number of sentences).\n"
+                f"Got: sum(ref_len)={ref_sum}, sum(hyp_len)={hyp_sum}"
+            )
+
+        invalid_ref = [len for len in ref_len if len <= 0]
+        invalid_hyp = [len for len in hyp_len if len <= 0]
+
+        if invalid_ref or invalid_hyp:
+            raise ValueError(
+                "Segment lengths must all be positive integers.\n"
+                f"Invalid values in ref_len: {invalid_ref}\n"
+                f"Invalid values in hyp_len: {invalid_hyp}"
+            )
+
+    # accept len and str and test if it makes sense
+    def _validate_conversion(
+        self,
+        str_rep: str,
+        len_rep: list[int],
+    ):
+        assert len(str_rep) == sum(len_rep) - 1
+
+    def _nltk_default_k(self, ref_str, boundary: str = "1") -> int:
+        n = len(ref_str)
+        b = ref_str.count(boundary)
+
+        if b == 0:
+            raise ValueError("Reference contains no boundaries")
+
+        return int(round(n / (2.0 * b)))

dobermann/segmenters/__init__.py

@@ -0,0 +1,9 @@
+from .abstract import SegmentationResult
+from .graphseg_embeddings import GraphSegEmbeddings
+from .texttiling_embeddings import TextTilingEmbeddings
+
+__all__ = [
+    "TextTilingEmbeddings",
+    "GraphSegEmbeddings",
+    "SegmentationResult",
+]

dobermann/segmenters/abstract.py

@@ -0,0 +1,79 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+
+
+@dataclass(slots=True, frozen=True)
+class SegmentationResult:
+    """Result returned by segmenters.
+
+    Attributes:
+        segment_lengths:
+            Length of each predicted segment.
+
+        runtime:
+            Segmentation runtime in seconds.
+
+        metadata:
+            Optional algorithm-specific intermediate values.
+    """
+
+    segment_lengths: list[int]
+    runtime: float
+    # method: str
+    metadata: dict = field(default_factory=dict)
+
+    def iter_spans(self):
+        start = 0
+
+        for length in self.segment_lengths:
+            end = start + length
+            yield start, end
+            start = end
+
+    # TODO: redesign akwared api
+    # curr: result.split(document.sentences)
+    # goal: result.split()
+    def split(self, sentences: list[str]) -> list[list[str]]:
+        chunks = []
+
+        for start, end in self.iter_spans():
+            chunks.append(sentences[start:end])
+
+        return chunks
+
+
+class Segmenter(ABC):
+    """Abstract topic segmentation interface."""
+
+    def segment(self, sentences: list[str]) -> SegmentationResult:
+        """Segment sentences into topical regions.
+
+        Args:
+            sentences:
+                Ordered sentence sequence.
+
+        Returns:
+            Segmentation result containing:
+            - segment lengths
+            - runtime information
+            - optional metadata
+        """
+        self._validate_input(sentences)
+        return self._segment(sentences)
+
+    @abstractmethod
+    def _segment(self, sentences: list[str]) -> SegmentationResult: ...
+
+    def _validate_input(self, sentences: list[str]):
+
+        # 1. Must be a list of str --> 1.1 List, 1.2 Str
+        # 2. Cannot be empty list
+
+        if not isinstance(sentences, list):
+            raise TypeError("sentences must be a list of str")
+
+        if any(not isinstance(s, str) for s in sentences):
+            raise TypeError("all elements in sentences must be str")
+
+        if len(sentences) == 0:
+            raise ValueError("sentences must be nonempty")

dobermann/segmenters/graphseg_embeddings.py

@@ -0,0 +1,226 @@
+import logging
+import time
+
+import networkx as nx
+import numpy as np
+from sentence_transformers import SentenceTransformer
+from sklearn.metrics.pairwise import cosine_similarity
+from transformers import logging as hf_logging
+
+from .abstract import SegmentationResult, Segmenter
+
+
+class GraphSegEmbeddings(Segmenter):
+    """
+    Improved GraphSeg-style topic segmentation using sentence embeddings.
+
+    Pipeline:
+    1. Encode sentences
+    2. Build weighted similarity graph with positional decay
+    3. Detect communities
+    4. Convert communities -> ordered labels
+    5. Smooth labels with neighborhood majority vote
+    6. Convert smoothed labels -> segment lengths
+    """
+
+    def __init__(self, model: str):
+        logging.getLogger("sentence_transformers").setLevel(logging.ERROR)
+        hf_logging.set_verbosity_error()
+        self.model = SentenceTransformer(model)
+
+    # --------------------------------------------------
+    # MAIN
+    # --------------------------------------------------
+
+    def _segment(self, sentences: list[str]) -> SegmentationResult:
+        start = time.perf_counter()
+
+        embeddings = self._vectorize(sentences)
+        sim_matrix = self._similarity_matrix(embeddings)
+
+        graph = self._build_graph(sim_matrix)
+        communities = self._communities(graph)
+
+        labels = self._communities_to_labels(
+            communities=communities,
+            n_sentences=len(sentences),
+        )
+
+        smoothed_labels = self._smooth_labels(labels, window=2)
+
+        segment_lengths = self._labels_to_segments(smoothed_labels)
+
+        runtime = time.perf_counter() - start
+
+        metadata = {
+            "embeddings": embeddings,
+            "similarity_matrix": sim_matrix,
+            "graph": graph,
+            "communities": communities,
+            "labels": labels,
+            "smoothed_labels": smoothed_labels,
+        }
+
+        return SegmentationResult(
+            segment_lengths=segment_lengths,
+            runtime=runtime,
+            metadata=metadata,
+        )
+
+    # --------------------------------------------------
+    # VECTORIZE
+    # --------------------------------------------------
+
+    def _vectorize(self, sentences: list[str]) -> np.ndarray:
+        return self.model.encode(sentences)
+
+    # --------------------------------------------------
+    # SIMILARITY
+    # --------------------------------------------------
+
+    def _similarity_matrix(self, embeddings: np.ndarray) -> np.ndarray:
+        return cosine_similarity(embeddings)
+
+    # --------------------------------------------------
+    # GRAPH BUILDING
+    # --------------------------------------------------
+
+    def _build_graph(
+        self,
+        sim_matrix: np.ndarray,
+        max_distance: int = 15,
+        min_similarity: float = 0.30,
+        decay: float = 0.15,
+    ) -> nx.Graph:
+        """
+        Weighted graph.
+
+        Edge weight:
+            similarity * exp(-decay * distance)
+
+        Keeps softer structure than hard thresholding.
+        """
+
+        n = len(sim_matrix)
+        G = nx.Graph()
+
+        for i in range(n):
+            G.add_node(i)
+
+        for i in range(n):
+            for j in range(i + 1, min(n, i + max_distance + 1)):
+                sim = float(sim_matrix[i, j])
+
+                if sim < min_similarity:
+                    continue
+
+                distance = abs(i - j)
+                weight = sim * np.exp(-decay * distance)
+
+                if weight > 0:
+                    G.add_edge(i, j, weight=weight)
+
+        return G
+
+    # --------------------------------------------------
+    # COMMUNITIES
+    # --------------------------------------------------
+
+    def _communities(self, graph: nx.Graph) -> list[list[int]]:
+        """
+        Greedy modularity clustering.
+        """
+
+        communities = nx.algorithms.community.greedy_modularity_communities(
+            graph,
+            weight="weight",
+        )
+
+        return [sorted(list(c)) for c in communities]
+
+    # --------------------------------------------------
+    # COMMUNITIES -> LABELS
+    # --------------------------------------------------
+
+    def _communities_to_labels(
+        self,
+        communities: list[list[int]],
+        n_sentences: int,
+    ) -> list[int]:
+        """
+        Convert unordered communities into sentence-order labels.
+        """
+
+        labels = [-1] * n_sentences
+
+        for cid, community in enumerate(communities):
+            for idx in community:
+                labels[idx] = cid
+
+        # isolated nodes remain unique singleton labels
+        next_label = len(communities)
+
+        for i in range(n_sentences):
+            if labels[i] == -1:
+                labels[i] = next_label
+                next_label += 1
+
+        return labels
+
+    # --------------------------------------------------
+    # LABEL SMOOTHING
+    # --------------------------------------------------
+
+    def _smooth_labels(
+        self,
+        labels: list[int],
+        window: int = 2,
+    ) -> list[int]:
+        """
+        Majority-vote smoothing.
+
+        Example:
+            A A B A A -> A A A A A
+        """
+
+        smoothed = labels.copy()
+        n = len(labels)
+
+        for i in range(n):
+            left = max(0, i - window)
+            right = min(n, i + window + 1)
+
+            neighborhood = labels[left:right]
+
+            values, counts = np.unique(neighborhood, return_counts=True)
+            majority = values[np.argmax(counts)]
+
+            smoothed[i] = int(majority)
+
+        return smoothed
+
+    # --------------------------------------------------
+    # LABELS -> SEGMENTS
+    # --------------------------------------------------
+
+    def _labels_to_segments(self, labels: list[int]) -> list[int]:
+        """
+        Convert contiguous labels into segment lengths.
+        """
+
+        lengths = []
+
+        current = labels[0]
+        run = 1
+
+        for i in range(1, len(labels)):
+            if labels[i] == current:
+                run += 1
+            else:
+                lengths.append(run)
+                run = 1
+                current = labels[i]
+
+        lengths.append(run)
+
+        return lengths

dobermann/segmenters/texttiling_embeddings.py

@@ -0,0 +1,133 @@
+import logging
+import time
+
+import numpy as np
+from scipy.ndimage import uniform_filter1d
+from scipy.signal import find_peaks
+from sentence_transformers import SentenceTransformer
+from sklearn.metrics.pairwise import cosine_similarity
+from transformers import logging as hf_logging
+
+from .abstract import SegmentationResult, Segmenter
+
+
+class TextTilingEmbeddings(Segmenter):
+    """Embedding-based TextTiling segmentation.
+
+    This segmenter replaces lexical similarity with sentence
+    embedding similarity computed from a transformer model.
+
+    Pipeline:
+        1. Encode sentences into embeddings
+        2. Compute adjacent cosine similarities
+        3. Smooth similarity signal
+        4. Detect valley boundaries
+        5. Convert boundaries into segment lengths
+
+    Args:
+        model:
+            SentenceTransformer model name.
+    """
+
+    def __init__(self, model: str):
+        logging.getLogger("sentence_transformers").setLevel(logging.ERROR)
+        hf_logging.set_verbosity_error()
+        self.model = SentenceTransformer(model)
+
+    def _segment(self, sentences: list[str]) -> SegmentationResult:
+        start = time.perf_counter()
+
+        embeddings = self._vectorize(self.model, sentences)
+        similarities = self._similarity(embeddings)
+        smoothed = self._smooth(similarities)
+        boundaries = self._boundaries(signal=smoothed)
+        segment_lengths = self._postprocess(
+            boundaries=boundaries, n_sentences=len(sentences)
+        )
+
+        end = time.perf_counter()
+        runtime = end - start
+
+        metadata = {
+            "embeddings": embeddings,
+            "similarities": similarities,
+            "smoothed": smoothed,
+            "boundaries": boundaries,
+        }
+
+        return SegmentationResult(
+            segment_lengths=segment_lengths, runtime=runtime, metadata=metadata
+        )
+
+    def _vectorize(self, model, sentences):
+        embeddings = model.encode(sentences)
+        return embeddings
+
+    def _similarity(self, embeddings):
+        sims = []
+
+        for i in range(len(embeddings) - 1):
+            sim = cosine_similarity([embeddings[i]], [embeddings[i + 1]])[0][0]
+
+            sims.append(sim)
+
+        return sims
+
+    def _smooth(self, similarities):
+        # TODO: make smoothing windows a class state
+        smoothed = uniform_filter1d(similarities, size=2)
+        return smoothed
+
+    # TODO: fix thresholding
+    # TODO: adaptive thresholding
+
+    def _boundaries(self, signal, alpha=0.5, plimit=0.1):
+        """
+        signal: smoothed similarity curve
+        alpha : threshold parameter
+        plimit: minimum candidate score
+        """
+
+        signal = np.asarray(signal)
+
+        valleys, _ = find_peaks(-signal)
+
+        candidates = []
+
+        for v in valleys:
+            left_peak = np.max(signal[: v + 1])
+            right_peak = np.max(signal[v:])
+
+            score = 0.5 * (left_peak + right_peak - 2 * signal[v])
+
+            if score >= plimit:
+                candidates.append((v, score))
+
+        if not candidates:
+            return []
+
+        vals = np.array([s for _, s in candidates])
+
+        mu = np.mean(vals)
+        sigma = np.std(vals)
+
+        threshold = mu - alpha * sigma
+
+        boundaries = [idx for idx, score in candidates if score >= threshold]
+
+        return boundaries
+
+    def _postprocess(self, boundaries, n_sentences):
+        boundaries = sorted(int(b) for b in boundaries)
+
+        lengths = []
+        start = 0
+
+        for b in boundaries:
+            end = b + 1  # boundary after sentence b
+            lengths.append(end - start)
+            start = end
+
+        lengths.append(n_sentences - start)
+
+        return lengths

dobermann-0.1.0.dist-info/METADATA

@@ -0,0 +1,82 @@
+Metadata-Version: 2.3
+Name: dobermann
+Version: 0.1.0
+Summary: Add your description here
+Author: Paddy Denier
+Author-email: Paddy Denier <202327146+paddydenier@users.noreply.github.com>
+Requires-Dist: spacy>=3.8.14
+Requires-Dist: nltk>=3.9.4
+Requires-Dist: sentence-transformers>=5.4.1
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# dobermann
+
+Dobermann is a modern Python library for discourse segmentation, evaluation, and visualization, combining classical computational linguistics literature with contemporary NLP and embedding-based methods.
+
+![ci workflow](https://github.com/paddydenier/dobermann/actions/workflows/ci.yml/badge.svg)
+![docs workflow](https://github.com/paddydenier/dobermann/actions/workflows/docs.yml/badge.svg)
+
+## Features
+
+- ✂️ Discourse Segmentation Algorithms from Computational Linguistics Literature
+- 📈 Built-In Datasets and Evaluation Metrics
+- 👀 Visualization Tools
+- 📖 Free and Open Source
+
+## Installation
+
+Dobermann can conveniently be installed through the pip package manager:
+
+```bash
+pip install dobermann
+```
+
+Alternatively, clone the repository to access the full range of tools or contribute to the project:
+
+```bash
+git clone https://github.com/paddydenier/dobermann.git
+cd dobermann
+pip install -e .
+```
+
+TODO: explain constraints.
+
+## Usage
+
+Minimal segmentation and evaluation workflow example:
+
+<!-- BEGIN:quickstart -->
+```python
+from dobermann import Document, GraphSegEmbeddings, SegmentationEvaluator
+
+text = "Cats are domesticated mammals that are commonly kept as pets. They belong to the family Felidae and are known for their agility. Cats have sharp claws and excellent night vision. Many cats communicate using vocalizations such as meowing and purring. Dogs are also domesticated mammals and are among the most common household pets. They belong to the family Canidae and have a strong sense of smell. Dogs have been bred for many different purposes, including hunting and herding. Many dogs are trained to assist humans in various tasks. Python is a high-level programming language used for many different applications. It is widely used in web development, data science, and automation. Python uses indentation to define blocks of code. Functions in Python can accept arguments and return values. A function is defined using the def keyword. Python also provides many built-in data structures such as lists and dictionaries."
+document = Document.from_text(text)
+
+segmenter = GraphSegEmbeddings("all-MiniLM-L6-v2")
+segmentation_result = segmenter.segment(document.sentences)
+
+print(segmentation_result.split(document.sentences))
+```
+<!-- END:quickstart -->
+
+## API Usage
+
+For integration into existing pipelines, Dobermann provides a standardized FastAPI interface for exposing its segmentation capabilities through a REST API.
+
+### Starting the API
+
+On default port 8000:
+
+```bash
+make backend
+```
+
+On custom port, e.g., 8081:
+```bash
+make backend PORT=8081
+```
+
+## Contribution and Development Workflows
+
+TODO: explain makefile.

dobermann-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+dobermann/__init__.py,sha256=5x3yE-EJJrmoVW_-1l1F5gkH-kG38E8yO1_m5KLr7CQ,399
+dobermann/document.py,sha256=_JLFgIC0oapKTmxfDDdiIHPqdzish7KBKMjTVi1GMaA,433
+dobermann/evaluators/__init__.py,sha256=UPWFVoOom_Kelf6CBirBSvlm4CMsaF0h2Krs36e6sEo,133
+dobermann/evaluators/segmentation_evaluator.py,sha256=QNVewQPA-H_9gDfnUc07HWrU2FAQNDxEWGdY8A36iDU,6556
+dobermann/segmenters/__init__.py,sha256=CW7LkKFTx-Fv3taCy6HzVYqhwTlV0Ymnee0jotJ0tFs,244
+dobermann/segmenters/abstract.py,sha256=T_1J4g1NjkcvdUoVx-iuigLjJARFdAs-gsb86sPh1wo,2108
+dobermann/segmenters/graphseg_embeddings.py,sha256=Jfg-iCI_SBjrNhwUPjrzhOpPta6pNklr9416MRD7uyQ,6159
+dobermann/segmenters/texttiling_embeddings.py,sha256=snQtRK4DmOWAYUwiBM_65Vi6CXV40N0Guz8AWem2S2o,3697
+dobermann-0.1.0.dist-info/WHEEL,sha256=4OL6Foqnnp3xRY5wMkjgc25_i5YJC6dKsC6LPcjqEoU,80
+dobermann-0.1.0.dist-info/entry_points.txt,sha256=j7mpNERTXQapqbQODRuJq9jjYg3KkuDsIbU7ft8jqPk,46
+dobermann-0.1.0.dist-info/METADATA,sha256=5zrkV_Cq_Jh3liyYPkK4iFp8_f35tLNNN8Gh3BVUe-U,3025
+dobermann-0.1.0.dist-info/RECORD,,

dobermann-0.1.0.dist-info/WHEEL

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

dobermann-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+dobermann = dobermann:main
+