paces 0.0.17__tar.gz → 0.0.19__tar.gz

{paces-0.0.17 → paces-0.0.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: paces
-Version: 0.0.17
+Version: 0.0.19
 Summary: Turn instructional media into structured, interactive learning material
 Project-URL: Homepage, https://github.com/thorwhalen/paces
 Project-URL: Repository, https://github.com/thorwhalen/paces

{paces-0.0.17 → paces-0.0.19}/paces/ask.py

@@ -49,7 +49,7 @@ from paces.corrections import (
     time_str,
 )
 from paces.model import seconds_per_unit
-from paces.segmenters import Segmentation
+from paces.segmentation import Segmentation
 
 PROPOSAL_KIND = "PacesAskProposal"
 ANSWERS_KIND = "PacesAskAnswers"

{paces-0.0.17 → paces-0.0.19}/paces/corrections.py

@@ -42,7 +42,7 @@ from dataclasses import dataclass
 from typing import Literal, get_args
 
 from paces.model import decimal_str
-from paces.segmenters import (
+from paces.segmentation import (
     DFLT_EXPLICIT_CONFIDENCE,
     SegStep,
     Segmentation,

{paces-0.0.17 → paces-0.0.19}/paces/evidence.py

@@ -144,7 +144,7 @@ from paces.model import (
     StepDocument,
 )
 from paces.projection import to_document
-from paces.segmenters import Segmentation
+from paces.segmentation import Segmentation
 
 #: The namespace every paces annotation id is derived under. Derived from the
 #: repository URL rather than typed as a literal, so it is reproducible from
@@ -454,7 +454,7 @@ def to_store(
     *seg* is the analysis result; the projection arguments (*doc_id*,
     *title*, *source*, *domain*, *lang*) are :func:`paces.to_document`'s,
     unchanged. Everything else is evidence a segmenter does not carry on
-    :class:`~paces.segmenters.Segmentation` but a pipeline may have:
+    :class:`~paces.segmentation.Segmentation` but a pipeline may have:
 
     Args:
         store: Any ``lacing.IntervalAnnotationStore`` — ``MemoryStore()`` for

{paces-0.0.17 → paces-0.0.19}/paces/model.py

@@ -24,6 +24,7 @@ Design decisions, each argued in ``docs/07-annotation-model.md``:
 
 from __future__ import annotations
 
+import math
 from collections.abc import Mapping
 from datetime import datetime
 from fractions import Fraction
@@ -286,9 +287,16 @@ def decimal_str(value: float, *, places: int = 3) -> str:
 
     >>> decimal_str(72.60000000000001, places=3)
     '72.6'
+    >>> decimal_str(-0.0004, places=3)  # rounds to zero: no sign
+    '0'
     """
-    text = f"{float(value):.{places}f}".rstrip("0").rstrip(".")
-    return text or "0"
+    number = float(value)
+    if not math.isfinite(number):
+        raise ValueError(f"no decimal string for a non-finite value: {value!r}")
+    text = f"{number:.{places}f}"
+    if "." in text:  # places=0 has no fraction to trim
+        text = text.rstrip("0").rstrip(".")
+    return "0" if text in ("", "-0") else text
 
 
 # ── serialisation (the git rules of docs/07 §6.5) ───────────────────────────

{paces-0.0.17 → paces-0.0.19}/paces/projection.py

@@ -21,7 +21,7 @@ from paces.model import (
     StepDocument,
     seconds_per_unit,
 )
-from paces.segmenters import SegStep, Segmentation
+from paces.segmentation import SegStep, Segmentation
 
 #: Decimal places kept when converting computed seconds to wire decimals —
 #: matches the POC's 0.1 s working resolution with headroom.

paces-0.0.19/paces/segmentation.py

@@ -0,0 +1,74 @@
+"""What a segmenter returns: :class:`Segmentation`, its :class:`SegStep` records and
+the ``Span`` they cover — the analysis-result types, with nothing else.
+
+They live apart from :mod:`paces.segmenters` (the registry and the
+``segment()`` facade) so a module that only consumes or reshapes a result —
+:mod:`paces.corrections`, :mod:`paces.projection`, :mod:`paces.ask`, the
+evidence layer — depends on the types and not on the facade, and the facade
+can import those modules without a cycle. :mod:`paces.segmenters` re-exports
+every name here, so ``from paces.segmenters import Segmentation`` keeps
+working.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from typing import Any
+
+from paces.model import MetricGrid
+
+__all__ = [
+    "DFLT_CHAPTERS_CONFIDENCE",
+    "DFLT_EXPLICIT_CONFIDENCE",
+    "DFLT_GRID_CONFIDENCE",
+    "SegStep",
+    "Segmentation",
+    "Span",
+]
+
+Span = tuple[float, float]  # seconds, half-open
+
+# Confidence constants: placement from user-supplied inputs is arithmetic, so
+# what these grade is trust in the inputs, not in any inference.
+DFLT_EXPLICIT_CONFIDENCE = 0.95  # a human said so
+DFLT_GRID_CONFIDENCE = 0.9  # exact given the grid; the grid itself may drift
+DFLT_CHAPTERS_CONFIDENCE = 0.9  # the author said so, in metadata
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class SegStep:
+    """One named piece of the media, as an analysis result.
+
+    ``name=''`` means "found, not named" — a VALID state, not an error.
+    ``spans`` is a tuple because a step legitimately appears in several places
+    (run-through AND breakdown).
+    """
+
+    id: str
+    name: str = ""
+    spans: tuple[Span, ...] = ()
+    confidence: float = 0.0
+    children: tuple["SegStep", ...] = ()
+    source: str = ""  # which capability produced it
+    evidence: Mapping[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Segmentation:
+    """What every segmenter returns. Reviewable, re-runnable, arguable.
+
+    ``boundaries`` is separate from ``steps`` and populated even when naming
+    failed: nine excellent unnamed cuts are a useful, honest result. ``steps``
+    may be empty while ``boundaries`` is not.
+    """
+
+    steps: tuple[SegStep, ...] = ()  # ordered; MAY be empty while boundaries is not
+    boundaries: tuple[float, ...] = ()  # the raw cut set, always
+    unit: str = "seconds"  # "eight" | "rep" | "seconds"
+    grid: MetricGrid | None = None
+    confidence: float = 0.0
+    method: str = ""  # which capability ran (the ADR's "reported default")
+    flags: tuple[str, ...] = ()  # 'naming-abstained', 'no-signal', 'try: ...'
+    elapsed_s: float = 0.0
+    spent_usd: float = 0.0

{paces-0.0.17 → paces-0.0.19}/paces/segmenters.py

@@ -44,55 +44,18 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Callable
 
+from paces import corrections as corrections_module
 from paces.model import MetricGrid, seconds_per_unit
+from paces.segmentation import (  # noqa: F401 — re-exported; their home is there
+    DFLT_CHAPTERS_CONFIDENCE,
+    DFLT_EXPLICIT_CONFIDENCE,
+    DFLT_GRID_CONFIDENCE,
+    SegStep,
+    Segmentation,
+    Span,
+)
 from paces.timed_text import normalize_timed_text
 
-Span = tuple[float, float]  # seconds, half-open
-
-# Confidence constants: placement from user-supplied inputs is arithmetic, so
-# what these grade is trust in the inputs, not in any inference.
-DFLT_EXPLICIT_CONFIDENCE = 0.95  # a human said so
-DFLT_GRID_CONFIDENCE = 0.9  # exact given the grid; the grid itself may drift
-DFLT_CHAPTERS_CONFIDENCE = 0.9  # the author said so, in metadata
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class SegStep:
-    """One named piece of the media, as an analysis result.
-
-    ``name=''`` means "found, not named" — a VALID state, not an error.
-    ``spans`` is a tuple because a step legitimately appears in several places
-    (run-through AND breakdown).
-    """
-
-    id: str
-    name: str = ""
-    spans: tuple[Span, ...] = ()
-    confidence: float = 0.0
-    children: tuple["SegStep", ...] = ()
-    source: str = ""  # which capability produced it
-    evidence: Mapping[str, Any] = field(default_factory=dict)
-
-
-@dataclass(frozen=True, slots=True, kw_only=True)
-class Segmentation:
-    """What every segmenter returns. Reviewable, re-runnable, arguable.
-
-    ``boundaries`` is separate from ``steps`` and populated even when naming
-    failed: nine excellent unnamed cuts are a useful, honest result. ``steps``
-    may be empty while ``boundaries`` is not.
-    """
-
-    steps: tuple[SegStep, ...] = ()  # ordered; MAY be empty while boundaries is not
-    boundaries: tuple[float, ...] = ()  # the raw cut set, always
-    unit: str = "seconds"  # "eight" | "rep" | "seconds"
-    grid: MetricGrid | None = None
-    confidence: float = 0.0
-    method: str = ""  # which capability ran (the ADR's "reported default")
-    flags: tuple[str, ...] = ()  # 'naming-abstained', 'no-signal', 'try: ...'
-    elapsed_s: float = 0.0
-    spent_usd: float = 0.0
-
 
 @dataclass(frozen=True, slots=True, kw_only=True)
 class Capability:
@@ -354,13 +317,6 @@ def _facts(
     return frozenset(facts)
 
 
-def _corrections_api():
-    """:mod:`paces.corrections`, imported lazily: it imports this module."""
-    from paces import corrections
-
-    return corrections
-
-
 def _apply_corrections(
     result: Segmentation, log: tuple, capability: Capability | None
 ) -> Segmentation:
@@ -370,7 +326,7 @@ def _apply_corrections(
     unmatched — rather than dropped."""
     if not log or (capability is not None and "corrections" in capability.reads):
         return result
-    return _corrections_api().replay(result, log)
+    return corrections_module.replay(result, log)
 
 
 # ── the facade ──────────────────────────────────────────────────────────────
@@ -418,7 +374,7 @@ def segment(
     transcript_cues = normalize_timed_text(transcript)
     # fail fast: a malformed log raises before any segmenter runs
     correction_log = (
-        _corrections_api().normalize_corrections(corrections)
+        corrections_module.normalize_corrections(corrections)
         if corrections is not None
         else ()
     )

{paces-0.0.17 → paces-0.0.19}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "paces"
-version = "0.0.17"
+version = "0.0.19"
 description = "Turn instructional media into structured, interactive learning material"
 readme = "README.md"
 license = "MIT"

{paces-0.0.17 → paces-0.0.19}/tests/test_ask.py

@@ -232,6 +232,8 @@ def test_js_time_format_matches_the_python_wire_format():
     values = [0, 15, 95.8, 0.8550444, 10.1235, 1e-7, 123.4567, 7.0005, 59.9996]
     # exact binary ties: Python's format rounds half-even, toFixed rounds up
     values += [10.0625, 0.0625, 0.1875, 0.3125, 2.5625, 1023.9375, 0.0005]
+    # values that round to zero carry no sign, in either language (#40)
+    values += [-0.0004, -0.0, -1e-9]
     got = _run_js(f"{json.dumps(values)}.map(core.timeStr)")
     assert got == [decimal_str(v, places=3) for v in values]
 

{paces-0.0.17 → paces-0.0.19}/tests/test_segment.py

@@ -145,3 +145,28 @@ def test_tools_segment_accepts_json_strings():
     assert payload["method"] == "grid-placed"
     assert payload["steps"][0]["name"] == "intro"
     json.dumps(payload)  # JSON-ready throughout
+
+
+@pytest.mark.parametrize(
+    "value, places, expected",
+    [
+        (-0.0004, 3, "0"),  # rounds to zero: no sign (#40)
+        (-0.0, 3, "0"),
+        (-0.0005, 3, "-0.001"),
+        (100, 0, "100"),  # places=0: no fraction to trim, digits stay
+        (-0.4, 0, "0"),
+        (72.60000000000001, 3, "72.6"),
+    ],
+)
+def test_decimal_str_writes_clean_wire_decimals(value, places, expected):
+    from paces.model import decimal_str
+
+    assert decimal_str(value, places=places) == expected
+
+
+@pytest.mark.parametrize("value", [float("nan"), float("inf"), float("-inf")])
+def test_decimal_str_refuses_non_finite_values(value):
+    from paces.model import decimal_str
+
+    with pytest.raises(ValueError, match="non-finite"):
+        decimal_str(value)