edgar-pit-clock 0.1.0__py3-none-any.whl

edgar_pit_clock/__init__.py

@@ -0,0 +1,36 @@
+"""
+edgar_pit_clock — Deterministic Point-in-Time SEC EDGAR Timestamp & Session Router.
+
+Maintained by Starling Quantitative Research (https://starlingquant.com).
+Zero external dependencies; 100% deterministic Python standard library.
+"""
+
+from .clock import (
+    MarketSession,
+    PointInTimeAlignment,
+    PurgedFold,
+    add_nyse_trading_days,
+    align_filing_to_market_bar,
+    is_nyse_trading_day,
+    next_nyse_trading_day,
+    normalize_cik10,
+    normalize_sec_artifact_id,
+    parse_edgar_acceptance,
+    purged_walk_forward_splits,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "MarketSession",
+    "PointInTimeAlignment",
+    "PurgedFold",
+    "add_nyse_trading_days",
+    "align_filing_to_market_bar",
+    "is_nyse_trading_day",
+    "next_nyse_trading_day",
+    "normalize_cik10",
+    "normalize_sec_artifact_id",
+    "parse_edgar_acceptance",
+    "purged_walk_forward_splits",
+]

edgar_pit_clock/clock.py

@@ -0,0 +1,329 @@
+"""
+Core point-in-time SEC EDGAR timestamp alignment, NYSE holiday calendar,
+One-Document-One-Witness accession normalization, and Purged Walk-Forward CV splitting.
+
+Reference:
+  Starling Quantitative Research Note RN-01:
+  "Point-in-Time Alternative Data Ingestion, Entity Resolution & Survivorship-Free Panel Construction"
+  https://starlingquant.com/guides/point-in-time-alternative-data-and-survivorship-free-panels
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from datetime import date, datetime, time, timedelta, timezone
+from enum import Enum
+from typing import Iterable, Sequence
+from zoneinfo import ZoneInfo
+
+ET = ZoneInfo("America/New_York")
+MARKET_OPEN = time(9, 30, 0)
+MARKET_CLOSE = time(16, 0, 0)
+
+_DIGITS_14_RE = re.compile(r"^\d{14}$")
+_ACCESSION_RE = re.compile(r"(\d{10})-?(\d{2})-?(\d{6})")
+
+
+class MarketSession(str, Enum):
+    PRE_MARKET = "PRE_MARKET"
+    REGULAR_SESSION = "REGULAR_SESSION"
+    AFTER_HOURS = "AFTER_HOURS"
+    NON_TRADING_DAY = "NON_TRADING_DAY"
+
+
+@dataclass(frozen=True)
+class PointInTimeAlignment:
+    acceptance_et: datetime
+    acceptance_utc: datetime
+    market_session: MarketSession
+    daily_batch_bar_date: date
+    daily_batch_price_field: str
+    intraday_eligible: bool
+
+
+@dataclass(frozen=True)
+class PurgedFold:
+    fold_index: int
+    train_indices: tuple[int, ...]
+    test_indices: tuple[int, ...]
+    train_end_date: date
+    test_start_date: date
+    test_end_date: date
+    purged_count: int
+
+
+def _easter_sunday(year: int) -> date:
+    """Anonymous Gregorian computus for Western Easter Sunday."""
+    a = year % 19
+    b = year // 100
+    c = year % 100
+    d = b // 4
+    e = b % 4
+    f = (b + 8) // 25
+    g = (b - f + 1) // 3
+    h = (19 * a + b - d - g + 15) % 30
+    i = c // 4
+    k = c % 4
+    l_val = (32 + 2 * e + 2 * i - h - k) % 7
+    m = (a + 11 * h + 22 * l_val) // 451
+    month = (h + l_val - 7 * m + 114) // 31
+    day = ((h + l_val - 7 * m + 114) % 31) + 1
+    return date(year, month, day)
+
+
+def _nth_weekday(year: int, month: int, weekday: int, n: int) -> date:
+    first = date(year, month, 1)
+    offset = (weekday - first.weekday()) % 7
+    return first + timedelta(days=offset + 7 * (n - 1))
+
+
+def _last_weekday(year: int, month: int, weekday: int) -> date:
+    if month == 12:
+        nxt = date(year + 1, 1, 1)
+    else:
+        nxt = date(year, month + 1, 1)
+    last = nxt - timedelta(days=1)
+    offset = (last.weekday() - weekday) % 7
+    return last - timedelta(days=offset)
+
+
+def _observed_fixed_holiday(d: date) -> date:
+    if d.weekday() == 5:  # Saturday -> Friday
+        return d - timedelta(days=1)
+    if d.weekday() == 6:  # Sunday -> Monday
+        return d + timedelta(days=1)
+    return d
+
+
+def _nyse_holidays_for_year(year: int) -> set[date]:
+    holidays: set[date] = set()
+    for fixed in (
+        date(year, 1, 1),
+        date(year + 1, 1, 1),  # Handles Jan 1 observed on Dec 31
+        date(year, 7, 4),
+        date(year, 12, 25),
+    ):
+        obs = _observed_fixed_holiday(fixed)
+        if obs.year == year:
+            holidays.add(obs)
+
+    if year >= 2022:
+        obs_june = _observed_fixed_holiday(date(year, 6, 19))
+        holidays.add(obs_june)
+
+    holidays.add(_nth_weekday(year, 1, 0, 3))   # MLK Jr. Day (3rd Mon Jan)
+    holidays.add(_nth_weekday(year, 2, 0, 3))   # Presidents' Day (3rd Mon Feb)
+    holidays.add(_easter_sunday(year) - timedelta(days=2))  # Good Friday
+    holidays.add(_last_weekday(year, 5, 0))     # Memorial Day (Last Mon May)
+    holidays.add(_nth_weekday(year, 9, 0, 1))   # Labor Day (1st Mon Sep)
+    holidays.add(_nth_weekday(year, 11, 3, 4))  # Thanksgiving (4th Thu Nov)
+    return holidays
+
+
+def is_nyse_trading_day(d: date) -> bool:
+    """Returns True if `d` is a regular weekday NYSE session."""
+    if isinstance(d, datetime):
+        d = d.date()
+    if d.weekday() >= 5:
+        return False
+    return d not in _nyse_holidays_for_year(d.year)
+
+
+def next_nyse_trading_day(d: date, *, inclusive: bool = False) -> date:
+    """Advances `d` to the next valid NYSE trading session."""
+    if isinstance(d, datetime):
+        d = d.date()
+    cur = d if inclusive else d + timedelta(days=1)
+    while not is_nyse_trading_day(cur):
+        cur += timedelta(days=1)
+    return cur
+
+
+def add_nyse_trading_days(d: date, n_days: int) -> date:
+    """Adds `n_days >= 0` NYSE trading sessions to `d`."""
+    if n_days < 0:
+        raise ValueError("n_days must be >= 0")
+    cur = next_nyse_trading_day(d, inclusive=True)
+    for _ in range(n_days):
+        cur = next_nyse_trading_day(cur, inclusive=False)
+    return cur
+
+
+def parse_edgar_acceptance(raw_ts: str | datetime) -> datetime:
+    """
+    Parses SEC EDGAR `acceptanceDateTime` into timezone-aware America/New_York (`ET`).
+
+    Supports:
+      - 14-digit EDGAR submission strings (`"20261113161504"`), which SEC EDGAR stamps in Eastern Time
+      - ISO-8601 strings with `Z` or explicit offset (`"2026-11-13T21:15:04.000Z"` or `"-05:00"`)
+      - Naive ISO-8601 strings from EDGAR `submissions` JSON (`"2026-11-13T16:15:04"`), interpreted as `ET`
+    """
+    if isinstance(raw_ts, datetime):
+        if raw_ts.tzinfo is None:
+            return raw_ts.replace(tzinfo=ET)
+        return raw_ts.astimezone(ET)
+
+    s = str(raw_ts).strip()
+    if not s:
+        raise ValueError("Empty acceptanceDateTime")
+
+    if _DIGITS_14_RE.match(s):
+        dt_naive = datetime.strptime(s, "%Y%m%d%H%M%S")
+        return dt_naive.replace(tzinfo=ET)
+
+    if s.endswith("Z") or s.endswith("z"):
+        s = s[:-1] + "+00:00"
+
+    parsed = datetime.fromisoformat(s)
+    if parsed.tzinfo is None:
+        return parsed.replace(tzinfo=ET)
+    return parsed.astimezone(ET)
+
+
+def align_filing_to_market_bar(raw_acceptance_ts: str | datetime) -> PointInTimeAlignment:
+    """
+    Routes an SEC filing's `acceptanceDateTime` to its earliest lookahead-free executable bar:
+      - `< 09:30:00 ET` on a trading day  -> `PRE_MARKET`, daily batch `Open(T_0)`
+      - `09:30:00 <= t < 16:00:00 ET`     -> `REGULAR_SESSION`, intraday `ArrivalMid` eligible, daily batch `Open(T+1)`
+      - `>= 16:00:00 ET`                  -> `AFTER_HOURS`, strictly `Open(T+1)` (eliminates the 4:15 PM filing trap)
+      - Weekend / NYSE Holiday            -> `NON_TRADING_DAY`, strictly `Open(next_trading_day)`
+    """
+    accept_et = parse_edgar_acceptance(raw_acceptance_ts)
+    accept_utc = accept_et.astimezone(timezone.utc)
+    cal_date = accept_et.date()
+    tod = accept_et.timetz().replace(tzinfo=None)
+
+    if not is_nyse_trading_day(cal_date):
+        return PointInTimeAlignment(
+            acceptance_et=accept_et,
+            acceptance_utc=accept_utc,
+            market_session=MarketSession.NON_TRADING_DAY,
+            daily_batch_bar_date=next_nyse_trading_day(cal_date, inclusive=False),
+            daily_batch_price_field="OPEN",
+            intraday_eligible=False,
+        )
+
+    if tod < MARKET_OPEN:
+        return PointInTimeAlignment(
+            acceptance_et=accept_et,
+            acceptance_utc=accept_utc,
+            market_session=MarketSession.PRE_MARKET,
+            daily_batch_bar_date=cal_date,
+            daily_batch_price_field="OPEN",
+            intraday_eligible=False,
+        )
+
+    if tod < MARKET_CLOSE:
+        return PointInTimeAlignment(
+            acceptance_et=accept_et,
+            acceptance_utc=accept_utc,
+            market_session=MarketSession.REGULAR_SESSION,
+            daily_batch_bar_date=next_nyse_trading_day(cal_date, inclusive=False),
+            daily_batch_price_field="OPEN",
+            intraday_eligible=True,
+        )
+
+    return PointInTimeAlignment(
+        acceptance_et=accept_et,
+        acceptance_utc=accept_utc,
+        market_session=MarketSession.AFTER_HOURS,
+        daily_batch_bar_date=next_nyse_trading_day(cal_date, inclusive=False),
+        daily_batch_price_field="OPEN",
+        intraday_eligible=False,
+    )
+
+
+def normalize_cik10(cik: str | int) -> str:
+    """Formats an SEC Central Index Key (`CIK`) to canonical 10-digit zero-padded string."""
+    digits = re.sub(r"\D", "", str(cik).strip())
+    if not digits or len(digits) > 10 or int(digits) == 0:
+        raise ValueError(f"Invalid SEC CIK: {cik!r}")
+    return digits.zfill(10)
+
+
+def normalize_sec_artifact_id(accession_or_url: str) -> str:
+    """
+    Canonicalizes any SEC accession string or EDGAR archive URL into a
+    One-Document-One-Witness identifier (`SEC:<18-digit-accession>`) so
+    multiple parsers reading the same filing cannot manufacture false confluence.
+    """
+    m = _ACCESSION_RE.search(str(accession_or_url))
+    if not m:
+        raise ValueError(f"Could not extract 18-digit SEC accession from {accession_or_url!r}")
+    return f"SEC:{m.group(1)}{m.group(2)}{m.group(3)}"
+
+
+def purged_walk_forward_splits(
+    entry_dates: Sequence[date],
+    *,
+    n_splits: int = 5,
+    horizon_trading_days: int = 10,
+    settlement_embargo_days: int = 2,
+    min_train_events: int = 30,
+) -> list[PurgedFold]:
+    """
+    Anchored Purged Walk-Forward Cross-Validation splitter (Lopez de Prado, 2018)
+    enforcing a trailing purge + settlement embargo gap so zero overlapping forward
+    return windows leak from the training set into the out-of-sample fold.
+    """
+    if n_splits < 2:
+        raise ValueError("n_splits must be >= 2")
+    n = len(entry_dates)
+    if n <= min_train_events:
+        raise ValueError(f"Need > {min_train_events} events, got {n}")
+
+    order = sorted(range(n), key=lambda idx: entry_dates[idx])
+    sorted_dates = [entry_dates[idx] for idx in order]
+    total_purge_days = horizon_trading_days + settlement_embargo_days
+
+    unique_dates = sorted(set(sorted_dates))
+    if len(unique_dates) < n_splits + 1:
+        raise ValueError("Insufficient distinct trading dates for requested n_splits")
+
+    # Reserve Chunk 0 as initial calibration warmup; evaluate Folds 1..n_splits out-of-sample
+    chunk_count = n_splits + 1
+    chunk_size = max(1, len(unique_dates) // chunk_count)
+    folds: list[PurgedFold] = []
+
+    for fold_idx in range(1, chunk_count):
+        test_start_dt = unique_dates[fold_idx * chunk_size]
+        test_end_dt = (
+            unique_dates[-1]
+            if fold_idx == chunk_count - 1
+            else unique_dates[(fold_idx + 1) * chunk_size - 1]
+        )
+
+        test_indices = tuple(
+            orig_i for orig_i, dt in zip(order, sorted_dates) if test_start_dt <= dt <= test_end_dt
+        )
+        if not test_indices:
+            continue
+
+        train_candidates: list[int] = []
+        purged_count = 0
+        for orig_i, dt in zip(order, sorted_dates):
+            if dt >= test_start_dt:
+                break
+            matured_dt = add_nyse_trading_days(dt, total_purge_days)
+            if matured_dt <= test_start_dt:
+                train_candidates.append(orig_i)
+            else:
+                purged_count += 1
+
+        if len(train_candidates) < min_train_events:
+            continue
+
+        train_end_dt = max(entry_dates[i] for i in train_candidates)
+        folds.append(
+            PurgedFold(
+                fold_index=fold_idx,
+                train_indices=tuple(train_candidates),
+                test_indices=test_indices,
+                train_end_date=train_end_dt,
+                test_start_date=test_start_dt,
+                test_end_date=test_end_dt,
+                purged_count=purged_count,
+            )
+        )
+    return folds

edgar_pit_clock-0.1.0.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: edgar-pit-clock
+Version: 0.1.0
+Summary: Zero-dependency point-in-time SEC EDGAR acceptanceDateTime to NYSE trading-session router, One-Document-One-Witness accession normalizer, and Purged Walk-Forward splitter.
+Author-email: Starling Quantitative Research <founder@starlingquant.com>
+License: MIT
+Project-URL: Homepage, https://starlingquant.com
+Project-URL: Repository, https://github.com/starlingquant/edgar-pit-clock
+Project-URL: Documentation, https://starlingquant.com/guides/point-in-time-alternative-data-and-survivorship-free-panels
+Project-URL: Scorecard, https://starlingquant.com/scorecard
+Project-URL: MachineReference, https://starlingquant.com/llms-full.txt
+Keywords: quantitative-finance,sec-edgar,point-in-time,alternative-data,lookahead-bias,walk-forward,market-microstructure
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# `edgar-pit-clock` — Point-in-Time SEC EDGAR Timestamp & Session Router
+
+**Zero-dependency Python utility for eliminating the `4:15 PM` SEC `filingDate` lookahead trap, normalizing `One-Document-One-Witness` EDGAR accession provenance, and enforcing Purged Walk-Forward Cross-Validation embargoes.**
+
+Built and maintained by **[Starling Quantitative Research](https://starlingquant.com)** (*"They Trade the Headlines. We Trade the Fine Print."*).
+
+---
+
+## Why This Exists: The `4:15 PM` Filing Trap
+
+Naive equity backtests align corporate disclosures (`10-K`, `10-Q`, `8-K`, `Form 4`, `Schedule 13D`) by fiscal period-end (`fp`) or calendar `filingDate`. Even `filingDate` leaks a full trading session of lookahead bias whenever a company files after the `16:00:00 ET` closing bell (for example, at `16:15:04 ET`), because a daily close-to-close backtest assumes execution at `16:00:00 ET`—fifteen minutes before the filing hit EDGAR.
+
+`edgar-pit-clock` enforces strict point-in-time filtration using down-to-the-second SEC server `acceptanceDateTime` across the full NYSE holiday calendar:
+
+| Filing `acceptanceDateTime` (`ET`) | `MarketSession` | Intraday Daemon | Daily Batch Replay |
+| :--- | :--- | :--- | :--- |
+| `< 09:30:00 ET` (NYSE Trading Day) | `PRE_MARKET` | Wait for `Open(T_0)` | `Open(T_0)` |
+| `09:30:00 – 15:59:59 ET` | `REGULAR_SESSION` | Live `ArrivalMid` | `Open(T+1)` *(Conservative)* |
+| `>= 16:00:00 ET` | `AFTER_HOURS` | Next Session `Open(T+1)` | `Open(T+1)` |
+| Weekend / NYSE Holiday | `NON_TRADING_DAY` | Next Session `Open(T+1)` | `Open(T+1)` |
+
+---
+
+## Quickstart
+
+```bash
+pip install edgar-pit-clock
+```
+
+```python
+from edgar_pit_clock import (
+    align_filing_to_market_bar,
+    normalize_cik10,
+    normalize_sec_artifact_id,
+    purged_walk_forward_splits,
+)
+
+# 1. Friday 16:15:04 ET Form 8-K -> Routes cleanly to Monday Open (never Friday Close)
+bar = align_filing_to_market_bar("2026-11-13T16:15:04-05:00")
+print(bar.market_session, bar.daily_batch_bar_date, bar.daily_batch_price_field)
+# -> MarketSession.AFTER_HOURS 2026-11-16 OPEN
+
+# 2. One-Document-One-Witness provenance key (prevents multi-parser double-counting)
+doc_id = normalize_sec_artifact_id("0000320193-26-000077")
+cik = normalize_cik10(320193)
+# -> doc_id == "SEC:000032019326000077", cik == "0000320193"
+```
+
+---
+
+## About Starling Quantitative
+
+**[Starling Quantitative](https://starlingquant.com)** is the systematic U.S. equity research and capital allocation desk of Biwada LLC. Starling runs two layers of **100% deterministic, zero-LLM** U.S. equity scouts under a single non-parametric calibration and risk engine:
+
+1. **The Proven Foundation (Point-in-Time Filing Scouts):** Rule-based scouts extracting factor-neutralized alpha from primary SEC, FDA, and patent disclosures across `3,607` survivorship-free Russell 3000 CIKs (`555` delisted retained; `+61.8%` OOS `2022–2026` unlevered vs. `SPY +54.3%`).
+2. **The Experiment Layer (Darwinian Alt-Data Scouts):** A live survival-of-the-fittest ecosystem tracking ephemeral, differentiated alternative data feeds behind a One-Way Shadow/Canary Glass Wall—starting at `$0` in shadow and earning or losing capital automatically on live out-of-sample attribution.
+
+### Open Research Monographs & Verification
+- **Research Note RN-01:** [Point-in-Time Alternative Data Ingestion, Entity Resolution & Survivorship-Free Panel Construction](https://starlingquant.com/guides/point-in-time-alternative-data-and-survivorship-free-panels) ([PDF](https://starlingquant.com/papers/RN-01-Point-in-Time-Alternative-Data-Starling-Quantitative.pdf) | [DOI: 10.5281/zenodo.24222468](https://doi.org/10.5281/zenodo.24222468))
+- **Research Note RN-02:** [Non-Parametric Signal Calibration, Orthogonal Pillar Pooling & One-Way Statutory Distress Vetoes](https://starlingquant.com/guides/non-parametric-signal-calibration-and-orthogonal-pillar-pooling) ([PDF](https://starlingquant.com/papers/RN-02-Non-Parametric-Signal-Calibration-Starling-Quantitative.pdf) | [DOI: 10.5281/zenodo.24222814](https://doi.org/10.5281/zenodo.24222814))
+- **Research Note RN-03:** [Six-Factor Residual Attribution, Purged Walk-Forward Validation & Volatility-Parity Risk Governance](https://starlingquant.com/guides/multi-agent-quorum-and-systematic-factor-consensus) ([PDF](https://starlingquant.com/papers/RN-03-Six-Factor-Residual-Attribution-Starling-Quantitative.pdf) | [DOI: 10.5281/zenodo.24222816](https://doi.org/10.5281/zenodo.24222816))
+- **Live Forward Attribution Scorecard:** [https://starlingquant.com/scorecard](https://starlingquant.com/scorecard)
+- **Machine-Readable Specification:** [https://starlingquant.com/llms-full.txt](https://starlingquant.com/llms-full.txt)
+
+*Disclosure: Starling Quantitative trades proprietary capital and conducts selective institutional research evaluation under mutual NDA. Nothing in this repository constitutes investment advice or an offer to solicit retail capital.*

edgar_pit_clock-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+edgar_pit_clock/__init__.py,sha256=30hsmvCy77g2qA8K5ZaxsJAYANDe5eEgXQA9ymgKaYQ,893
+edgar_pit_clock/clock.py,sha256=xdquce6Q_iUfKbH5vYeI9IjATryaGif0cWTI26fSrak,11434
+edgar_pit_clock-0.1.0.dist-info/licenses/LICENSE,sha256=g3KY7aTLbD3pNwrcc0izG5PFfATNZk5yHG9SOXQaGVI,1121
+edgar_pit_clock-0.1.0.dist-info/METADATA,sha256=JJN5RtHixAFTwVJjZP5BvCEc_AbSQSPUu84bSV5Vm9Q,6480
+edgar_pit_clock-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+edgar_pit_clock-0.1.0.dist-info/top_level.txt,sha256=r4N9zIEGRUhOADG5Uh5mcVNsCvLoIdzCuqTn3T0YBqc,16
+edgar_pit_clock-0.1.0.dist-info/RECORD,,

edgar_pit_clock-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

edgar_pit_clock-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Biwada LLC (Starling Quantitative — https://starlingquant.com)
+
+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.

edgar_pit_clock-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+edgar_pit_clock