diff --git a/AGENTS_MANUAL_CHECKS.md b/AGENTS_MANUAL_CHECKS.md
deleted file mode 100644
index 10fa462..0000000
--- a/AGENTS_MANUAL_CHECKS.md
+++ /dev/null
@@ -1,61 +0,0 @@
-# Agent Instructions: python-package-template (Token-Efficient)
-
-## Quick Start
-1. **Setup:** Run `uv sync --dev` before major work sessions
-2. **Activate:** Ensure `.venv` is active; run `uv venv` if missing
-3. **Code:** Use `python3` or `uv run python`; always add type hints and tests
-
-## Tech Stack
-| Component | Tool |
-|-----------|------|
-| Environment & Dependencies | uv |
-| Data Validation | Pydantic |
-| CLI Framework | Typer |
-| Testing | pytest |
-| Linting & Formatting | ruff |
-| Type Checking | mypy |
-
-## Project Structure
-```
-python_package_template/
-  ├── config.py          (Pydantic models)
-  ├── hello.py           (Business logic)
-  └── cli.py             (Typer CLI)
-tests/                   (Pytest suite)
-pyproject.toml           (Dependencies & tool config)
-```
-
-## Essential Directives
-
-### Code Standards
-- **Type Hints:** Required on ALL function signatures and class members. Write code that will pass mypy.
-- **Docstrings:** Google-style format for all public APIs.
-- **Logging:** Use `logging` module only; never `print()`.
-- **Relative Paths:** Never use absolute paths in code.
-
-### Dependency & Configuration Management
-- **Adding/Removing Dependencies:** Use `uv add` / `uv remove` commands.
-- **Editing pyproject.toml:** Avoid manual edits during development. Only update `pyproject.toml` as the **final change** after all work is tested and finalized.
-- **Before Major Work:** Always run `uv sync --dev` first.
-
-### Testing & Quality
-- **Test Coverage:** Every code change requires corresponding tests in `tests/`.
-- **Manual Validation:** After development is complete, **you will manually run** the full validation suite for final checks.
-
-### Operational Constraints
-- **No Interactive Prompts:** Mock or bypass any interactive commands.
-- **No Git Operations:** Don't stage/commit unless explicitly requested.
-- **Code Review Mode:** Analyze only; record findings in `./REVIEW.md` without making modifications. At the top of the review, identify the reviewer including the name of the IDE/CLI used and the primary model that performed the review.
-
-### File Maintenance
-- **Keep Instructions Current:** Update "Tech Stack," "Project Structure," and "Workflow Commands" if `pyproject.toml`, structure, or core logic changes.
-
-## Workflow Commands (Run Manually)
-```bash
-uv sync --dev                           # Install/sync all dependencies
-uv run pytest                           # Run tests (USER RUNS)
-uv run ruff check .                     # Lint (USER RUNS)
-uv run ruff format .                    # Auto-format (USER RUNS)
-uv run mypy .                           # Type check (USER RUNS)
-uv run hello-world hello  # Test CLI
-```
\ No newline at end of file
diff --git a/README.md b/README.md
index 119fea2..97fc57b 100644
--- a/README.md
+++ b/README.md
@@ -1,19 +1,23 @@
-# python-package-template
+# timetracker-utils
 
-A basic template package demonstrating Python packaging best practices using **uv**, **pydantic**, and **pytest**.
+This repository, CLI, and all associated materials are provided on an **"as is" basis only**. We make no warranties or representations, express or implied, as to the accuracy, completeness, or fitness for a particular purpose of any content. At no point does the developer have any duty to correct, update, or support the provided material. **Use at your own risk.**
+
+Time tracker utilities for parsing, validating, and persisting CSV time tracking data. Built with **Pydantic**, **pandas**, **Typer**, and **SQLite**.
 
 ## Overview
 
-This is a minimal but well-structured Python package that serves as a template for building larger projects. It demonstrates:
+This package processes CSV time tracking exports (in the TimeCop format), validates each entry using Pydantic models, and persists the data to a SQLite database with intelligent merge semantics. It supports timezone-aware datetime handling, conflict detection, and round-trip export back to CSV.
 
-- Modern Python packaging with `pyproject.toml`
-- Type hints and static type checking with **mypy**
-- Data validation using **pydantic**
-- Code linting with **ruff**
-- Testing with **pytest**
-- Dependency management with **uv**
+## Features
 
-This package is intentionally simple to provide a clean starting point for your own projects.
+- **CSV parsing & validation**: Read and validate TimeCop-format CSV files with Pydantic
+- **Smart merge semantics**: Import CSV data into a SQLite database with three merge rules:
+  1. **Duplicate drop**: Identical rows are silently skipped
+  2. **Blank-fill**: Missing fields (date, notes) are filled in from later imports
+  3. **Conflict detection**: Non-blank conflicting values raise a `MergeConflictError`
+- **Timezone conversion**: Display timestamps in any IANA or abbreviation timezone (ET, PT, UTC, etc.)
+- **Round-trip CSV export**: Export the entire database back to TimeCop-format CSV
+- **CLI interface**: Full-featured command-line interface via Typer
 
 ## Installation
 
@@ -24,176 +28,155 @@ This package is intentionally simple to provide a clean starting point for your
 
 ### Setup
 
-**Option 1: Use this template (recommended)**
-
-Visit https://github.com/AlexAndrewsAI/python-package-template and click the green "Use this template" button to create your own repository. Then clone your new repository:
-
-```bash
-cd your-repo-name
-uv sync
-```
-
-**Option 2: Clone directly**
-
 ```bash
-git clone https://github.com/AlexAndrewsAI/python-package-template.git
-cd python-package-template  
-uv sync
-```
-
-To install the package in editable mode (recommended for development) and test the CLI:
-
-```bash
-uv pip install -e .
-hello-world --version
+git clone https://github.com/AlexAndrewsAI/timetracker-utils.git
+cd timetracker-utils
+uv sync --dev
 ```
 
 ## Usage
 
-### Basic Example
-
-```python
-from python_package_template.hello import HelloWorld
-from python_package_template.config import Config
-
-# Create with default name
-hello = HelloWorld()
-greeting = hello.greet() # Hello, World!
-
-# Create with custom name
-hello = HelloWorld(Config(name="Alice"))
-personal_greeting = hello.greet() # Hello, Alice!
-```
-
 ### Configuration
 
-The `Config` class uses **pydantic** for validation:
-
-```python
-from python_package_template.config import Config
-
-# Create with default name
-config = Config()
+Create a YAML configuration file pointing to your SQLite database:
 
-# Create with custom name
-config = Config(name="Alice")
+```yaml
+database: /path/to/data/timetracker/db.sqlite3
+timezone: ET
+max_conflict_display: 100
 ```
 
-### Command Line Interface
+### CLI
 
-The package includes a CLI tool built with **typer**:
+The package provides a `timetracker` CLI with a single command `timecop`:
 
 ```bash
 # Show version
-uv run hello-world --version
+uv run timetracker --version
 
-# Run the CLI with default name
-uv run hello-world hello
+# Import a CSV file and display entries
+uv run timetracker timecop --config config.yml --input timecop_export.csv
 
-# Greet a specific name
-uv run hello-world hello --name Alice
+# Export the database back to CSV
+uv run timetracker timecop --config config.yml --output timecop_export.csv
 
-# Show help
-uv run hello-world hello --help
-```
+# Both import and export in one command
+uv run timetracker timecop --config config.yml --input input.csv --output output.csv
 
-## Development
+# Control how many rows to display
+uv run timetracker timecop --config config.yml --input input.csv --head 10
+```
 
-### Install Dev Dependencies
+### Python API
 
-```bash
-uv sync --dev
+```python
+from timetracker_utils import TimeCop, TimeEntry
+
+# Parse a CSV string
+cop = TimeCop()
+csv_data = '''\
+"Date","Project","Description","Combined Project & Description","Start Time","End Time","Time (hours)","Notes"
+"4/13/2026","Research","literature review","Research: literature review","2026-04-13T09:00:00.000Z","2026-04-13T11:30:00.000Z","2.5",""
+'''
+df = cop.read_csv_string(csv_data)
+print(f"Loaded {len(df)} entries")
+print(f"Total hours: {cop.total_hours()}")
+print(f"Hours by project: {cop.total_hours_by_project()}")
 ```
 
-This installs all dependencies and dev tools (pytest, ruff, mypy).
+```python
+from timetracker_utils.database import Database
 
-### Run Tests
+db = Database()
 
-```bash
-# Run all tests
-uv run pytest
+# Write entries to a SQLite database (with merge semantics)
+db.write(df, "/path/to/db.sqlite3")
 
-# Run specific test
-uv run pytest tests/test_hello.py::test_default_name
+# Read all entries back
+entries = db.read("/path/to/db.sqlite3")
+print(f"Database has {len(entries)} entries")
 ```
 
-### Code Quality
-
-```bash
-# Lint code
-uv run ruff check
-uv run ruff format
+```python
+from timetracker_utils.datetime_utils import convert_column_tz
 
-# Type check
-uv run mypy .
+# Convert timestamps to a specific timezone
+converted = convert_column_tz(df["start_time"], "America/New_York")
 ```
 
 ## Project Structure
 
-- generate using `git ls-tree -r --name-only HEAD | tree --fromfile`
 ```
-python-package-template/
+timetracker-utils/
 ├── AGENTS.md
-├── .gitignore
 ├── pyproject.toml
-├── python_package_template
-│   ├── cli.py
-│   ├── config.py
-│   ├── hello.py
-│   └── __init__.py
 ├── README.md
-├── tests
+├── timetracker_utils/
+│   ├── __init__.py         # Package entry point, version
+│   ├── __main__.py         # python -m entry point
+│   ├── cli.py              # Typer CLI interface
+│   ├── config.py           # Pydantic config model (YAML-backed)
+│   ├── database.py         # SQLite persistence with merge logic
+│   ├── datetime_utils.py   # Timezone conversion utilities
+│   └── time_cop.py         # CSV parsing & Pydantic validation
+├── tests/
 │   ├── __init__.py
-│   └── test_hello.py
+│   ├── test_cli.py
+│   ├── test_config.py
+│   ├── test_database.py
+│   ├── test_datetime_utils.py
+│   └── test_time_cop.py
 └── uv.lock
 ```
 
+## Development
 
+### Install Dev Dependencies
 
-## Agent Instructions
-
-This template includes two agent instruction files for different workflows:
-
-### AGENTS.md
-Complete instructions for an AI agent with full automation. The agent automatically runs `pytest`, `ruff check`, and `mypy` after code changes to validate quality before handoff.
+```bash
+uv sync --dev
+```
 
-**Best for:** Fully autonomous workflows where the agent handles all validation.
+### Run Tests
 
-### AGENTS_MANUAL_CHECKS.md
-Streamlined instructions that skip automated validation tools to reduce token usage. The agent writes code with quality standards in mind, but you manually run `pytest`, `ruff check`, and `mypy` for final validation.
+```bash
+# Run all tests with coverage
+uv run pytest
 
-**Best for:** Cost-conscious workflows or when you prefer manual control over validation timing.
+# Run specific test file
+uv run pytest tests/test_time_cop.py
+```
 
-Both files enforce the same code standards and project structure—only the automation scope differs.
+### Code Quality
 
+```bash
+# Lint
+uv run ruff check .
 
-## Features
+# Auto-format
+uv run ruff format .
 
-- **Type hints**: Full type annotations for better IDE support and mypy compatibility
-- **Pydantic validation**: Runtime type validation and serialization
-- **Configuration**: Externalize settings using the `Config` class
-- **Testing**: Comprehensive test suite with pytest
-- **Code quality**: Automated linting with ruff and type checking with mypy
+# Type check
+uv run mypy .
+```
 
-## Python Best Practices Used
+## Technology Stack
 
-- ✅ **Type hints**: All functions and classes use type annotations
-- ✅ **Docstrings**: Clear descriptions of modules, classes, and functions
-- ✅ **Project structure**: Proper package layout with separation of concerns
-- ✅ **Testing**: Comprehensive test coverage with pytest
-- ✅ **Configuration**: Externalized config using pydantic BaseModel
-- ✅ **Linting**: Code quality checks with ruff
-- ✅ **Dependency management**: Explicit dependencies in pyproject.toml
-- ✅ **Python versions**: Supports Python 3.10+
+| Component         | Tool          |
+|-------------------|---------------|
+| Environment       | uv            |
+| Data Validation   | Pydantic      |
+| CLI               | Typer         |
+| Data Processing   | pandas        |
+| Database          | SQLite        |
+| Testing           | pytest        |
+| Linting           | ruff          |
+| Type Checking     | mypy          |
 
 ## License
 
 MIT
 
-## Contributing
-
-This is a template repository. Feel free to use it as a starting point for your own projects.
-
 ## Author
 
-AlexAndrewsAI <alex.andrews.ai@protonmail.com>
\ No newline at end of file
+AlexAndrewsAI <alex.andrews.ai@protonmail.com>
diff --git a/pyproject.toml b/pyproject.toml
index 15ac107..5812280 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,14 +1,14 @@
 [project]
-name = "python-package-template"
+name = "timetracker-utils"
 dynamic = ["version"]  # Version is read from __init__.py by hatch
-description = "A simple package using pydantic"
+description = "Time tracker utilities with CSV parsing and validation via Pydantic"
 readme = "README.md"
 requires-python = ">=3.10"
 license = "MIT"
 authors = [
     {name = "AlexAndrewsAI", email = "alex.andrews.ai@protonmail.com"}
 ]
-keywords = ["hello", "world"]
+keywords = ["time", "tracking", "csv", "pydantic"]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Intended Audience :: Developers",
@@ -21,7 +21,9 @@ classifiers = [
 ]
 
 dependencies = [
+    "pandas>=2.3.3",
     "pydantic>=2.0",
+    "pyyaml>=6.0.3",
     "typer>=0.12.0",
 ]
 
@@ -31,24 +33,28 @@ dev = [
     "ruff",
     "mypy",
     "pytest-cov>=7.1.0",
+    "pandas-stubs>=2.3.3.260113",
+    "uv>=0.11.21",
+    "types-pyyaml>=6.0.12.20260518",
 ]
 
 [project.scripts]
-hello-world = "python_package_template.cli:app"
+timetracker = "timetracker_utils.cli:app"
 
 [project.urls]
-Homepage = "https://github.com/AlexAndrewsAI/python-package-template"
-Repository = "https://github.com/AlexAndrewsAI/python-package-template.git"
-Documentation = "https://github.com/AlexAndrewsAI/python-package-template#readme"
+Homepage = "https://github.com/AlexAndrewsAI/timetracker-utils"
+Repository = "https://github.com/AlexAndrewsAI/timetracker-utils.git"
+Documentation = "https://github.com/AlexAndrewsAI/timetracker-utils#readme"
 
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [tool.hatch.version]  # Configures hatch to read version from __init__.py
-path = "python_package_template/__init__.py"
+path = "timetracker_utils/__init__.py"
 
-[tool.uv]
+[tool.hatch.build.targets.wheel]
+packages = ["timetracker_utils"]
 
 [tool.ruff]
 line-length = 88
@@ -74,6 +80,7 @@ ignore = ["D203", "D213"]  # Ignore conflicting docstring style rules (one-blank
 
 [tool.ruff.lint.per-file-ignores]
 "tests/**" = ["S101"]  # Allow assert statements in tests
+"timetracker_utils/cli.py" = ["B008"]  # Typer uses function calls in defaults
 
 
 [tool.mypy]
@@ -81,13 +88,19 @@ python_version = "3.10"
 warn_return_any = true  # Warn when returning Any from a function
 warn_unused_configs = true  # Warn about unused mypy configuration
 disallow_untyped_defs = true  # Require type hints on all function definitions
+plugins = ["pydantic.mypy"]
+
+[tool.pydantic-mypy]
+init_forbid_extra = false
+init_typed = true
+warn_required_dynamic_aliases = true
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
-addopts = "--cov=python_package_template --cov-report=term-missing --cov-fail-under=80"
+addopts = "--cov=timetracker_utils --cov-report=term-missing --cov-fail-under=80"
 
 [tool.coverage.run]
-source = ["python_package_template"]
+source = ["timetracker_utils"]
 omit = []
 parallel = true
 
diff --git a/python_package_template/__init__.py b/python_package_template/__init__.py
deleted file mode 100644
index f5051a7..0000000
--- a/python_package_template/__init__.py
+++ /dev/null
@@ -1,11 +0,0 @@
-"""Python package template.
-
-A simple template for creating Python packages with configuration management
-and a hello world example.
-"""
-
-from python_package_template.config import Config
-from python_package_template.hello import HelloWorld
-
-__version__ = "0.1.1"
-__all__ = ["Config", "HelloWorld"]
diff --git a/python_package_template/__main__.py b/python_package_template/__main__.py
deleted file mode 100644
index 2025e68..0000000
--- a/python_package_template/__main__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-"""Main entry point for python -m python_package_template."""
-
-from python_package_template.cli import app
-
-if __name__ == "__main__":
-    app()
diff --git a/python_package_template/cli.py b/python_package_template/cli.py
deleted file mode 100644
index 4da8f1f..0000000
--- a/python_package_template/cli.py
+++ /dev/null
@@ -1,56 +0,0 @@
-"""Command line interface module.
-
-Provides a typer-based CLI for the package.
-"""
-
-import typer
-
-from python_package_template import __version__
-from python_package_template.config import Config
-from python_package_template.hello import HelloWorld
-
-app = typer.Typer(help="Python package template CLI")
-
-
-def version_callback(value: bool) -> None:
-    """Handle the version flag callback."""
-    if value:
-        typer.echo(f"python-package-template version: {__version__}")
-        raise typer.Exit()
-
-
-@app.callback()
-def main(
-    version: bool | None = typer.Option(
-        None,
-        "--version",
-        "-V",
-        callback=version_callback,
-        is_eager=True,
-        help="Show the version and exit.",
-    ),
-) -> None:
-    """Python package template CLI."""
-    ...
-
-
-@app.command()
-def hello(
-    name: str = typer.Option(
-        "World", "--name", "-n", help="Name to greet (default: World)"
-    ),
-) -> None:
-    """Greet the specified name.
-
-    Args:
-        name: The name to greet.
-
-    """
-    config = Config(name=name)
-    hello_world = HelloWorld(config)
-    greeting = hello_world.greet()
-    typer.echo(greeting)
-
-
-if __name__ == "__main__":
-    app()
diff --git a/python_package_template/config.py b/python_package_template/config.py
deleted file mode 100644
index 44ff832..0000000
--- a/python_package_template/config.py
+++ /dev/null
@@ -1,19 +0,0 @@
-"""Configuration module.
-
-Provides configuration management using Pydantic models.
-"""
-
-from pydantic import BaseModel, Field
-
-
-class Config(BaseModel):
-    """Configuration for the HelloWorld class.
-
-    Attributes:
-        name: The name to greet. Defaults to "World".
-
-    """
-
-    name: str = Field(default="World", min_length=1, description="The name to greet")
-
-    model_config = {"title": "Hello World Config", "frozen": True}
diff --git a/python_package_template/hello.py b/python_package_template/hello.py
deleted file mode 100644
index 0cc67e5..0000000
--- a/python_package_template/hello.py
+++ /dev/null
@@ -1,39 +0,0 @@
-"""Hello world module.
-
-Provides a simple greeting class that uses configuration.
-"""
-
-import logging
-
-from python_package_template.config import Config
-
-logger = logging.getLogger(__name__)
-
-
-class HelloWorld:
-    """A simple greeting class.
-
-    Greets a name specified in the configuration.
-    """
-
-    def __init__(self, config: Config | None = None) -> None:
-        """Initialize the HelloWorld instance.
-
-        Args:
-            config: Optional configuration object. If not provided,
-                   a default Config instance will be created.
-
-        """
-        if config is None:
-            config = Config()
-        self.config = config
-
-    def greet(self) -> str:
-        """Generate a greeting message.
-
-        Returns:
-            A greeting string with the configured name.
-
-        """
-        logger.info("hello %s", self.config.name)
-        return f"Hello, {self.config.name}!"
diff --git a/tests/example.csv b/tests/example.csv
new file mode 100644
index 0000000..f611ba4
--- /dev/null
+++ b/tests/example.csv
@@ -0,0 +1,13 @@
+Date,Project,Description,Combined Project & Description,Start Time,End Time,Time (hours),Notes
+1/15/2200,StellarCartography,nebula mapping,StellarCartography: nebula mapping,2200-01-15T09:00:00.000Z,2200-01-15T11:30:00.000Z,2.5,
+1/15/2200,Hydroponics,crop harvest,Hydroponics: crop harvest,2200-01-15T13:00:00.000Z,2200-01-15T14:45:00.000Z,1.75,
+1/15/2200,StellarCartography,,StellarCartography: ,2200-01-15T21:00:00.000Z,2200-01-15T22:30:00.000Z,1.5,
+1/16/2200,CrewFitness,strength training,CrewFitness: strength training,2200-01-16T06:00:00.000Z,2200-01-16T07:00:00.000Z,1,
+1/16/2200,Hydroponics,nutrient mix,Hydroponics: nutrient mix,2200-01-16T10:15:00.000Z,2200-01-16T11:45:00.000Z,1.5,
+1/16/2200,StellarCartography,course plotting,StellarCartography: course plotting,2200-01-16T20:30:00.000Z,2200-01-16T22:15:00.000Z,1.75,
+1/17/2200,WarpDrive,plasma calibration,WarpDrive: plasma calibration,2200-01-17T08:00:00.000Z,2200-01-17T12:30:00.000Z,4.5,critical test
+1/17/2200,Hydroponics,pH adjustment,Hydroponics: pH adjustment,2200-01-17T14:00:00.000Z,2200-01-17T15:30:00.000Z,1.5,
+1/17/2200,CrewFitness,cardiovascular,CrewFitness: cardiovascular,2200-01-17T17:00:00.000Z,2200-01-17T18:30:00.000Z,1.5,
+1/20/2200,WarpDrive,coil winding,WarpDrive: coil winding,2200-01-20T09:30:00.000Z,2200-01-20T13:30:00.000Z,4,
+1/20/2200,StellarCartography,asteroid tracking,StellarCartography: asteroid tracking,2200-01-20T15:00:00.000Z,2200-01-20T16:45:00.000Z,1.75,
+1/20/2200,CrewFitness,yoga session,CrewFitness: yoga session,2200-01-20T19:00:00.000Z,2200-01-20T20:00:00.000Z,1,test
diff --git a/tests/test_cli.py b/tests/test_cli.py
new file mode 100644
index 0000000..0340f40
--- /dev/null
+++ b/tests/test_cli.py
@@ -0,0 +1,365 @@
+"""Tests for the CLI module."""
+
+# ruff: noqa: E501 - CSV data lines exceed line length limit
+
+from pathlib import Path
+
+import pytest
+import yaml
+from typer.testing import CliRunner
+
+from timetracker_utils import __version__
+from timetracker_utils.cli import app
+
+runner = CliRunner()
+
+SAMPLE_CSV = """\
+"Date","Project","Description","Combined Project & Description","Start Time","End Time","Time (hours)","Notes"
+"1/15/2200","StellarCartography","nebula mapping","StellarCartography: nebula mapping","2200-01-15T09:00:00.000Z","2200-01-15T11:30:00.000Z","2.5",""
+"""
+
+
+def _write_config(tmp_path: Path, timezone: str = "ET") -> Path:
+    """Write a temporary config YAML file and return its path."""
+    config_path = tmp_path / "timetracker.yml"
+    db_path = tmp_path / "data" / "timetracker" / "db.sqlite3"
+    config_path.write_text(
+        yaml.dump({"database": str(db_path), "timezone": timezone}),
+        encoding="utf-8",
+    )
+    return config_path
+
+
+def test_cli_version() -> None:
+    """Test that --version flag prints the version and exits."""
+    result = runner.invoke(app, ["--version"])
+    assert result.exit_code == 0
+    assert __version__ in result.stdout
+
+
+def test_cli_help() -> None:
+    """Test that --help flag prints help text."""
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "Time tracker utilities CLI" in result.stdout
+
+
+def test_cli_no_args_exits_with_error() -> None:
+    """Test that running with no arguments exits with code 2 (missing command)."""
+    result = runner.invoke(app, [])
+    assert result.exit_code == 2
+    assert "Missing command" in result.stderr
+
+
+def test_cli_callback_run_directly() -> None:
+    """Test the main callback body directly to cover _ = TimeCop."""
+    # main() is a Typer callback that expects options through Typer's context,
+    # so we invoke it via the app with --help to reach the callback body
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+
+
+def test_cli_main_body() -> None:
+    """Test the main callback body covers _ = TimeCop line."""
+    from timetracker_utils.cli import main
+
+    # main() with no arguments runs the callback body (hits _ = TimeCop line)
+    main()
+
+
+def test_main_module_importable() -> None:
+    """Test that the __main__ module can be imported."""
+    import timetracker_utils.__main__
+
+    assert timetracker_utils.__main__ is not None
+
+
+def test_version_callback() -> None:
+    """Test the version_callback function directly."""
+    from click.exceptions import Exit as ClickExit
+
+    from timetracker_utils.cli import version_callback
+
+    with pytest.raises(ClickExit) as exc_info:
+        version_callback(True)
+    # click.exceptions.Exit has exit_code, not code
+    assert exc_info.value.exit_code == 0
+
+    # Should do nothing when value is False
+    version_callback(False)
+
+
+def test_timecop_command(tmp_path: Path) -> None:
+    """Test the timecop CLI command loads a CSV and prints the DataFrame."""
+    csv_path = tmp_path / "test.csv"
+    csv_path.write_text(SAMPLE_CSV, encoding="utf-8")
+    config_path = _write_config(tmp_path, timezone="ET")
+    result = runner.invoke(
+        app, ["timecop", "--config", str(config_path), "--input", str(csv_path)]
+    )
+    assert result.exit_code == 0
+    assert "Loaded DataFrame" in result.output
+    assert "StellarCartography" in result.output
+
+
+def test_timecop_command_head(tmp_path: Path) -> None:
+    """Test the timecop CLI command with --head option."""
+    csv_path = tmp_path / "test.csv"
+    csv_path.write_text(SAMPLE_CSV, encoding="utf-8")
+    config_path = _write_config(tmp_path, timezone="ET")
+    result = runner.invoke(
+        app,
+        [
+            "timecop",
+            "--config",
+            str(config_path),
+            "--input",
+            str(csv_path),
+            "--head",
+            "1",
+        ],
+    )
+    assert result.exit_code == 0
+    assert "Loaded DataFrame" in result.output
+
+
+def test_timecop_command_missing_config() -> None:
+    """Test that the timecop CLI command fails without required --config."""
+    result = runner.invoke(app, ["timecop"])
+    assert result.exit_code != 0
+    assert "Missing option" in result.stderr or "required" in result.stderr.lower()
+
+
+def test_timecop_command_no_input_or_output_exits_with_error(tmp_path: Path) -> None:
+    """Test that the timecop CLI command fails without --input or --output."""
+    config_path = _write_config(tmp_path, timezone="ET")
+    result = runner.invoke(app, ["timecop", "--config", str(config_path)])
+    assert result.exit_code == 1
+    assert "input" in result.output or "output" in result.output
+
+
+def test_timecop_command_timezone_from_config(tmp_path: Path) -> None:
+    """Test that timezone from config converts timestamps in the DataFrame."""
+    csv_path = tmp_path / "test.csv"
+    csv_path.write_text(SAMPLE_CSV, encoding="utf-8")
+    config_path = _write_config(tmp_path, timezone="ET")
+    result = runner.invoke(
+        app, ["timecop", "--config", str(config_path), "--input", str(csv_path)]
+    )
+    assert result.exit_code == 0
+    assert "Loaded DataFrame" in result.output
+    assert "StellarCartography" in result.output
+    # UTC-4 means 09:00Z becomes 05:00 ET
+    assert "05:00" in result.output
+
+
+def test_timecop_command_different_timezone(tmp_path: Path) -> None:
+    """Test that a different timezone from config works correctly."""
+    csv_path = tmp_path / "test.csv"
+    csv_path.write_text(SAMPLE_CSV, encoding="utf-8")
+    config_path = _write_config(tmp_path, timezone="PT")
+    result = runner.invoke(
+        app, ["timecop", "--config", str(config_path), "--input", str(csv_path)]
+    )
+    assert result.exit_code == 0
+    assert "Loaded DataFrame" in result.output
+    # January 2200 is winter: PT is UTC-8, so 09:00Z becomes 01:00 PT
+    assert "01:00" in result.output
+
+
+def test_timecop_output_empty_db(tmp_path: Path) -> None:
+    """Test --output with an empty database writes header-only CSV."""
+    config_path = _write_config(tmp_path, timezone="ET")
+    output_path = tmp_path / "output.csv"
+    result = runner.invoke(
+        app, ["timecop", "--config", str(config_path), "--output", str(output_path)]
+    )
+    assert result.exit_code == 0
+    assert "Database is empty" in result.output
+    assert output_path.exists()
+    content = output_path.read_text(encoding="utf-8")
+    assert "Date" in content
+    assert "Project" in content
+    assert "Start Time" in content
+    # No data rows should exist beyond the header
+    assert content.strip().count("\n") == 0  # Only header row
+
+
+def test_timecop_output_with_data(tmp_path: Path) -> None:
+    """Test --output exports a previously imported database to CSV."""
+    csv_path = tmp_path / "input.csv"
+    csv_path.write_text(SAMPLE_CSV, encoding="utf-8")
+    config_path = _write_config(tmp_path, timezone="ET")
+    # First, import the CSV to populate the database
+    result = runner.invoke(
+        app, ["timecop", "--config", str(config_path), "--input", str(csv_path)]
+    )
+    assert result.exit_code == 0
+    # Now export to output CSV
+    output_path = tmp_path / "output.csv"
+    result = runner.invoke(
+        app, ["timecop", "--config", str(config_path), "--output", str(output_path)]
+    )
+    assert result.exit_code == 0
+    assert output_path.exists()
+    content = output_path.read_text(encoding="utf-8")
+    # Check header
+    assert "Date" in content
+    assert "Project" in content
+    assert "Combined Project & Description" in content
+    assert "Start Time" in content
+    assert "End Time" in content
+    assert "Time (hours)" in content
+    # Check data row content
+    assert "StellarCartography" in content
+    assert "nebula mapping" in content
+    assert "StellarCartography: nebula mapping" in content
+    assert "2200-01-15T09:00:00.000Z" in content or "2200-01-15T09:00:00" in content
+    assert "2200-01-15T11:30:00.000Z" in content or "2200-01-15T11:30:00" in content
+    assert "2.5000" in content
+
+
+def test_timecop_output_combined_with_input(tmp_path: Path) -> None:
+    """Test using --output together with --input."""
+    csv_path = tmp_path / "input.csv"
+    csv_path.write_text(SAMPLE_CSV, encoding="utf-8")
+    config_path = _write_config(tmp_path, timezone="ET")
+    output_path = tmp_path / "output.csv"
+    result = runner.invoke(
+        app,
+        [
+            "timecop",
+            "--config",
+            str(config_path),
+            "--input",
+            str(csv_path),
+            "--output",
+            str(output_path),
+        ],
+    )
+    assert result.exit_code == 0
+    assert "Loaded DataFrame" in result.output
+    assert "Exporting" in result.output
+    assert output_path.exists()
+    content = output_path.read_text(encoding="utf-8")
+    assert "StellarCartography" in content
+
+
+def test_timecop_output_non_existent_db(tmp_path: Path) -> None:
+    """Test --output when the database file does not exist yet."""
+    config_path = _write_config(tmp_path, timezone="ET")
+    output_path = tmp_path / "output.csv"
+    result = runner.invoke(
+        app, ["timecop", "--config", str(config_path), "--output", str(output_path)]
+    )
+    assert result.exit_code == 0
+    assert "Database is empty" in result.output
+    assert output_path.exists()
+
+
+def test_format_datetime_iso() -> None:
+    """Test _format_datetime_iso helper function."""
+    from datetime import datetime, timedelta, timezone
+
+    from timetracker_utils.cli import _format_datetime_iso
+
+    # None input
+    assert _format_datetime_iso(None) == ""
+    # Empty string
+    assert _format_datetime_iso("") == ""
+    # Datetime object
+    dt = datetime(2200, 1, 15, 9, 0, 0, tzinfo=timezone.utc)
+    result = _format_datetime_iso(dt)
+    assert result == "2200-01-15T09:00:00.000Z"
+    # ISO string
+    result = _format_datetime_iso("2200-01-15T09:00:00.000Z")
+    assert result == "2200-01-15T09:00:00.000Z"
+    # Non-UTC timezone
+    dt_est = datetime(2200, 1, 15, 5, 0, 0, tzinfo=timezone(timedelta(hours=-5)))
+    result = _format_datetime_iso(dt_est)
+    assert result == "2200-01-15T10:00:00.000Z"
+
+
+def test_format_datetime_iso_unparseable_string() -> None:
+    """Test _format_datetime_iso with an unparseable string (hits except branch)."""
+    from timetracker_utils.cli import _format_datetime_iso
+
+    # Unparseable string should return as-is
+    result = _format_datetime_iso("not-a-date")
+    assert result == "not-a-date"
+
+
+def test_format_datetime_iso_naive_datetime() -> None:
+    """Test _format_datetime_iso with a naive datetime (hits tzinfo is None branch)."""
+    from datetime import datetime
+
+    from timetracker_utils.cli import _format_datetime_iso
+
+    dt = datetime(2200, 1, 15, 9, 0, 0)  # No tzinfo
+    result = _format_datetime_iso(dt)
+    # Should be treated as UTC
+    assert result == "2200-01-15T09:00:00.000Z"
+
+
+def test_format_datetime_iso_non_datetime_type() -> None:
+    """Test _format_datetime_iso with a non-datetime, non-string type (hits else branch)."""
+    from timetracker_utils.cli import _format_datetime_iso
+
+    # Integer input hits the else: return str(val) branch
+    result = _format_datetime_iso(42)
+    assert result == "42"
+
+
+def test_compute_hours() -> None:
+    """Test _compute_hours helper function."""
+    from timetracker_utils.cli import _compute_hours
+
+    # None values
+    assert _compute_hours(None, None) == ""
+    assert _compute_hours("2020-01-01T00:00:00Z", None) == ""
+    # Valid times
+    result = _compute_hours("2200-01-15T09:00:00.000Z", "2200-01-15T11:30:00.000Z")
+    assert result == "2.5000"
+    # Rounding
+    result = _compute_hours("2200-01-15T09:00:00.000Z", "2200-01-15T12:00:00.000Z")
+    assert result == "3.0000"
+
+
+def test_compute_hours_empty_string() -> None:
+    """Test _compute_hours with empty string start/end times."""
+    from timetracker_utils.cli import _compute_hours
+
+    # Empty start time
+    assert _compute_hours("", "2200-01-15T11:30:00.000Z") == ""
+    # Empty end time
+    assert _compute_hours("2200-01-15T09:00:00.000Z", "") == ""
+
+
+def test_compute_hours_datetime_objects() -> None:
+    """Test _compute_hours with datetime objects (hits isinstance(datetime) branch)."""
+    from datetime import datetime, timezone
+
+    from timetracker_utils.cli import _compute_hours
+
+    start = datetime(2200, 1, 15, 9, 0, 0, tzinfo=timezone.utc)
+    end = datetime(2200, 1, 15, 11, 30, 0, tzinfo=timezone.utc)
+    result = _compute_hours(start, end)
+    assert result == "2.5000"
+
+
+def test_compute_hours_invalid_string() -> None:
+    """Test _compute_hours with invalid time string (hits except branch)."""
+    from timetracker_utils.cli import _compute_hours
+
+    # Invalid string should be caught by ValueError from fromisoformat
+    result = _compute_hours("not-a-date", "2200-01-15T11:30:00.000Z")
+    assert result == ""
+
+
+def test_compute_hours_non_datetime_type() -> None:
+    """Test _compute_hours with non-datetime, non-string types."""
+    from timetracker_utils.cli import _compute_hours
+
+    # Integer types hit the elif isinstance(x, datetime) else branch and return ""
+    result = _compute_hours(100, 200)
+    assert result == ""
diff --git a/tests/test_config.py b/tests/test_config.py
new file mode 100644
index 0000000..855ddd2
--- /dev/null
+++ b/tests/test_config.py
@@ -0,0 +1,97 @@
+"""Tests for the configuration module."""
+
+import os
+from pathlib import Path
+
+import pytest
+import yaml
+from pydantic import ValidationError
+
+from timetracker_utils.config import TimeTrackerConfig, load_config
+
+
+def test_load_config(tmp_path: Path) -> None:
+    """Test loading a valid config YAML file."""
+    config_path = tmp_path / "timetracker.yml"
+    config_path.write_text(
+        yaml.dump({"database": "~/data/timetracker/db.sqlite3", "timezone": "ET"}),
+        encoding="utf-8",
+    )
+    config = load_config(config_path)
+    expected = str(Path(os.path.expanduser("~/data/timetracker/db.sqlite3")))
+    assert config.database == expected
+    assert config.timezone == "ET"
+
+
+def test_load_config_missing_file() -> None:
+    """Test that load_config raises FileNotFoundError for a missing file."""
+    with pytest.raises(FileNotFoundError, match="Configuration file not found"):
+        load_config(Path("/nonexistent/path/config.yml"))
+
+
+def test_load_config_invalid_yaml(tmp_path: Path) -> None:
+    """Test that load_config raises an error for invalid YAML."""
+    config_path = tmp_path / "bad.yml"
+    config_path.write_text("invalid: yaml: content: [", encoding="utf-8")
+    with pytest.raises(yaml.YAMLError):
+        load_config(config_path)
+
+
+def test_load_config_missing_fields(tmp_path: Path) -> None:
+    """Test that load_config raises an error when required fields are missing."""
+    config_path = tmp_path / "incomplete.yml"
+    config_path.write_text(
+        yaml.dump({"database": "~/data/db.sqlite3"}),
+        encoding="utf-8",
+    )
+    with pytest.raises(ValidationError):
+        load_config(config_path)
+
+
+def test_max_conflict_display_default() -> None:
+    """Test that max_conflict_display defaults to 100."""
+    config = TimeTrackerConfig(database="~/test.db", timezone="UTC")
+    assert config.max_conflict_display == 100
+
+
+def test_max_conflict_display_custom() -> None:
+    """Test that max_conflict_display can be set to a custom value."""
+    config = TimeTrackerConfig(
+        database="~/test.db", timezone="UTC", max_conflict_display=50
+    )
+    assert config.max_conflict_display == 50
+
+
+def test_max_conflict_display_zero() -> None:
+    """Test that max_conflict_display can be set to 0."""
+    config = TimeTrackerConfig(
+        database="~/test.db", timezone="UTC", max_conflict_display=0
+    )
+    assert config.max_conflict_display == 0
+
+
+def test_time_tracker_config_model() -> None:
+    """Test the TimeTrackerConfig model directly."""
+    config = TimeTrackerConfig(database="~/data/db.sqlite3", timezone="PT")
+    expected = str(Path(os.path.expanduser("~/data/db.sqlite3")))
+    assert config.database == expected
+    assert config.timezone == "PT"
+    assert config.max_conflict_display == 100  # default
+
+
+def test_database_path_tilde_expansion() -> None:
+    """Test that tilde in database path is expanded to the home directory."""
+    config = TimeTrackerConfig(database="~/test.db", timezone="UTC")
+    assert config.database == str(Path.home() / "test.db")
+
+
+def test_database_path_absolute_not_expanded() -> None:
+    """Test that an absolute path without tilde is kept as-is."""
+    config = TimeTrackerConfig(database="/absolute/path/db.sqlite3", timezone="UTC")
+    assert config.database == "/absolute/path/db.sqlite3"
+
+
+def test_database_path_relative_not_expanded() -> None:
+    """Test that a relative path without tilde is kept as-is."""
+    config = TimeTrackerConfig(database="relative/path/db.sqlite3", timezone="UTC")
+    assert config.database == "relative/path/db.sqlite3"
diff --git a/tests/test_database.py b/tests/test_database.py
new file mode 100644
index 0000000..1c855d9
--- /dev/null
+++ b/tests/test_database.py
@@ -0,0 +1,783 @@
+"""Tests for the Database module."""
+# ruff: noqa: E501 - CSV data lines exceed line length limit
+# mypy: ignore-errors
+# Pydantic validators handle runtime type coercion
+
+import sqlite3
+from pathlib import Path
+
+import pandas as pd
+import pytest
+from pydantic import ValidationError
+
+from timetracker_utils.database import (
+    ActivityEntry,
+    Database,
+    MergeConflictError,
+)
+
+SAMPLE_DF = pd.DataFrame(
+    {
+        "date": ["1/15/2200", "1/16/2200"],
+        "project": ["StellarCartography", "Hydroponics"],
+        "description": ["nebula mapping", "crop harvest"],
+        "combined": ["StellarCartography: nebula mapping", "Hydroponics: crop harvest"],
+        "start_time": pd.to_datetime(
+            ["2200-01-15 09:00:00+00:00", "2200-01-16 13:00:00+00:00"]
+        ),
+        "end_time": pd.to_datetime(
+            ["2200-01-15 11:30:00+00:00", "2200-01-16 14:45:00+00:00"]
+        ),
+        "hours": [2.5, 1.75],
+        "notes": ["", ""],
+    }
+)
+
+
+def test_activity_entry_fields() -> None:
+    """Test that ActivityEntry has the expected fields (no computed columns)."""
+    entry = ActivityEntry(
+        date="1/15/2200",
+        project="StellarCartography",
+        description="nebula mapping",
+        start_time="2200-01-15T09:00:00.000Z",
+        end_time="2200-01-15T11:30:00.000Z",
+        notes="",
+    )
+    assert entry.date == "1/15/2200"
+    assert entry.project == "StellarCartography"
+    assert entry.description == "nebula mapping"
+    # Verify combined and hours are NOT present
+    assert not hasattr(entry, "combined")
+    assert not hasattr(entry, "hours")
+
+
+def test_activity_entry_start_time_required() -> None:
+    """Test that start_time is required for ActivityEntry."""
+    with pytest.raises(ValidationError, match="Field required"):
+        ActivityEntry(
+            date="1/15/2200",
+            project="StellarCartography",
+            description="nebula mapping",
+        )
+
+
+def test_database_write_creates_table(tmp_path: Path) -> None:
+    """Test that Database.write creates a SQLite table with correct schema."""
+    db_path = tmp_path / "test.db"
+    db = Database()
+    db.write(SAMPLE_DF, db_path)
+    assert db_path.exists()
+    conn = sqlite3.connect(str(db_path))
+    try:
+        cur = conn.execute("PRAGMA table_info(activities)")
+        columns = {row[1] for row in cur.fetchall()}
+        # Should have the core fields but NOT combined or hours
+        assert "date" in columns
+        assert "project" in columns
+        assert "description" in columns
+        assert "start_time" in columns
+        assert "end_time" in columns
+        assert "notes" in columns
+        assert "combined" not in columns
+        assert "hours" not in columns
+    finally:
+        conn.close()
+
+
+def test_database_write_stores_correct_count(tmp_path: Path) -> None:
+    """Test that Database.write stores the correct number of rows."""
+    db_path = tmp_path / "test.db"
+    db = Database()
+    db.write(SAMPLE_DF, db_path)
+    conn = sqlite3.connect(str(db_path))
+    try:
+        cur = conn.execute("SELECT COUNT(*) FROM activities")
+        count = cur.fetchone()[0]
+        assert count == 2
+    finally:
+        conn.close()
+
+
+def test_database_write_merge_keeps_existing_when_no_overlap(tmp_path: Path) -> None:
+    """Test that merge keeps existing rows and adds new rows with different keys."""
+    db_path = tmp_path / "test.db"
+    db = Database()
+    db.write(SAMPLE_DF, db_path)
+
+    # New data with completely different project/description/times
+    new_df = pd.DataFrame(
+        {
+            "date": ["1/17/2200"],
+            "project": ["Astrobiology"],
+            "description": ["sample analysis"],
+            "start_time": pd.to_datetime(["2200-01-17 10:00:00+00:00"]),
+            "end_time": pd.to_datetime(["2200-01-17 12:00:00+00:00"]),
+            "notes": [""],
+        }
+    )
+    db.write(new_df, db_path)
+    conn = sqlite3.connect(str(db_path))
+    try:
+        cur = conn.execute("SELECT COUNT(*) FROM activities")
+        count = cur.fetchone()[0]
+        assert count == 3  # 2 original + 1 new
+    finally:
+        conn.close()
+
+
+# ── Merge Rule 1: Identical rows silently dropped ──────────────────────
+
+
+def test_merge_drops_identical_row(tmp_path: Path) -> None:
+    """Test that an identical row is silently dropped (Rule 1)."""
+    db_path = tmp_path / "test.db"
+    db = Database()
+
+    # Write initial data
+    initial_df = pd.DataFrame(
+        {
+            "date": ["1/15/2200"],
+            "project": ["StellarCartography"],
+            "description": ["nebula mapping"],
+            "start_time": pd.to_datetime(["2200-01-15 09:00:00+00:00"]),
+            "end_time": pd.to_datetime(["2200-01-15 11:30:00+00:00"]),
+            "notes": [""],
+        }
+    )
+    db.write(initial_df, db_path)
+
+    # Write the exact same data again
+    db.write(initial_df, db_path)
+
+    conn = sqlite3.connect(str(db_path))
+    try:
+        cur = conn.execute("SELECT COUNT(*) FROM activities")
+        count = cur.fetchone()[0]
+        assert count == 1  # No duplicate added
+    finally:
+        conn.close()
+
+
+# ── Merge Rule 2: Blank-fill merge ─────────────────────────────────────
+
+
+def test_merge_blank_fill_notes(tmp_path: Path) -> None:
+    """Test that blank-fill merge fills in notes when old entry has blank notes."""
+    db_path = tmp_path / "test.db"
+    db = Database()
+
+    # Write initial data with blank notes
+    initial_df = pd.DataFrame(
+        {
+            "date": ["1/15/2200"],
+            "project": ["StellarCartography"],
+            "description": ["nebula mapping"],
+            "start_time": pd.to_datetime(["2200-01-15 09:00:00+00:00"]),
+            "end_time": pd.to_datetime(["2200-01-15 11:30:00+00:00"]),
+            "notes": [""],
+        }
+    )
+    db.write(initial_df, db_path)
+
+    # Write same entry but with notes filled in
+    updated_df = pd.DataFrame(
+        {
+            "date": ["1/15/2200"],
+            "project": ["StellarCartography"],
+            "description": ["nebula mapping"],
+            "start_time": pd.to_datetime(["2200-01-15 09:00:00+00:00"]),
+            "end_time": pd.to_datetime(["2200-01-15 11:30:00+00:00"]),
+            "notes": ["Mapped the Triangulum Nebula"],
+        }
+    )
+    db.write(updated_df, db_path)
+
+    conn = sqlite3.connect(str(db_path))
+    try:
+        cur = conn.execute("SELECT notes FROM activities")
+        notes = cur.fetchone()[0]
+        assert notes == "Mapped the Triangulum Nebula"
+        cur = conn.execute("SELECT COUNT(*) FROM activities")
+        count = cur.fetchone()[0]
+        assert count == 1  # Still only 1 row
+    finally:
+        conn.close()
+
+
+def test_merge_blank_fill_date(tmp_path: Path) -> None:
+    """Test that blank-fill merge fills in date when old entry has blank date."""
+    db_path = tmp_path / "test.db"
+    db = Database()
+
+    # Write initial data with blank date
+    initial_df = pd.DataFrame(
+        {
+            "date": [""],
+            "project": ["StellarCartography"],
+            "description": ["nebula mapping"],
+            "start_time": pd.to_datetime(["2200-01-15 09:00:00+00:00"]),
+            "end_time": pd.to_datetime(["2200-01-15 11:30:00+00:00"]),
+            "notes": [""],
+        }
+    )
+    db.write(initial_df, db_path)
+
+    # Write same entry but with date filled in
+    updated_df = pd.DataFrame(
+        {
+            "date": ["1/15/2200"],
+            "project": ["StellarCartography"],
+            "description": ["nebula mapping"],
+            "start_time": pd.to_datetime(["2200-01-15 09:00:00+00:00"]),
+            "end_time": pd.to_datetime(["2200-01-15 11:30:00+00:00"]),
+            "notes": [""],
+        }
+    )
+    db.write(updated_df, db_path)
+
+    conn = sqlite3.connect(str(db_path))
+    try:
+        cur = conn.execute("SELECT date FROM activities")
+        date = cur.fetchone()[0]
+        assert date == "1/15/2200"
+    finally:
+        conn.close()
+
+
+# ── Merge Rule 3: Conflicts ────────────────────────────────────────────
+
+
+def test_merge_conflict_detected(tmp_path: Path) -> None:
+    """Test that a merge conflict raises MergeConflictError."""
+    db_path = tmp_path / "test.db"
+    db = Database()
+
+    # Write initial data with non-blank notes
+    initial_df = pd.DataFrame(
+        {
+            "date": ["1/15/2200"],
+            "project": ["StellarCartography"],
+            "description": ["nebula mapping"],
+            "start_time": pd.to_datetime(["2200-01-15 09:00:00+00:00"]),
+            "end_time": pd.to_datetime(["2200-01-15 11:30:00+00:00"]),
+            "notes": ["Original notes"],
+        }
+    )
+    db.write(initial_df, db_path)
+
+    # Write same entry but with different non-blank notes
+    conflicting_df = pd.DataFrame(
+        {
+            "date": ["1/15/2200"],
+            "project": ["StellarCartography"],
+            "description": ["nebula mapping"],
+            "start_time": pd.to_datetime(["2200-01-15 09:00:00+00:00"]),
+            "end_time": pd.to_datetime(["2200-01-15 11:30:00+00:00"]),
+            "notes": ["Different notes"],
+        }
+    )
+
+    with pytest.raises(MergeConflictError) as exc_info:
+        db.write(conflicting_df, db_path)
+
+    assert "Merge conflict detected" in str(exc_info.value)
+    assert len(exc_info.value.conflicts) == 1
+    assert exc_info.value.conflicts[0]["notes"] == "Original notes"
+
+
+def test_merge_conflict_on_date(tmp_path: Path) -> None:
+    """Test that a conflict on the date field is detected."""
+    db_path = tmp_path / "test.db"
+    db = Database()
+
+    initial_df = pd.DataFrame(
+        {
+            "date": ["1/15/2200"],
+            "project": ["StellarCartography"],
+            "description": ["nebula mapping"],
+            "start_time": pd.to_datetime(["2200-01-15 09:00:00+00:00"]),
+            "end_time": pd.to_datetime(["2200-01-15 11:30:00+00:00"]),
+            "notes": [""],
+        }
+    )
+    db.write(initial_df, db_path)
+
+    conflicting_df = pd.DataFrame(
+        {
+            "date": ["1/16/2200"],  # Different date
+            "project": ["StellarCartography"],
+            "description": ["nebula mapping"],
+            "start_time": pd.to_datetime(["2200-01-15 09:00:00+00:00"]),
+            "end_time": pd.to_datetime(["2200-01-15 11:30:00+00:00"]),
+            "notes": [""],
+        }
+    )
+
+    with pytest.raises(MergeConflictError, match="Merge conflict detected"):
+        db.write(conflicting_df, db_path)
+
+
+def test_merge_conflict_multiple_entries(tmp_path: Path) -> None:
+    """Test that multiple conflicts are all collected."""
+    db_path = tmp_path / "test.db"
+    db = Database()
+
+    initial_df = pd.DataFrame(
+        {
+            "date": ["1/15/2200", "1/16/2200"],
+            "project": ["ProjA", "ProjB"],
+            "description": ["descA", "descB"],
+            "start_time": pd.to_datetime(
+                ["2200-01-15 09:00:00+00:00", "2200-01-16 10:00:00+00:00"]
+            ),
+            "end_time": pd.to_datetime(
+                ["2200-01-15 11:00:00+00:00", "2200-01-16 12:00:00+00:00"]
+            ),
+            "notes": ["Note A", "Note B"],
+        }
+    )
+    db.write(initial_df, db_path)
+
+    conflicting_df = pd.DataFrame(
+        {
+            "date": ["1/15/2200", "1/16/2200"],
+            "project": ["ProjA", "ProjB"],
+            "description": ["descA", "descB"],
+            "start_time": pd.to_datetime(
+                ["2200-01-15 09:00:00+00:00", "2200-01-16 10:00:00+00:00"]
+            ),
+            "end_time": pd.to_datetime(
+                ["2200-01-15 11:00:00+00:00", "2200-01-16 12:00:00+00:00"]
+            ),
+            "notes": ["Different A", "Different B"],
+        }
+    )
+
+    with pytest.raises(MergeConflictError) as exc_info:
+        db.write(conflicting_df, db_path)
+
+    assert len(exc_info.value.conflicts) == 2
+
+
+def test_merge_conflict_max_display_limit(tmp_path: Path) -> None:
+    """Test that max_conflict_display limits the displayed conflicts."""
+    db_path = tmp_path / "test.db"
+    db = Database()
+
+    # Create 5 existing entries
+    rows: list[dict] = []
+    for i in range(5):
+        rows.append(
+            {
+                "date": f"1/{15 + i}/2200",
+                "project": "Proj",
+                "description": f"desc{i}",
+                "start_time": pd.to_datetime(f"2200-01-{15 + i:02d} 09:00:00+00:00"),
+                "end_time": pd.to_datetime(f"2200-01-{15 + i:02d} 11:00:00+00:00"),
+                "notes": f"Original note {i}",
+            }
+        )
+    initial = pd.DataFrame(rows)
+    db.write(initial, db_path)
+
+    # Create conflicting entries with max_conflict_display=2
+    conflicting_rows: list[dict] = []
+    for i in range(5):
+        conflicting_rows.append(
+            {
+                "date": f"1/{15 + i}/2200",
+                "project": "Proj",
+                "description": f"desc{i}",
+                "start_time": pd.to_datetime(f"2200-01-{15 + i:02d} 09:00:00+00:00"),
+                "end_time": pd.to_datetime(f"2200-01-{15 + i:02d} 11:00:00+00:00"),
+                "notes": f"Different note {i}",
+            }
+        )
+    conflicting = pd.DataFrame(conflicting_rows)
+
+    with pytest.raises(MergeConflictError) as exc_info:
+        db.write(conflicting, db_path, max_conflict_display=2)
+
+    msg = str(exc_info.value)
+    # Should mention the total count and that more exist
+    assert "5 entr" in msg
+    assert "and 3 more conflicts" in msg
+
+
+def test_merge_conflict_max_display_zero_suppresses_list(tmp_path: Path) -> None:
+    """Test that max_conflict_display=0 suppresses the conflict list."""
+    db_path = tmp_path / "test.db"
+    db = Database()
+
+    initial_df = pd.DataFrame(
+        {
+            "date": ["1/15/2200"],
+            "project": ["ProjA"],
+            "description": ["descA"],
+            "start_time": pd.to_datetime(["2200-01-15 09:00:00+00:00"]),
+            "end_time": pd.to_datetime(["2200-01-15 11:00:00+00:00"]),
+            "notes": ["Original"],
+        }
+    )
+    db.write(initial_df, db_path)
+
+    conflicting_df = pd.DataFrame(
+        {
+            "date": ["1/15/2200"],
+            "project": ["ProjA"],
+            "description": ["descA"],
+            "start_time": pd.to_datetime(["2200-01-15 09:00:00+00:00"]),
+            "end_time": pd.to_datetime(["2200-01-15 11:00:00+00:00"]),
+            "notes": ["Different"],
+        }
+    )
+
+    with pytest.raises(MergeConflictError) as exc_info:
+        db.write(conflicting_df, db_path, max_conflict_display=0)
+
+    msg = str(exc_info.value)
+    assert "Merge conflict detected" in msg
+    # The conflict list should be empty since max is 0
+    assert "notes=" not in msg or "project=" not in msg or msg.count("project=") == 0
+
+
+# ── Mixed scenarios ────────────────────────────────────────────────────
+
+
+def test_merge_mixed_new_and_identical(tmp_path: Path) -> None:
+    """Test merge with a mix of new, identical, and blank-fill rows."""
+    db_path = tmp_path / "test.db"
+    db = Database()
+
+    initial_df = pd.DataFrame(
+        {
+            "date": ["1/15/2200", "1/16/2200", "1/17/2200"],
+            "project": ["A", "B", "C"],
+            "description": ["descA", "descB", "descC"],
+            "start_time": pd.to_datetime(
+                [
+                    "2200-01-15 09:00:00+00:00",
+                    "2200-01-16 09:00:00+00:00",
+                    "2200-01-17 09:00:00+00:00",
+                ]
+            ),
+            "end_time": pd.to_datetime(
+                [
+                    "2200-01-15 11:00:00+00:00",
+                    "2200-01-16 11:00:00+00:00",
+                    "2200-01-17 11:00:00+00:00",
+                ]
+            ),
+            "notes": ["", "", "Note C"],
+        }
+    )
+    db.write(initial_df, db_path)
+
+    # Row 1 (project=A): existing notes are blank → blank-fill merge → notes become "Existing notes"
+    # Row 2 (project=B): existing notes are blank → blank-fill merge → notes become "New notes for B"
+    # Row 3 (project=D): new entry with different key → added
+    incoming_df = pd.DataFrame(
+        {
+            "date": ["1/15/2200", "1/16/2200", "1/18/2200"],
+            "project": ["A", "B", "D"],
+            "description": ["descA", "descB", "descD"],
+            "start_time": pd.to_datetime(
+                [
+                    "2200-01-15 09:00:00+00:00",
+                    "2200-01-16 09:00:00+00:00",
+                    "2200-01-18 10:00:00+00:00",
+                ]
+            ),
+            "end_time": pd.to_datetime(
+                [
+                    "2200-01-15 11:00:00+00:00",
+                    "2200-01-16 11:00:00+00:00",
+                    "2200-01-18 12:00:00+00:00",
+                ]
+            ),
+            "notes": ["Existing notes", "New notes for B", ""],
+        }
+    )
+    db.write(incoming_df, db_path)
+
+    conn = sqlite3.connect(str(db_path))
+    try:
+        cur = conn.execute("SELECT COUNT(*) FROM activities")
+        count = cur.fetchone()[0]
+        # Row 1 (blank-fill) → merged, not added as new
+        # Row 2 (blank-fill) → merged, not added as new
+        # Row 3 (new) → added
+        # Original rows: A (notes filled), B (notes filled), C (unchanged)
+        # Total = 3 original + 1 new = 4
+        assert count == 4
+
+        # Verify row 1 notes were filled (blank-fill merge)
+        cur = conn.execute("SELECT notes FROM activities WHERE project='A'")
+        notes_a = cur.fetchone()[0]
+        assert notes_a == "Existing notes"
+
+        # Verify row 2 notes were filled
+        cur = conn.execute("SELECT notes FROM activities WHERE project='B'")
+        notes_b = cur.fetchone()[0]
+        assert notes_b == "New notes for B"
+
+        # Verify row 3 notes still say "Note C" (unchanged)
+        cur = conn.execute("SELECT notes FROM activities WHERE project='C'")
+        notes_c = cur.fetchone()[0]
+        assert notes_c == "Note C"
+
+    finally:
+        conn.close()
+
+
+# ── Existing behavior preserved ────────────────────────────────────────
+
+
+def test_database_write_creates_parent_directories(tmp_path: Path) -> None:
+    """Test that Database.write creates parent directories if they don't exist."""
+    db_path = tmp_path / "nested" / "dirs" / "test.db"
+    db = Database()
+    db.write(SAMPLE_DF, db_path)
+    assert db_path.exists()
+
+
+def test_database_write_empty_dataframe(tmp_path: Path) -> None:
+    """Test that Database.write handles an empty DataFrame gracefully."""
+    db_path = tmp_path / "test.db"
+    db = Database()
+    empty_df = pd.DataFrame()
+    db.write(empty_df, db_path)
+    assert db_path.exists()
+    conn = sqlite3.connect(str(db_path))
+    try:
+        cur = conn.execute(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name='activities'"
+        )
+        assert cur.fetchone() is not None
+        cur = conn.execute("SELECT COUNT(*) FROM activities")
+        count = cur.fetchone()[0]
+        assert count == 0
+    finally:
+        conn.close()
+
+
+def test_database_normalise_missing_endtime_column() -> None:
+    """Test normalisation when the end_time column is missing from the DataFrame (hits line 246 else None)."""
+    df = pd.DataFrame(
+        {
+            "date": ["1/15/2200"],
+            "project": ["ProjA"],
+            "description": ["desc"],
+            "start_time": pd.to_datetime(["2200-01-15 09:00:00+00:00"]),
+            "notes": [""],
+        }
+    )
+    normalised = Database._normalise_dataframe(df)
+    assert "end_time" in normalised.columns
+    assert normalised["end_time"].iloc[0] is None
+
+
+def test_database_normalise_missing_date_column(tmp_path: Path) -> None:
+    """Test normalisation when the date column is missing from the DataFrame (hits line 246 empty string)."""
+    db_path = tmp_path / "test.db"
+    db = Database()
+    df = pd.DataFrame(
+        {
+            "project": ["ProjA"],
+            "description": ["desc"],
+            "start_time": pd.to_datetime(["2200-01-15 09:00:00+00:00"]),
+            "end_time": pd.to_datetime(["2200-01-15 11:00:00+00:00"]),
+            "notes": [""],
+        }
+    )
+    db.write(df, db_path)
+    conn = sqlite3.connect(str(db_path))
+    try:
+        cur = conn.execute("SELECT date FROM activities")
+        assert cur.fetchone()[0] == ""
+    finally:
+        conn.close()
+
+
+def test_rows_identical_with_nan_both_sides() -> None:
+    """Test _rows_identical when both values are pd.isna (hits line 438)."""
+    row_a = pd.Series({"date": None, "notes": None})
+    row_b = pd.Series({"date": None, "notes": None})
+    assert Database._rows_identical(row_a, row_b, include_key=False)
+
+
+def test_merge_empty_incoming_preserves_existing(tmp_path: Path) -> None:
+    """Test that merging an empty DataFrame with existing data preserves existing."""
+    db_path = tmp_path / "test.db"
+    db = Database()
+    db.write(SAMPLE_DF, db_path)
+    # Merge with empty DataFrame — incoming is empty, existing stays
+    db.write(pd.DataFrame(), db_path)
+    conn = sqlite3.connect(str(db_path))
+    try:
+        cur = conn.execute("SELECT COUNT(*) FROM activities")
+        assert cur.fetchone()[0] == 2
+    finally:
+        conn.close()
+
+
+def test_merge_key_with_nan_endtime(tmp_path: Path) -> None:
+    """Test that NaN values in key columns are handled when building merge keys (hits pd.isna branch)."""
+    db_path = tmp_path / "test.db"
+    db = Database()
+    # Write initial data with no end_time (will be None in DataFrame)
+    initial_df = pd.DataFrame(
+        {
+            "date": ["1/15/2200"],
+            "project": ["ProjA"],
+            "description": ["desc"],
+            "start_time": pd.to_datetime(["2200-01-15 09:00:00+00:00"]),
+            "end_time": pd.to_datetime(["2200-01-15 11:00:00+00:00"]),
+            "notes": [""],
+        }
+    )
+    db.write(initial_df, db_path)
+
+    # New data with NaN in end_time (pd.NaT) — _make_key will hit pd.isna branch
+    incoming_df = pd.DataFrame(
+        {
+            "date": ["1/16/2200"],
+            "project": ["ProjB"],
+            "description": ["desc2"],
+            "start_time": pd.to_datetime(["2200-01-16 09:00:00+00:00"]),
+            "end_time": pd.Series([pd.NaT], dtype="datetime64[ns]"),
+            "notes": [""],
+        }
+    )
+    db.write(incoming_df, db_path)
+    conn = sqlite3.connect(str(db_path))
+    try:
+        cur = conn.execute("SELECT COUNT(*) FROM activities")
+        assert cur.fetchone()[0] == 2
+    finally:
+        conn.close()
+
+
+def test_merge_identical_with_nan_notes(tmp_path: Path) -> None:
+    """Test that identical rows with NaT values silently drop duplicates (hits pd.isna branch)."""
+    db_path = tmp_path / "test.db"
+    db = Database()
+    df = pd.DataFrame(
+        {
+            "date": ["1/15/2200"],
+            "project": ["ProjA"],
+            "description": ["desc"],
+            "start_time": pd.to_datetime(["2200-01-15 09:00:00+00:00"]),
+            "end_time": pd.Series([pd.NaT], dtype="datetime64[ns]"),
+            "notes": [""],
+        }
+    )
+    db.write(df, db_path)
+    # Write exact same data again — identical row should be dropped
+    db.write(df, db_path)
+    conn = sqlite3.connect(str(db_path))
+    try:
+        cur = conn.execute("SELECT COUNT(*) FROM activities")
+        assert cur.fetchone()[0] == 1  # No duplicate
+    finally:
+        conn.close()
+
+
+def test_merge_old_non_blank_new_blank(tmp_path: Path) -> None:
+    """Test merge when old row has non-blank values but new row has blank (hits fallthrough)."""
+    db_path = tmp_path / "test.db"
+    db = Database()
+
+    initial_df = pd.DataFrame(
+        {
+            "date": ["1/15/2200"],
+            "project": ["ProjA"],
+            "description": ["desc"],
+            "start_time": pd.to_datetime(["2200-01-15 09:00:00+00:00"]),
+            "end_time": pd.to_datetime(["2200-01-15 11:00:00+00:00"]),
+            "notes": ["Original notes"],
+        }
+    )
+    db.write(initial_df, db_path)
+
+    # Same key but notes is blank — old is non-blank, new is blank.
+    # Not identical (notes differ).
+    # Not a blank-fill (old non-blank, new blank → _is_blank_fill returns False).
+    # Not a conflict (new is blank → _is_conflict returns False).
+    # Falls through to 'not resolved' branch.
+    incoming_df = pd.DataFrame(
+        {
+            "date": ["1/15/2200"],
+            "project": ["ProjA"],
+            "description": ["desc"],
+            "start_time": pd.to_datetime(["2200-01-15 09:00:00+00:00"]),
+            "end_time": pd.to_datetime(["2200-01-15 11:00:00+00:00"]),
+            "notes": [""],
+        }
+    )
+    db.write(incoming_df, db_path)
+
+    conn = sqlite3.connect(str(db_path))
+    try:
+        cur = conn.execute("SELECT COUNT(*) FROM activities")
+        # Old row preserved, new row added via fallthrough
+        assert cur.fetchone()[0] == 2
+    finally:
+        conn.close()
+
+
+def test_database_write_drops_hours_and_combined(tmp_path: Path) -> None:
+    """Test that the database table does NOT contain hours or combined columns."""
+    db_path = tmp_path / "test.db"
+    db = Database()
+    db.write(SAMPLE_DF, db_path)
+    conn = sqlite3.connect(str(db_path))
+    try:
+        cur = conn.execute("PRAGMA table_info(activities)")
+        col_names = {row[1] for row in cur.fetchall()}
+        assert "hours" not in col_names
+        assert "combined" not in col_names
+    finally:
+        conn.close()
+
+
+def test_database_entries_property_after_write(tmp_path: Path) -> None:
+    """Test that db.entries is populated after write."""
+    db_path = tmp_path / "test.db"
+    db = Database()
+    db.write(SAMPLE_DF, db_path)
+    assert not db.entries.empty
+    assert len(db.entries) == 2
+    # Should not have combined or hours
+    assert "combined" not in db.entries.columns
+    assert "hours" not in db.entries.columns
+    assert "date" in db.entries.columns
+    assert "project" in db.entries.columns
+
+
+def test_database_write_from_timecop(tmp_path: Path) -> None:
+    """Test end-to-end: TimeCop -> Database.write creates correct DB."""
+    from timetracker_utils.time_cop import TimeCop
+
+    SAMPLE_CSV = """\
+"Date","Project","Description","Combined Project & Description","Start Time","End Time","Time (hours)","Notes"
+"1/15/2200","StellarCartography","nebula mapping","StellarCartography: nebula mapping","2200-01-15T09:00:00.000Z","2200-01-15T11:30:00.000Z","2.5",""
+"1/16/2200","Hydroponics","crop harvest","Hydroponics: crop harvest","2200-01-16T13:00:00.000Z","2200-01-16T14:45:00.000Z","1.75",""
+"""
+    cop = TimeCop()
+    cop.read_csv_string(SAMPLE_CSV)
+    db_path = tmp_path / "test.db"
+    db = Database()
+    db.write(cop.entries, db_path)
+    conn = sqlite3.connect(str(db_path))
+    try:
+        cur = conn.execute("SELECT COUNT(*) FROM activities")
+        count = cur.fetchone()[0]
+        assert count == 2
+        cur = conn.execute("SELECT project, description FROM activities")
+        rows = cur.fetchall()
+        assert rows[0] == ("StellarCartography", "nebula mapping")
+        assert rows[1] == ("Hydroponics", "crop harvest")
+    finally:
+        conn.close()
diff --git a/tests/test_datetime_utils.py b/tests/test_datetime_utils.py
new file mode 100644
index 0000000..5a673c1
--- /dev/null
+++ b/tests/test_datetime_utils.py
@@ -0,0 +1,109 @@
+"""Tests for the datetime_utils module."""
+
+from zoneinfo import ZoneInfo
+
+import pandas as pd
+import pytest
+
+from timetracker_utils.datetime_utils import convert_column_tz, resolve_tz
+
+
+def test_resolve_tz_abbreviation_et() -> None:
+    """Test that ET resolves to America/New_York."""
+    zone = resolve_tz("ET")
+    assert zone == ZoneInfo("America/New_York")
+
+
+def test_resolve_tz_abbreviation_pt() -> None:
+    """Test that PT resolves to America/Los_Angeles."""
+    zone = resolve_tz("PT")
+    assert zone == ZoneInfo("America/Los_Angeles")
+
+
+def test_resolve_tz_abbreviation_utc() -> None:
+    """Test that UTC resolves to UTC."""
+    zone = resolve_tz("UTC")
+    assert zone == ZoneInfo("UTC")
+
+
+def test_resolve_tz_abbreviation_case_insensitive() -> None:
+    """Test that abbreviation resolution is case-insensitive."""
+    zone = resolve_tz("et")
+    assert zone == ZoneInfo("America/New_York")
+
+
+def test_resolve_tz_iana_name() -> None:
+    """Test that a full IANA name resolves correctly."""
+    zone = resolve_tz("Europe/London")
+    assert zone == ZoneInfo("Europe/London")
+
+
+def test_resolve_tz_unsupported() -> None:
+    """Test that an unsupported timezone abbreviation returns None."""
+    zone = resolve_tz("XZ")
+    assert zone is None
+
+
+def test_resolve_tz_iana_case_insensitive() -> None:
+    """Test that IANA names are matched case-insensitively."""
+    zone = resolve_tz("america/new_york")
+    assert zone == ZoneInfo("America/New_York")
+
+
+def test_convert_column_tz_et() -> None:
+    """Test converting UTC timestamps to Eastern Time via abbreviation."""
+    series = pd.Series(
+        pd.to_datetime(
+            ["2026-04-13T15:00:00Z", "2026-04-13T16:00:00Z"],
+            utc=True,
+        )
+    )
+    result = convert_column_tz(series, "ET")
+    assert result.dt.tz == ZoneInfo("America/New_York")
+    # ET is UTC-4 in April
+    assert result.iloc[0].hour == 11
+    assert result.iloc[1].hour == 12
+
+
+def test_convert_column_tz_iana() -> None:
+    """Test converting UTC timestamps to a full IANA timezone."""
+    series = pd.Series(
+        pd.to_datetime(
+            ["2026-04-13T15:00:00Z"],
+            utc=True,
+        )
+    )
+    result = convert_column_tz(series, "America/Los_Angeles")
+    assert result.dt.tz == ZoneInfo("America/Los_Angeles")
+    # PT is UTC-7 in April
+    assert result.iloc[0].hour == 8
+
+
+def test_convert_column_tz_naive_treated_as_utc() -> None:
+    """Test that timezone-naive values are assumed to be UTC."""
+    series = pd.Series(pd.to_datetime(["2026-04-13T15:00:00", "2026-04-13T16:00:00"]))
+    result = convert_column_tz(series, "ET")
+    assert result.dt.tz == ZoneInfo("America/New_York")
+    assert result.iloc[0].hour == 11
+
+
+def test_convert_column_tz_does_not_mutate() -> None:
+    """Test that the original series is not mutated."""
+    series = pd.Series(pd.to_datetime(["2026-04-13T15:00:00Z"], utc=True))
+    original = series.copy()
+    _ = convert_column_tz(series, "ET")
+    assert series.iloc[0] == original.iloc[0]
+
+
+def test_convert_column_tz_unsupported_raises() -> None:
+    """Test that an unsupported timezone raises ValueError."""
+    series = pd.Series(pd.to_datetime(["2026-04-13T15:00:00Z"], utc=True))
+    with pytest.raises(ValueError, match="Cannot resolve timezone"):
+        convert_column_tz(series, "XZ")
+
+
+def test_convert_column_tz_utc_to_utc() -> None:
+    """Test converting to UTC (identity)."""
+    series = pd.Series(pd.to_datetime(["2026-04-13T15:00:00Z"], utc=True))
+    result = convert_column_tz(series, "UTC")
+    assert result.iloc[0].hour == 15
diff --git a/tests/test_hello.py b/tests/test_hello.py
deleted file mode 100644
index 9b8bb29..0000000
--- a/tests/test_hello.py
+++ /dev/null
@@ -1,113 +0,0 @@
-"""Tests for the hello module."""
-
-import logging
-
-import pytest
-from pydantic import ValidationError
-from typer.testing import CliRunner
-
-from python_package_template import Config, HelloWorld
-from python_package_template.cli import app
-
-
-def test_default_name(caplog: pytest.LogCaptureFixture) -> None:
-    """Test HelloWorld with default name.
-
-    Args:
-        caplog: Pytest fixture for capturing log output.
-
-    """
-    caplog.set_level(logging.INFO)
-    hello_world = HelloWorld()
-    greeting = hello_world.greet()
-    assert greeting == "Hello, World!"
-    assert len(caplog.records) == 1
-    assert caplog.records[0].message == "hello World"
-    assert caplog.records[0].levelname == "INFO"
-
-
-def test_custom_name(caplog: pytest.LogCaptureFixture) -> None:
-    """Test HelloWorld with custom name.
-
-    Args:
-        caplog: Pytest fixture for capturing log output.
-
-    """
-    caplog.set_level(logging.INFO)
-    hello_world = HelloWorld(Config(name="Alice"))
-    greeting = hello_world.greet()
-    assert greeting == "Hello, Alice!"
-    assert len(caplog.records) == 1
-    assert caplog.records[0].message == "hello Alice"
-    assert caplog.records[0].levelname == "INFO"
-
-
-def test_empty_name_validation() -> None:
-    """Test that Config validates against empty names."""
-    with pytest.raises(ValidationError, match="at least 1 character"):
-        Config(name="")
-
-
-def test_config_frozen_immutability() -> None:
-    """Test that Config is frozen and cannot be modified after creation."""
-    config = Config(name="Alice")
-    with pytest.raises(ValidationError, match="Instance is frozen"):
-        config.name = "Bob"
-
-
-def test_config_invalid_type() -> None:
-    """Test that Config validates against invalid types."""
-    with pytest.raises(ValidationError, match="Input should be a valid string"):
-        Config(name=123)  # type: ignore[arg-type]
-
-
-# CLI Tests
-runner = CliRunner()
-
-
-def test_cli_hello_default() -> None:
-    """Test CLI hello command with default name."""
-    result = runner.invoke(app, ["hello"])
-    assert result.exit_code == 0
-    assert "Hello, World!" in result.output
-
-
-def test_cli_hello_custom_name() -> None:
-    """Test CLI hello command with custom name."""
-    result = runner.invoke(app, ["hello", "--name", "Alice"])
-    assert result.exit_code == 0
-    assert "Hello, Alice!" in result.output
-
-
-def test_cli_hello_short_option() -> None:
-    """Test CLI hello command with short option."""
-    result = runner.invoke(app, ["hello", "-n", "Bob"])
-    assert result.exit_code == 0
-    assert "Hello, Bob!" in result.output
-
-
-def test_cli_version() -> None:
-    """Test CLI --version flag."""
-    result = runner.invoke(app, ["--version"])
-    assert result.exit_code == 0
-    assert "python-package-template version:" in result.output
-
-
-def test_cli_version_short() -> None:
-    """Test CLI -V short flag."""
-    result = runner.invoke(app, ["-V"])
-    assert result.exit_code == 0
-    assert "python-package-template version:" in result.output
-
-
-def test_cli_hello_empty_name() -> None:
-    """Test CLI hello command with empty string name raises validation error."""
-    result = runner.invoke(app, ["hello", "--name", ""])
-    assert result.exit_code != 0
-
-
-def test_main_entry_point() -> None:
-    """Test that __main__.py can be imported and provides the app."""
-    from python_package_template import __main__
-
-    assert hasattr(__main__, "app")
diff --git a/tests/test_time_cop.py b/tests/test_time_cop.py
new file mode 100644
index 0000000..3240b88
--- /dev/null
+++ b/tests/test_time_cop.py
@@ -0,0 +1,532 @@
+"""Tests for the TimeCop module."""
+
+# ruff: noqa: E501 - CSV data lines exceed line length limit
+# mypy: ignore-errors
+# Pydantic validators handle str->datetime conversion at runtime
+
+import logging
+from datetime import datetime, timezone
+from pathlib import Path
+
+import pandas as pd
+import pytest
+from pydantic import ValidationError
+
+from timetracker_utils.time_cop import TimeCop, TimeEntry
+
+SAMPLE_CSV = """\
+"Date","Project","Description","Combined Project & Description","Start Time","End Time","Time (hours)","Notes"
+"1/15/2200","StellarCartography","nebula mapping","StellarCartography: nebula mapping","2200-01-15T09:00:00.000Z","2200-01-15T11:30:00.000Z","2.5",""
+"1/15/2200","Hydroponics","crop harvest","Hydroponics: crop harvest","2200-01-15T13:00:00.000Z","2200-01-15T14:45:00.000Z","1.75",""
+"1/15/2200","StellarCartography","","StellarCartography: ","2200-01-15T21:00:00.000Z","2200-01-15T22:30:00.000Z","1.5",""
+"1/16/2200","CrewFitness","strength training","CrewFitness: strength training","2200-01-16T06:00:00.000Z","2200-01-16T07:00:00.000Z","1.0",""
+"1/16/2200","Hydroponics","nutrient mix","Hydroponics: nutrient mix","2200-01-16T10:15:00.000Z","2200-01-16T11:45:00.000Z","1.5",""
+"1/16/2200","StellarCartography","course plotting","StellarCartography: course plotting","2200-01-16T20:30:00.000Z","2200-01-16T22:15:00.000Z","1.75",""
+"1/17/2200","WarpDrive","plasma calibration","WarpDrive: plasma calibration","2200-01-17T08:00:00.000Z","2200-01-17T12:30:00.000Z","4.5","critical test"
+"1/17/2200","Hydroponics","pH adjustment","Hydroponics: pH adjustment","2200-01-17T14:00:00.000Z","2200-01-17T15:30:00.000Z","1.5",""
+"1/17/2200","CrewFitness","cardiovascular","CrewFitness: cardiovascular","2200-01-17T17:00:00.000Z","2200-01-17T18:30:00.000Z","1.5",""
+"1/20/2200","WarpDrive","coil winding","WarpDrive: coil winding","2200-01-20T09:30:00.000Z","2200-01-20T13:30:00.000Z","4.0",""
+"1/20/2200","StellarCartography","asteroid tracking","StellarCartography: asteroid tracking","2200-01-20T15:00:00.000Z","2200-01-20T16:45:00.000Z","1.75",""
+"1/20/2200","CrewFitness","yoga session","CrewFitness: yoga session","2200-01-20T19:00:00.000Z","2200-01-20T20:00:00.000Z","1.0",""
+"""
+
+
+def test_time_entry_valid() -> None:
+    """Test creating a valid TimeEntry."""
+    entry = TimeEntry(
+        date="4/13/2026",
+        project="Commute",
+        description="drive",
+        combined="Commute: drive",
+        start_time="2026-04-13T10:45:00.000Z",
+        end_time="2026-04-13T11:45:39.074Z",
+        hours=1.0108,
+        notes="",
+    )
+    assert entry.date == "4/13/2026"
+    assert entry.project == "Commute"
+    assert entry.description == "drive"
+    assert entry.hours == 1.0108
+
+
+def test_time_entry_duration() -> None:
+    """Test duration calculation on TimeEntry."""
+    entry = TimeEntry(
+        date="4/13/2026",
+        project="Commute",
+        description="drive",
+        combined="Commute: drive",
+        start_time="2026-04-13T10:45:00.000Z",
+        end_time="2026-04-13T11:45:39.074Z",
+        hours=1.0108,
+        notes="",
+    )
+    # 1 hour = 3600 seconds, + 39 seconds + 0.074 seconds = 3639.074
+    expected_seconds = 3639.074
+    assert abs(entry.duration_seconds() - expected_seconds) < 0.001
+    expected_minutes = expected_seconds / 60.0
+    assert abs(entry.duration_minutes() - expected_minutes) < 0.001
+
+
+def test_time_entry_with_descriptions() -> None:
+    """Test that TimeEntry can handle empty description."""
+    entry = TimeEntry(
+        date="4/15/2026",
+        project="Commute",
+        description="",
+        combined="Commute: ",
+        start_time="2026-04-15T11:00:00.000Z",
+        end_time="2026-04-15T12:17:04.327Z",
+        hours=1.2844,
+        notes="",
+    )
+    assert entry.description == ""
+
+
+def test_time_entry_with_notes() -> None:
+    """Test that TimeEntry accepts notes."""
+    entry = TimeEntry(
+        date="4/20/2026",
+        project="Break",
+        description="lunch",
+        combined="Break: lunch",
+        start_time="2026-04-20T17:01:00.000Z",
+        end_time="2026-04-20T17:15:00.000Z",
+        hours=0.2333,
+        notes="short lunch",
+    )
+    assert entry.notes == "short lunch"
+
+
+def test_time_entry_alias_mapping() -> None:
+    """Test that TimeEntry can be created with CSV column names as aliases."""
+    entry = TimeEntry(
+        **{
+            "Date": "4/13/2026",
+            "Project": "Commute",
+            "Description": "drive",
+            "Combined Project & Description": "Commute: drive",
+            "Start Time": "2026-04-13T10:45:00.000Z",
+            "End Time": "2026-04-13T11:45:39.074Z",
+            "Time (hours)": 1.0108,
+            "Notes": "",
+        }
+    )
+    assert entry.date == "4/13/2026"
+    assert entry.project == "Commute"
+    assert entry.hours == 1.0108
+
+
+def test_time_entry_negative_hours() -> None:
+    """Test that negative hours raises validation error."""
+    with pytest.raises(ValidationError):
+        TimeEntry(
+            date="4/13/2026",
+            project="Commute",
+            description="drive",
+            combined="Commute: drive",
+            start_time="2026-04-13T10:45:00.000Z",
+            end_time="2026-04-13T11:45:39.074Z",
+            hours=-1.0,
+            notes="",
+        )
+
+
+def test_time_entry_hours_too_large() -> None:
+    """Test that hours > 24 raises validation error."""
+    with pytest.raises(ValidationError, match="Hours exceed 24"):
+        TimeEntry(
+            date="4/13/2026",
+            project="Commute",
+            description="drive",
+            combined="Commute: drive",
+            start_time="2026-04-13T10:45:00.000Z",
+            end_time="2026-04-13T11:45:39.074Z",
+            hours=25.0,
+            notes="",
+        )
+
+
+def test_time_entry_empty_project_defaults_to_empty_string() -> None:
+    """Test that empty project name defaults to empty string."""
+    entry = TimeEntry(
+        date="4/13/2026",
+        project="",
+        description="drive",
+        combined="Commute: drive",
+        start_time="2026-04-13T10:45:00.000Z",
+        end_time="2026-04-13T11:45:39.074Z",
+        hours=1.0,
+        notes="",
+    )
+    assert entry.project == ""
+
+
+def test_time_entry_with_datetime_object() -> None:
+    """Test that TimeEntry accepts an already-parsed datetime object."""
+    from datetime import datetime, timedelta, timezone
+
+    dt = datetime(2026, 4, 13, 10, 45, 0, tzinfo=timezone.utc)
+    later = dt + timedelta(hours=1)
+    entry = TimeEntry(
+        date="4/13/2026",
+        project="Commute",
+        description="drive",
+        combined="Commute: drive",
+        start_time=dt,
+        end_time=later,
+        hours=1.0,
+        notes="",
+    )
+    assert entry.start_time == dt
+    assert entry.end_time == later
+
+
+def test_time_entry_datetime_without_tz_converted_to_utc() -> None:
+    """Test that naive datetime is converted to UTC."""
+    entry = TimeEntry(
+        date="4/13/2026",
+        project="Commute",
+        description="drive",
+        combined="Commute: drive",
+        start_time="2026-04-13T10:45:00",
+        end_time="2026-04-13T11:45:39",
+        hours=1.0,
+        notes="",
+    )
+    assert entry.start_time.tzinfo is not None
+    assert entry.end_time.tzinfo is not None
+
+
+def test_time_entry_invalid_datetime() -> None:
+    """Test that invalid datetime string raises validation error."""
+    with pytest.raises(ValidationError, match="Invalid datetime"):
+        TimeEntry(
+            date="4/13/2026",
+            project="Commute",
+            description="drive",
+            combined="Commute: drive",
+            start_time="not-a-datetime",
+            end_time="2026-04-13T11:45:39.074Z",
+            hours=1.0,
+            notes="",
+        )
+
+
+# TimeCop Tests
+
+
+def test_timecop_read_csv_string() -> None:
+    """Test reading CSV string into TimeCop."""
+    cop = TimeCop()
+    entries = cop.read_csv_string(SAMPLE_CSV)
+    assert len(entries) == 12  # 12 data rows
+    assert isinstance(entries, pd.DataFrame)
+    assert entries.iloc[0]["project"] == "StellarCartography"
+    assert entries.iloc[0]["hours"] == 2.5
+
+
+def test_timecop_read_csv_string_empty_notes_default() -> None:
+    """Test that empty notes fields load as empty strings."""
+    cop = TimeCop()
+    entries = cop.read_csv_string(SAMPLE_CSV)
+    assert entries.iloc[0]["notes"] == ""
+
+
+def test_timecop_total_hours() -> None:
+    """Test total hours calculation."""
+    cop = TimeCop()
+    cop.read_csv_string(SAMPLE_CSV)
+    total = cop.total_hours()
+    # Sum of all hours from sample data: 24.25
+    assert abs(total - 24.25) < 0.001
+
+
+def test_timecop_total_hours_by_project() -> None:
+    """Test total hours grouped by project."""
+    cop = TimeCop()
+    cop.read_csv_string(SAMPLE_CSV)
+    by_project = cop.total_hours_by_project()
+    assert "StellarCartography" in by_project
+    assert "WarpDrive" in by_project
+    assert by_project["StellarCartography"] > 0
+    assert by_project["WarpDrive"] > 0
+
+
+def test_timecop_entries_by_project() -> None:
+    """Test filtering entries by project."""
+    cop = TimeCop()
+    cop.read_csv_string(SAMPLE_CSV)
+    cartography_entries = cop.entries_by_project("StellarCartography")
+    hydroponics_entries = cop.entries_by_project("Hydroponics")
+    assert len(cartography_entries) == 4
+    assert len(hydroponics_entries) == 3
+    assert all(cartography_entries["project"] == "StellarCartography")
+    assert all(hydroponics_entries["project"] == "Hydroponics")
+
+
+def test_timecop_entries_by_project_nonexistent() -> None:
+    """Test filtering by a project that doesn't exist."""
+    cop = TimeCop()
+    cop.read_csv_string(SAMPLE_CSV)
+    entries = cop.entries_by_project("Nonexistent")
+    assert entries.empty
+
+
+def test_timecop_entries_by_date() -> None:
+    """Test filtering entries by date."""
+    cop = TimeCop()
+    cop.read_csv_string(SAMPLE_CSV)
+    entries = cop.entries_by_date("1/15/2200")
+    assert len(entries) == 3
+    assert all(entries["date"] == "1/15/2200")
+
+
+def test_timecop_entries_by_date_nonexistent() -> None:
+    """Test filtering by a date that doesn't exist."""
+    cop = TimeCop()
+    cop.read_csv_string(SAMPLE_CSV)
+    entries = cop.entries_by_date("1/1/2000")
+    assert entries.empty
+
+
+def test_timecop_empty_csv(caplog: pytest.LogCaptureFixture) -> None:
+    """Test reading CSV with only headers returns empty DataFrame."""
+    caplog.set_level(logging.INFO)
+    cop = TimeCop()
+    header_only_csv = (
+        "Date,Project,Description,Combined Project & Description,"
+        "Start Time,End Time,Time (hours),Notes\n"
+    )
+    entries = cop.read_csv_string(header_only_csv)
+    assert entries.empty
+    assert "Loaded 0 time entries" in caplog.records[0].message
+
+
+def test_timecop_total_hours_when_empty() -> None:
+    """Test total_hours returns 0.0 when no entries loaded."""
+    cop = TimeCop()
+    assert cop.total_hours() == 0.0
+
+
+def test_timecop_total_hours_by_project_when_empty() -> None:
+    """Test total_hours_by_project returns empty dict when no entries loaded."""
+    cop = TimeCop()
+    assert cop.total_hours_by_project() == {}
+
+
+def test_timecop_entries_by_project_when_empty() -> None:
+    """Test entries_by_project returns empty DataFrame when no entries loaded."""
+    cop = TimeCop()
+    result = cop.entries_by_project("Any")
+    assert result.empty
+
+
+def test_timecop_entries_by_date_when_empty() -> None:
+    """Test entries_by_date returns empty DataFrame when no entries loaded."""
+    cop = TimeCop()
+    result = cop.entries_by_date("1/1/2000")
+    assert result.empty
+
+
+def test_timecop_read_csv_file(tmp_path: Path) -> None:
+    """Test reading CSV from a file path."""
+    csv_path = tmp_path / "test_entries.csv"
+    csv_path.write_text(SAMPLE_CSV, encoding="utf-8")
+    cop = TimeCop()
+    entries = cop.read_csv(str(csv_path))
+    assert len(entries) == 12  # 12 data rows
+
+
+def test_timecop_read_csv_file_not_found() -> None:
+    """Test reading CSV from a non-existent file raises FileNotFoundError."""
+    cop = TimeCop()
+    with pytest.raises(FileNotFoundError, match="CSV file not found"):
+        cop.read_csv("/nonexistent/path.csv")
+
+
+def test_timecop_read_csv_with_bom() -> None:
+    """Test reading CSV with BOM (byte order mark) strips it."""
+    cop = TimeCop()
+    bom_csv = "\ufeff" + SAMPLE_CSV
+    # When CSV has BOM, DictReader includes it in the first column name
+    # Strip BOM from the data before parsing
+    entries = cop.read_csv_string(bom_csv)
+    assert len(entries) >= 1
+
+
+def test_timecop_extra_columns_logged_as_warning(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test that extra columns in CSV are logged as a warning and ignored."""
+    caplog.set_level(logging.WARNING)
+    cop = TimeCop()
+    csv_with_extra = (
+        "Date,Project,Description,Combined Project & Description,"
+        "Start Time,End Time,Time (hours),Notes,Location\n"
+        '"4/13/2026","Commute","drive","Commute: drive",'
+        '"2026-04-13T10:45:00.000Z","2026-04-13T11:45:39.074Z",1.0,"","Home"\n'
+    )
+    entries = cop.read_csv_string(csv_with_extra)
+    assert len(entries) == 1
+    assert any("Extra columns" in record.message for record in caplog.records)
+    assert any("Location" in record.message for record in caplog.records)
+
+
+def test_timecop_csv_with_fewer_data_columns_backfills_end_time() -> None:
+    """Test that CSV data row with fewer columns backfills end_time from hours."""
+    cop = TimeCop()
+    csv_data = (
+        "Date,Project,Description,Combined Project & Description,"
+        "Start Time,End Time,Time (hours),Notes\n"
+        '"4/13/2026","Commute","drive","Commute: drive",'
+        '"2026-04-13T10:45:00.000Z","2026-04-13T11:45:00.000Z",,\n'
+    )
+    entries = cop.read_csv_string(csv_data)
+    assert len(entries) == 1
+    row = entries.iloc[0]
+    assert row["date"] == "4/13/2026"
+    assert row["project"] == "Commute"
+    assert row["start_time"] == datetime(2026, 4, 13, 10, 45, 0, tzinfo=timezone.utc)
+    assert row["end_time"] == datetime(2026, 4, 13, 11, 45, 0, tzinfo=timezone.utc)
+    assert row["hours"] == 1.0  # Backfilled from end_time - start_time
+    assert row["notes"] == ""  # Missing column defaults to ""
+
+
+def test_time_entry_date_auto_filled_from_start_time() -> None:
+    """Test that date is auto-filled from start_time when not provided."""
+    from datetime import datetime, timezone
+
+    entry = TimeEntry(
+        start_time="2026-04-13T10:45:00.000Z",
+        hours=1.0,
+    )
+    assert entry.date == "4/13/2026"
+    assert entry.start_time == datetime(2026, 4, 13, 10, 45, 0, tzinfo=timezone.utc)
+
+
+def test_time_entry_date_and_start_time_consistent() -> None:
+    """Test that consistent date and start_time passes validation."""
+    entry = TimeEntry(
+        date="4/13/2026",
+        start_time="2026-04-13T10:45:00.000Z",
+        hours=1.0,
+    )
+    assert entry.date == "4/13/2026"
+
+
+def test_time_entry_date_and_start_time_inconsistent() -> None:
+    """Test that inconsistent date and start_time raises an error."""
+    with pytest.raises(ValidationError, match="does not match"):
+        TimeEntry(
+            date="4/14/2026",
+            start_time="2026-04-13T10:45:00.000Z",
+            hours=1.0,
+        )
+
+
+def test_time_entry_start_time_is_required() -> None:
+    """Test that start_time is required."""
+    with pytest.raises(ValidationError, match="Field required"):
+        TimeEntry()
+
+
+def test_time_entry_backfills_hours_from_end_time() -> None:
+    """Test that hours is backfilled from end_time when only end_time is provided."""
+    from datetime import datetime, timezone
+
+    entry = TimeEntry(
+        start_time="2026-04-13T10:45:00.000Z",
+        end_time="2026-04-13T11:45:00.000Z",
+    )
+    assert entry.project == ""
+    assert entry.description == ""
+    assert entry.combined == ""
+    assert entry.end_time == datetime(2026, 4, 13, 11, 45, 0, tzinfo=timezone.utc)
+    assert entry.hours == 1.0  # Backfilled from end_time - start_time
+    assert entry.notes == ""
+    assert entry.duration_seconds() == 3600.0
+
+
+def test_time_entry_backfills_end_time_from_hours() -> None:
+    """Test that end_time is backfilled from hours when only hours is provided."""
+    from datetime import datetime, timezone
+
+    entry = TimeEntry(
+        start_time="2026-04-13T10:45:00.000Z",
+        hours=1.0,
+    )
+    assert entry.end_time == datetime(2026, 4, 13, 11, 45, 0, tzinfo=timezone.utc)
+    assert entry.hours == 1.0
+    assert entry.duration_seconds() == 3600.0
+
+
+def test_time_entry_neither_end_time_nor_hours_raises() -> None:
+    """Test that providing neither end_time nor hours raises an error."""
+    with pytest.raises(ValidationError, match="At least one of"):
+        TimeEntry(start_time="2026-04-13T10:45:00.000Z")
+
+
+def test_time_entry_inconsistent_end_time_and_hours_raises() -> None:
+    """Test that inconsistent end_time and hours raises an error."""
+    with pytest.raises(ValidationError, match="does not match duration"):
+        TimeEntry(
+            start_time="2026-04-13T10:45:00.000Z",
+            end_time="2026-04-13T11:45:00.000Z",
+            hours=2.0,
+        )
+
+
+def test_time_entry_duration_with_missing_end_time_returns_none() -> None:
+    """Test that duration methods return None when end_time is not set."""
+    entry = TimeEntry(start_time="2026-04-13T10:45:00.000Z", hours=1.0)
+    # After backfill, end_time is always set. This tests the guard branch
+    # by deliberately constructing via __init__ and checking manually.
+    entry.end_time = None  # Force None for coverage
+    assert entry.duration_seconds() is None
+    assert entry.duration_minutes() is None
+
+
+def test_timecop_csv_with_none_values_from_dictreader() -> None:
+    """Test that None values from DictReader (missing trailing columns) are handled."""
+    cop = TimeCop()
+    csv_data = (
+        "Start Time,End Time,Time (hours),Notes\n"
+        '"2026-04-13T10:45:00.000Z","2026-04-13T11:45:00.000Z"'
+    )
+    entries = cop.read_csv_string(csv_data)
+    assert len(entries) == 1
+    row = entries.iloc[0]
+    assert row["hours"] == 1.0  # Backfilled from end_time
+    assert row["notes"] == ""  # None coerced to ""
+
+
+def test_timecop_csv_missing_end_time_backfills_end_time_from_hours() -> None:
+    """Test that when End Time column is missing, hours backfills end_time."""
+    cop = TimeCop()
+    csv_data = 'Start Time,Time (hours),Notes\n"2026-04-13T10:45:00.000Z",1.0,"testing"'
+    entries = cop.read_csv_string(csv_data)
+    assert len(entries) == 1
+    row = entries.iloc[0]
+    assert row["hours"] == 1.0
+    assert row["notes"] == "testing"
+
+
+def test_timecop_csv_end_time_none_backfills_hours() -> None:
+    """Test that None End Time with hours backfills end_time."""
+    cop = TimeCop()
+    csv_data = 'Start Time,End Time,Time (hours)\n"2026-04-13T10:45:00.000Z",,1.0'
+    entries = cop.read_csv_string(csv_data)
+    assert len(entries) == 1
+    row = entries.iloc[0]
+    # End Time is None from empty cell, hours is 1.0 -> backfill end_time
+    assert row["hours"] == 1.0
+    assert row["end_time"] is not None
+
+
+def test_parse_datetime_validator_with_none() -> None:
+    """Test that parse_datetime returns None directly when passed None."""
+    from timetracker_utils.time_cop import TimeEntry
+
+    result = TimeEntry.parse_datetime(None)
+    assert result is None
diff --git a/tests/timetracker.yml b/tests/timetracker.yml
new file mode 100644
index 0000000..a4ac867
--- /dev/null
+++ b/tests/timetracker.yml
@@ -0,0 +1,3 @@
+database: ~/data/timetracker/db.sqlite3
+timezone: ET
+
diff --git a/timetracker_utils/__init__.py b/timetracker_utils/__init__.py
new file mode 100644
index 0000000..843095c
--- /dev/null
+++ b/timetracker_utils/__init__.py
@@ -0,0 +1,9 @@
+"""Time tracker utilities.
+
+Provides CSV time tracking data parsing and validation via TimeCop.
+"""
+
+from timetracker_utils.time_cop import TimeCop, TimeEntry
+
+__version__ = "0.1.1"
+__all__ = ["TimeCop", "TimeEntry"]
diff --git a/timetracker_utils/__main__.py b/timetracker_utils/__main__.py
new file mode 100644
index 0000000..a88cf8a
--- /dev/null
+++ b/timetracker_utils/__main__.py
@@ -0,0 +1,6 @@
+"""Main entry point for python -m timetracker_utils."""
+
+from timetracker_utils.cli import app
+
+if __name__ == "__main__":
+    app()
diff --git a/timetracker_utils/cli.py b/timetracker_utils/cli.py
new file mode 100644
index 0000000..4ddbb8d
--- /dev/null
+++ b/timetracker_utils/cli.py
@@ -0,0 +1,274 @@
+"""Command line interface module.
+
+Provides a typer-based CLI for the package. Currently a dummy entrypoint
+that references the TimeCop class.
+"""
+
+import csv
+import logging
+from datetime import datetime, timezone
+from pathlib import Path
+
+import pandas as pd
+import typer
+
+from timetracker_utils import __version__
+from timetracker_utils.config import load_config
+from timetracker_utils.database import Database
+from timetracker_utils.datetime_utils import convert_column_tz
+from timetracker_utils.time_cop import TimeCop
+
+app = typer.Typer(help="Time tracker utilities CLI")
+
+logger = logging.getLogger(__name__)
+
+
+def version_callback(value: bool) -> None:
+    """Handle the version flag callback."""
+    if value:
+        typer.echo(f"timetracker-utils version: {__version__}")
+        raise typer.Exit()
+    return None
+
+
+@app.callback()
+def main(
+    _version: bool | None = typer.Option(
+        None,
+        "--version",
+        "-V",
+        callback=version_callback,
+        is_eager=True,
+        help="Show the version and exit.",
+    ),
+) -> None:
+    """Time tracker utilities CLI."""
+    # Reference TimeCop to ensure the class is importable
+    _ = TimeCop
+
+
+def _format_timecop_csv(entries: pd.DataFrame, output_path: Path) -> None:
+    """Write entries DataFrame to a timecop-format CSV file.
+
+    Reconstructs the combined project/description column and computes
+    hours from start/end time deltas to match the expected timecop CSV
+    input format.
+
+    Args:
+        entries: DataFrame of database entries (columns: date, project,
+            description, start_time, end_time, notes).
+        output_path: Path to write the CSV file.
+
+    """
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Shared header row for timecop CSV format
+    header = [
+        "Date",
+        "Project",
+        "Description",
+        "Combined Project & Description",
+        "Start Time",
+        "End Time",
+        "Time (hours)",
+        "Notes",
+    ]
+
+    if entries.empty:
+        with output_path.open("w", newline="", encoding="utf-8") as f:
+            writer = csv.writer(f, quoting=csv.QUOTE_ALL)
+            writer.writerow(header)
+        return
+
+    with output_path.open("w", newline="", encoding="utf-8") as f:
+        writer = csv.writer(f, quoting=csv.QUOTE_ALL)
+        writer.writerow(header)
+
+        for _, row in entries.iterrows():
+            date = str(row.get("date", ""))
+            project = str(row.get("project", ""))
+            description = str(row.get("description", ""))
+            combined = f"{project}: {description}"
+            start_time = row.get("start_time")
+            end_time = row.get("end_time")
+            notes = str(row.get("notes", ""))
+
+            # Format datetimes to ISO 8601 UTC with millisecond precision
+            start_str = _format_datetime_iso(start_time)
+            end_str = _format_datetime_iso(end_time)
+
+            # Compute hours from start/end time
+            hours_str = _compute_hours(start_time, end_time)
+
+            writer.writerow(
+                [
+                    date,
+                    project,
+                    description,
+                    combined,
+                    start_str,
+                    end_str,
+                    hours_str,
+                    notes,
+                ]
+            )
+
+
+def _format_datetime_iso(val: object) -> str:
+    """Format a datetime value as an ISO 8601 UTC string with millisecond precision.
+
+    Args:
+        val: A datetime object, string, or None.
+
+    Returns:
+        An ISO 8601 string in the format ``YYYY-MM-DDTHH:MM:SS.000Z``,
+        or an empty string if the value is missing.
+
+    """
+    if val is None or (isinstance(val, str) and val.strip() == ""):
+        return ""
+    if isinstance(val, str):
+        # Parse the string to get a datetime, then re-format consistently
+        try:
+            dt = datetime.fromisoformat(val.replace("Z", "+00:00"))
+        except (ValueError, TypeError):
+            return val
+    elif isinstance(val, datetime):
+        dt = val
+    else:
+        return str(val)
+
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    else:
+        dt = dt.astimezone(timezone.utc)
+    # Format with millisecond precision and Z suffix
+    return dt.strftime("%Y-%m-%dT%H:%M:%S.") + f"{dt.microsecond // 1000:03d}Z"
+
+
+def _compute_hours(start_time: object, end_time: object) -> str:
+    """Compute hours from start and end time.
+
+    Args:
+        start_time: Start time (datetime, string, or None).
+        end_time: End time (datetime, string, or None).
+
+    Returns:
+        A string representation of the hours, rounded to 4 decimal
+        places, or an empty string if the times are not available.
+
+    """
+    if start_time is None or end_time is None:
+        return ""
+    if isinstance(start_time, str) and start_time.strip() == "":
+        return ""
+    if isinstance(end_time, str) and end_time.strip() == "":
+        return ""
+
+    try:
+        if isinstance(start_time, str):
+            start_dt = datetime.fromisoformat(start_time.replace("Z", "+00:00"))
+        elif isinstance(start_time, datetime):
+            start_dt = start_time
+        else:
+            return ""
+
+        if isinstance(end_time, str):
+            end_dt = datetime.fromisoformat(end_time.replace("Z", "+00:00"))
+        elif isinstance(end_time, datetime):
+            end_dt = end_time
+        else:
+            return ""
+
+        delta = end_dt - start_dt
+        hours = delta.total_seconds() / 3600.0
+        return f"{hours:.4f}"
+    except (ValueError, TypeError):
+        return ""
+
+
+@app.command()
+def timecop(
+    config: Path = typer.Option(
+        ...,
+        "--config",
+        "-c",
+        help="Path to the YAML configuration file.",
+    ),
+    input: Path = typer.Option(
+        None,  # type: ignore[arg-type]
+        "--input",
+        "-i",
+        help="Path to the CSV file to load.",
+    ),
+    head: int = typer.Option(
+        100,
+        "--head",
+        "-h",
+        help="Number of rows to display from the top of the DataFrame.",
+    ),
+    output: Path = typer.Option(
+        None,  # type: ignore[arg-type]
+        "--output",
+        "-o",
+        help="Path to write the entire database in timecop CSV format.",
+    ),
+) -> None:
+    """Load a CSV time tracking file, write to database, and/or export the database.
+
+    If --input is provided, loads the CSV file, writes entries to the database,
+    and displays the DataFrame. If --output is provided, exports the entire
+    database to a timecop-format CSV file. Both can be used together.
+    """
+    logging.basicConfig(level=logging.INFO, format="%(message)s")
+    cfg = load_config(config)
+
+    if input is not None:
+        cop = TimeCop()
+        cop.read_csv(input)
+        db = Database()
+        db.write(
+            cop.entries, cfg.database, max_conflict_display=cfg.max_conflict_display
+        )
+        typer.echo(f"Loaded DataFrame ({len(cop.entries)} rows total):")
+
+        # Apply timezone conversion to timestamp columns before display
+        display_df = cop.entries.copy()
+        if not display_df.empty and "start_time" in display_df.columns:
+            display_df["start_time"] = convert_column_tz(
+                display_df["start_time"], cfg.timezone
+            )
+        if not display_df.empty and "end_time" in display_df.columns:
+            display_df["end_time"] = convert_column_tz(
+                display_df["end_time"], cfg.timezone
+            )
+        with pd.option_context(
+            "display.max_columns",
+            None,
+            "display.max_colwidth",
+            None,
+            "display.width",
+            None,
+        ):
+            typer.echo(str(display_df.head(head)))
+
+    if output is not None:
+        db = Database()
+        db_entries = db.read(cfg.database)
+        if db_entries.empty:
+            typer.echo("Database is empty, writing header-only CSV.")
+        else:
+            typer.echo(f"Exporting {len(db_entries)} entries to {output}")
+        _format_timecop_csv(db_entries, output)
+
+    if input is None and output is None:
+        typer.echo(
+            "No --input or --output specified. Use --input to load a CSV, "
+            "--output to export the database, or both.",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+
+if __name__ == "__main__":
+    app()
diff --git a/timetracker_utils/config.py b/timetracker_utils/config.py
new file mode 100644
index 0000000..af9de1d
--- /dev/null
+++ b/timetracker_utils/config.py
@@ -0,0 +1,82 @@
+"""Configuration module.
+
+Provides a Pydantic v2 model for loading application configuration from YAML files.
+"""
+
+import logging
+from pathlib import Path
+
+import yaml
+from pydantic import BaseModel, Field, field_validator
+
+logger = logging.getLogger(__name__)
+
+
+class TimeTrackerConfig(BaseModel):
+    """Pydantic v2 model for the timetracker configuration file.
+
+    Attributes:
+        database: Path to the SQLite database file.
+
+        timezone: Default timezone for timestamp conversions (e.g. ET, PT, UTC).
+
+        max_conflict_display: Maximum number of conflicting entries to display
+            when a merge conflict is detected (default 100).
+
+    """
+
+    database: str = Field(
+        ...,
+        description="Path to the SQLite database file.",
+    )
+    timezone: str = Field(
+        ...,
+        description="Default timezone for timestamp conversions (e.g. ET, PT, UTC).",
+    )
+    max_conflict_display: int = Field(
+        default=100,
+        description=(
+            "Maximum number of conflicting entries to display on merge conflict."
+        ),
+        ge=0,
+    )
+
+    @field_validator("database", mode="before")
+    @classmethod
+    def expand_user_in_path(cls, value: str) -> str:
+        """Expand a leading ``~`` in the database path to the user's home directory.
+
+        Args:
+            value: The raw database path string from the config file.
+
+        Returns:
+            The path string with ``~`` expanded, if present.
+
+        """
+        return str(Path(value).expanduser())
+
+
+def load_config(config_path: Path) -> TimeTrackerConfig:
+    """Load configuration from a YAML file.
+
+    Args:
+        config_path: Path to the YAML configuration file.
+
+    Returns:
+        A validated TimeTrackerConfig instance.
+
+    Raises:
+        FileNotFoundError: If the configuration file does not exist.
+
+        ValueError: If the configuration file is invalid.
+
+    """
+    if not config_path.exists():
+        msg = f"Configuration file not found: {config_path}"
+        raise FileNotFoundError(msg)
+
+    with config_path.open(encoding="utf-8") as f:
+        raw = yaml.safe_load(f)
+
+    logger.info("Loaded configuration from %s", config_path)
+    return TimeTrackerConfig(**raw)
diff --git a/timetracker_utils/database.py b/timetracker_utils/database.py
new file mode 100644
index 0000000..98d0e42
--- /dev/null
+++ b/timetracker_utils/database.py
@@ -0,0 +1,550 @@
+"""Database module.
+
+Provides a Pydantic model for activity entries and a ``Database``
+class that writes validated entries to a SQLite database with
+merge semantics.
+"""
+
+import logging
+import sqlite3
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+from pydantic import BaseModel, Field
+
+logger = logging.getLogger(__name__)
+
+# Columns that are computed at runtime and not persisted to the database
+_DROP_COLUMNS = {"combined", "hours"}
+
+# Columns that form the merge key (identifying a unique activity)
+_MERGE_KEY_COLUMNS = ["start_time", "end_time", "project", "description"]
+
+# Columns that can be silently filled in (merged) when the old value is blank
+_MERGEABLE_COLUMNS = ["date", "notes"]
+
+
+class ActivityEntry(BaseModel):
+    """A single activity entry suitable for database persistence.
+
+    Omits computed columns (``combined``, ``hours``) that are derived
+    at import time from the original CSV data.
+
+    Attributes:
+        date: The date of the activity (e.g. "4/13/2026").
+        project: The project or category name.
+        description: A short description of the activity.
+        start_time: The start timestamp in ISO 8601 format.
+        end_time: The end timestamp in ISO 8601 format.
+        notes: Optional notes about the activity.
+
+    """
+
+    date: str = Field(default="", description="The date of the activity")
+    project: str = Field(default="", description="The project or category name")
+    description: str = Field(
+        default="", description="Short description of the activity"
+    )
+    start_time: datetime = Field(..., description="Start timestamp in ISO 8601 format")
+    end_time: datetime | None = Field(
+        default=None, description="End timestamp in ISO 8601 format"
+    )
+    notes: str = Field(default="", description="Optional notes about the activity")
+
+
+def _is_blank(value: Any) -> bool:
+    """Check whether a value is considered blank (empty string or None).
+
+    Args:
+        value: The value to check.
+
+    Returns:
+        True if the value is None or an empty string.
+
+    """
+    return value is None or (isinstance(value, str) and value.strip() == "")
+
+
+def _format_row_for_display(row: dict[str, Any]) -> str:
+    """Format a row dictionary into a human-readable string for conflict output.
+
+    Args:
+        row: A dictionary of column values.
+
+    Returns:
+        A formatted string representation.
+
+    """
+    parts = []
+    for col in ["date", "project", "description", "start_time", "end_time", "notes"]:
+        val = row.get(col, "")
+        parts.append(f"{col}={val!r}")
+    return "  " + ", ".join(parts)
+
+
+class MergeConflictError(Exception):
+    """Raised when a merge conflict is detected during database write."""
+
+    def __init__(self, message: str, conflicts: list[dict[str, Any]]) -> None:
+        """Initialize the exception.
+
+        Args:
+            message: A human-readable error message.
+            conflicts: A list of conflicting row dictionaries (old entries).
+
+        """
+        super().__init__(message)
+        self.conflicts = conflicts
+
+
+class Database:
+    """Handles persistence of activity entries to a SQLite database.
+
+    Supports merging new entries into an existing database rather than
+    overwriting it entirely.
+
+    Attributes:
+        entries: A pandas DataFrame of database-ready activity entries.
+
+    """
+
+    def __init__(self) -> None:
+        """Initialize an empty Database instance."""
+        self.entries: pd.DataFrame = pd.DataFrame()
+
+    def write(
+        self,
+        df: pd.DataFrame,
+        db_path: str | Path,
+        max_conflict_display: int = 100,
+    ) -> None:
+        """Write a DataFrame to the SQLite database, merging with existing data.
+
+        Merge rules:
+
+        1. **Duplicate row:** If an incoming row is identical to an existing
+           row (all columns match), it is silently dropped.
+
+        2. **Blank-fill merge:** If an incoming row has the same key
+           (``start_time``, ``end_time``, ``project``, ``description``) as
+           an existing row, and the existing row has blank values (empty
+           string or ``None``) in the mergeable columns (``date``, ``notes``)
+           where the incoming row has non-blank values, the existing row is
+           updated with the incoming values.
+
+        3. **Conflict:** If an incoming row has the same key as an existing
+           row, but the existing row has non-blank values that differ from
+           the incoming values in a mergeable column, a
+           :class:`MergeConflictError` is raised. The error message lists up
+           to *max_conflict_display* conflicting entries.
+
+        Drops computed columns (``combined``, ``hours``), validates each row
+        through :class:`ActivityEntry`, and persists to an ``activities`` table.
+
+        Args:
+            df: The source DataFrame (typically from TimeCop).
+            db_path: Path to the SQLite database file.
+            max_conflict_display: Maximum number of conflicting entries to
+                display in the error message (default 100). A value of 0
+                suppresses the conflict list.
+
+        Raises:
+            MergeConflictError: If unresolvable merge conflicts are detected.
+
+        """
+        db = Path(db_path)
+        db.parent.mkdir(parents=True, exist_ok=True)
+
+        # Drop computed columns not needed in the database
+        cols_to_drop = _DROP_COLUMNS & set(df.columns)
+        if cols_to_drop:
+            df = df.drop(columns=list(cols_to_drop))
+
+        # Validate each row through ActivityEntry
+        validated = []
+        for _, row in df.iterrows():
+            validated.append(
+                ActivityEntry(**row.to_dict())  # type: ignore[arg-type]
+            )
+
+        if validated:
+            incoming_df = pd.DataFrame([entry.model_dump() for entry in validated])
+        else:
+            incoming_df = pd.DataFrame()
+
+        # Normalise column types for consistent comparison
+        incoming_df = self._normalise_dataframe(incoming_df)
+
+        conn = sqlite3.connect(str(db))
+        try:
+            existing_df = self._read_existing(conn)
+            existing_df = self._normalise_dataframe(existing_df)
+
+            if existing_df.empty:
+                # No existing data — just write the incoming data
+                merged_df = incoming_df
+                new_count = len(incoming_df)
+                skipped_count = 0
+                updated_count = 0
+            else:
+                merged_df, new_count, skipped_count, updated_count = (
+                    self._merge_dataframes(
+                        existing_df, incoming_df, max_conflict_display
+                    )
+                )
+
+            # Write the merged result
+            if merged_df.empty:
+                conn.execute("DROP TABLE IF EXISTS activities")
+                conn.execute(
+                    "CREATE TABLE activities ("
+                    "date TEXT, project TEXT, description TEXT, "
+                    "start_time TEXT, end_time TEXT, notes TEXT)"
+                )
+            else:
+                merged_df.to_sql("activities", conn, if_exists="replace", index=False)
+
+            self.entries = merged_df
+            written_count = new_count + updated_count
+            logger.info(
+                "Wrote %d entries to database %s (%d new, %d updated, %d skipped)",
+                written_count,
+                db,
+                new_count,
+                updated_count,
+                skipped_count,
+            )
+        finally:
+            conn.close()
+
+    def read(self, db_path: str | Path) -> pd.DataFrame:
+        """Read all entries from the database.
+
+        Args:
+            db_path: Path to the SQLite database file.
+
+        Returns:
+            A DataFrame of all entries in the database, or an empty
+            DataFrame if the table does not exist or has no data.
+
+        """
+        db = Path(db_path)
+        if not db.exists():
+            logger.info("Database %s does not exist, returning empty DataFrame", db)
+            self.entries = pd.DataFrame()
+            return self.entries
+
+        conn = sqlite3.connect(str(db))
+        try:
+            result = self._read_existing(conn)
+            self.entries = result
+            logger.info("Read %d entries from database %s", len(result), db)
+            return result
+        finally:
+            conn.close()
+
+    @staticmethod
+    def _normalise_dataframe(df: pd.DataFrame) -> pd.DataFrame:
+        """Normalise column types for consistent comparison.
+
+        Converts datetime columns to string representations and fills
+        missing values with empty strings.
+
+        Args:
+            df: The DataFrame to normalise.
+
+        Returns:
+            A normalised DataFrame with consistent types.
+
+        """
+        if df.empty:
+            return df
+
+        df = df.copy()
+
+        # Convert datetime columns to ISO string for consistent comparison
+        for col in ["start_time", "end_time"]:
+            if col in df.columns and pd.api.types.is_datetime64_any_dtype(df[col]):
+                df[col] = df[col].apply(
+                    lambda x: x.isoformat() if pd.notna(x) else None
+                )
+
+        # Ensure all expected columns exist
+        expected_cols = [
+            "date",
+            "project",
+            "description",
+            "start_time",
+            "end_time",
+            "notes",
+        ]
+        for col in expected_cols:
+            if col not in df.columns:
+                df[col] = "" if col != "end_time" else None
+
+        return df
+
+    @staticmethod
+    def _read_existing(conn: sqlite3.Connection) -> pd.DataFrame:
+        """Read existing data from the activities table.
+
+        Args:
+            conn: An open SQLite connection.
+
+        Returns:
+            A DataFrame of existing entries, or an empty DataFrame if the
+            table does not exist or has no data.
+
+        """
+        try:
+            result_df = pd.read_sql_query(
+                "SELECT date, project, description, start_time, end_time, notes "
+                "FROM activities",
+                conn,
+            )
+            return result_df
+        except pd.errors.DatabaseError:
+            return pd.DataFrame()
+
+    @staticmethod
+    def _merge_dataframes(
+        existing: pd.DataFrame,
+        incoming: pd.DataFrame,
+        max_conflict_display: int,
+    ) -> tuple[pd.DataFrame, int, int, int]:
+        """Merge an incoming DataFrame into an existing DataFrame.
+
+        Args:
+            existing: The existing data from the database.
+            incoming: The new data to merge in.
+            max_conflict_display: Maximum number of conflicts to list.
+
+        Returns:
+            A tuple of (merged DataFrame, new rows count, updated rows count,
+            skipped (identical) rows count).
+
+        Raises:
+            MergeConflictError: If unresolvable conflicts are detected.
+
+        """
+        if incoming.empty:
+            return existing, 0, 0, 0
+
+        # Build a key column for matching
+        def _make_key(row: pd.Series) -> str:
+            parts = []
+            for col in _MERGE_KEY_COLUMNS:
+                val = row.get(col)
+                if pd.isna(val):
+                    parts.append("")
+                else:
+                    parts.append(str(val))
+            return "|".join(parts)
+
+        existing = existing.reset_index(drop=True)
+        incoming = incoming.reset_index(drop=True)
+
+        existing["_merge_key"] = existing.apply(_make_key, axis=1)
+        incoming["_merge_key"] = incoming.apply(_make_key, axis=1)
+
+        # Separate incoming rows into: new, identical, blank-fill, conflict
+        new_rows: list[pd.DataFrame] = []
+        conflicts: list[dict[str, Any]] = []
+        new_count = 0
+        skipped_count = 0
+        updated_count = 0
+
+        for inc_idx, inc_row in incoming.iterrows():
+            inc_key = inc_row["_merge_key"]
+
+            # Find matching existing row(s)
+            match_mask = existing["_merge_key"] == inc_key
+            match_indices = existing.index[match_mask].tolist()
+
+            if not match_indices:
+                # No match — this is a new row
+                new_rows.append(
+                    incoming.iloc[[inc_idx]].drop(columns=["_merge_key"])  # type: ignore[index]
+                )
+                new_count += 1
+                continue
+
+            # There could be multiple matches; handle each independently
+            # (though in practice the key should be unique)
+            resolved = False
+            for match_idx in match_indices:
+                old_row = existing.loc[match_idx]
+
+                # Check if identical
+                if Database._rows_identical(old_row, inc_row, include_key=False):
+                    # Rule 1: silently drop the incoming row
+                    # Keep the existing row as-is
+                    skipped_count += 1
+                    resolved = True
+                    break
+
+                # Check if this is a blank-fill merge (Rule 2)
+                if Database._is_blank_fill(old_row, inc_row):
+                    # Rule 2: replace old with new data
+                    for col in _MERGEABLE_COLUMNS:
+                        new_val = inc_row.get(col)
+                        if not _is_blank(new_val):
+                            existing.at[match_idx, col] = new_val
+                    updated_count += 1
+                    resolved = True
+                    break
+
+                # Check for conflict (Rule 3)
+                if Database._is_conflict(old_row, inc_row):
+                    # Record the conflict using the old row data
+                    conflict_row = {
+                        col: old_row.get(col, "") for col in _MERGEABLE_COLUMNS
+                    }
+                    for col in _MERGE_KEY_COLUMNS:
+                        conflict_row[col] = old_row.get(col, "")
+                    conflicts.append(conflict_row)
+                    resolved = True
+                    break
+
+            if not resolved:
+                # No matching logic applied — treat as new row (shouldn't happen)
+                logger.warning(
+                    "Unresolved merge for row with key %s — treating as new",
+                    inc_key,
+                )
+                new_rows.append(
+                    incoming.iloc[[inc_idx]].drop(columns=["_merge_key"])  # type: ignore[index]
+                )
+
+        if conflicts:
+            # Use a set to deduplicate by the merge key
+            seen_keys: set[str] = set()
+            unique_conflicts: list[dict[str, Any]] = []
+            for c in conflicts:
+                key = "|".join(str(c.get(col, "")) for col in _MERGE_KEY_COLUMNS)
+                if key not in seen_keys:
+                    seen_keys.add(key)
+                    unique_conflicts.append(c)
+
+            display_conflicts = (
+                unique_conflicts[:max_conflict_display]
+                if max_conflict_display > 0
+                else []
+            )
+            total_conflicts = len(unique_conflicts)
+            conflict_msgs = []
+            for c in display_conflicts:
+                conflict_msgs.append(_format_row_for_display(c))
+            conflict_detail = "\n".join(conflict_msgs)
+            if total_conflicts > max_conflict_display > 0:
+                remaining = total_conflicts - max_conflict_display
+                conflict_detail += f"\n  ... and {remaining} more conflicts."
+
+            suffix = "y" if total_conflicts == 1 else "ies"
+            prefix = "y has" if total_conflicts == 1 else "ies have"
+            msg = (
+                f"Merge conflict detected for {total_conflicts} entr{suffix}. "
+                f"The following entr{prefix} the same "
+                "start_time, end_time, project, and description "
+                f"but conflicting non-blank values:\n"
+                f"{conflict_detail}"
+            )
+            raise MergeConflictError(msg, unique_conflicts)
+
+        # Build the result: existing rows + new rows
+        result = existing.drop(columns=["_merge_key"])
+        if new_rows:
+            new_concat = pd.concat(new_rows, ignore_index=True)
+            result = pd.concat([result, new_concat], ignore_index=True)
+
+        # Ensure we return a DataFrame (mypy: drop() returns DataFrame)
+        return result, new_count, skipped_count, updated_count  # type: ignore[no-any-return]
+
+    @staticmethod
+    def _rows_identical(
+        row_a: pd.Series,
+        row_b: pd.Series,
+        include_key: bool = True,
+    ) -> bool:
+        """Check if two rows are identical across all columns.
+
+        Args:
+            row_a: First row to compare.
+            row_b: Second row to compare.
+            include_key: If True, also compare key columns.
+
+        Returns:
+            True if the rows are identical.
+
+        """
+        cols = _MERGEABLE_COLUMNS + (_MERGE_KEY_COLUMNS if include_key else [])
+        for col in cols:
+            val_a = row_a.get(col)
+            val_b = row_b.get(col)
+            # Normalise NaN/None to the same representation
+            if pd.isna(val_a) and pd.isna(val_b):
+                continue
+            if val_a != val_b:
+                return False
+        return True
+
+    @staticmethod
+    def _is_blank_fill(old_row: pd.Series, new_row: pd.Series) -> bool:
+        """Check if a new row is a valid blank-fill merge of an old row.
+
+        The key columns must match (caller ensures this), and for each
+        mergeable column, the old value must be blank when the new value
+        is non-blank. If the old value is non-blank and differs from the
+        new value, this is not a blank-fill.
+
+        Args:
+            old_row: The existing row from the database.
+            new_row: The incoming row.
+
+        Returns:
+            True if the new row can be merged via blank-fill.
+
+        """
+        for col in _MERGEABLE_COLUMNS:
+            old_val = old_row.get(col)
+            new_val = new_row.get(col)
+            if _is_blank(old_val):
+                # Old is blank — new can fill it (even if new is also blank)
+                continue
+            # Old is non-blank
+            if pd.isna(new_val) or _is_blank(new_val):
+                # New is blank — old stays, this is not a blank-fill
+                return False
+            if str(old_val) != str(new_val):
+                # Both non-blank and different — not a blank-fill
+                return False
+        # All mergeable columns either matched or were blank-fillable
+        return True
+
+    @staticmethod
+    def _is_conflict(old_row: pd.Series, new_row: pd.Series) -> bool:
+        """Check if a new row conflicts with an old row.
+
+        A conflict occurs when the key columns match (caller ensures this)
+        and at least one mergeable column has non-blank values that differ.
+
+        Args:
+            old_row: The existing row from the database.
+            new_row: The incoming row.
+
+        Returns:
+            True if there is a conflict.
+
+        """
+        for col in _MERGEABLE_COLUMNS:
+            old_val = old_row.get(col)
+            new_val = new_row.get(col)
+            if _is_blank(old_val) or _is_blank(new_val):
+                # At least one is blank — no conflict possible
+                continue
+            if str(old_val) != str(new_val):
+                # Both non-blank and different — conflict!
+                return True
+        return False
diff --git a/timetracker_utils/datetime_utils.py b/timetracker_utils/datetime_utils.py
new file mode 100644
index 0000000..b861b35
--- /dev/null
+++ b/timetracker_utils/datetime_utils.py
@@ -0,0 +1,116 @@
+"""Datetime utilities module.
+
+Provides functions for converting pandas timestamp columns
+between timezones using familiar abbreviations.
+"""
+
+import logging
+from typing import TYPE_CHECKING
+from zoneinfo import ZoneInfo, available_timezones
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+# Mapping from common timezone abbreviations to IANA timezone names.
+# Uses zoneinfo from the standard library for reliable tz resolution.
+_TZ_ABBREV: dict[str, str] = {
+    "ET": "America/New_York",
+    "CT": "America/Chicago",
+    "MT": "America/Denver",
+    "PT": "America/Los_Angeles",
+    "AT": "America/Anchorage",
+    "HT": "Pacific/Honolulu",
+    "UTC": "UTC",
+    "GMT": "Europe/London",
+    "CET": "Europe/Berlin",
+    "IST": "Asia/Kolkata",
+    "JST": "Asia/Tokyo",
+    "AEST": "Australia/Sydney",
+    "NZST": "Pacific/Auckland",
+}
+
+
+def resolve_tz(tz: str) -> ZoneInfo | None:
+    """Resolve a timezone abbreviation or IANA name to a ZoneInfo object.
+
+    Checks the built-in abbreviation map first, then tries to find an
+    exact match among known IANA timezone names, and finally attempts
+    a case-insensitive match.
+
+    Args:
+        tz: A timezone abbreviation (e.g. "ET") or IANA name
+            (e.g. "America/New_York").
+
+    Returns:
+        A ZoneInfo object for the resolved timezone, or None if the
+        timezone cannot be resolved.
+
+    """
+    # Check built-in abbreviation map first
+    if tz.upper() in _TZ_ABBREV:
+        iana = _TZ_ABBREV[tz.upper()]
+        logger.debug("Resolved abbreviation %r to IANA %r", tz, iana)
+        return ZoneInfo(iana)
+
+    # Direct IANA name match
+    if tz in available_timezones():
+        logger.debug("Resolved IANA timezone %r", tz)
+        return ZoneInfo(tz)
+
+    # Case-insensitive IANA match
+    tz_lower = tz.lower()
+    for tz_name in available_timezones():
+        if tz_name.lower() == tz_lower:
+            logger.debug("Resolved %r to IANA %r (case-insensitive)", tz, tz_name)
+            return ZoneInfo(tz_name)
+
+    logger.warning("Could not resolve timezone: %r", tz)
+    return None
+
+
+def convert_column_tz(
+    column: "pd.Series",
+    target_tz: str,
+) -> "pd.Series":
+    """Convert a pandas Series of timestamps to a target timezone.
+
+    The series should contain timezone-aware datetime values (e.g. UTC
+    timestamps). The function converts them to the timezone identified
+    by ``target_tz``.
+
+    Args:
+        column: A pandas Series containing timezone-aware datetime values.
+            Timezone-naive values are assumed to be UTC.
+        target_tz: The target timezone as an abbreviation (e.g. "ET",
+            "PT") or a full IANA timezone name (e.g. "America/New_York").
+
+    Returns:
+        A new pandas Series with timestamps converted to the target
+        timezone.
+
+    Raises:
+        ValueError: If the target timezone cannot be resolved.
+
+    """
+    zone = resolve_tz(target_tz)
+    if zone is None:
+        msg = f"Cannot resolve timezone: {target_tz!r}"
+        raise ValueError(msg)
+
+    # Work on a copy so we don't mutate the original
+    series = column.copy()
+
+    # If series is timezone-naive, assume UTC
+    if series.dt.tz is None:
+        series = series.dt.tz_localize("UTC")
+
+    result: pd.Series = series.dt.tz_convert(zone)
+    logger.info(
+        "Converted %d timestamps from %s to %s",
+        len(result),
+        series.dt.tz,
+        target_tz,
+    )
+    return result
diff --git a/timetracker_utils/time_cop.py b/timetracker_utils/time_cop.py
new file mode 100644
index 0000000..eb33716
--- /dev/null
+++ b/timetracker_utils/time_cop.py
@@ -0,0 +1,367 @@
+"""TimeCop module.
+
+Provides a class that reads CSV time tracking data and validates
+entries using Pydantic models.
+"""
+
+import csv
+import io
+import logging
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+import pandas as pd
+from pydantic import BaseModel, Field, field_validator, model_validator
+
+logger = logging.getLogger(__name__)
+
+
+class TimeEntry(BaseModel):
+    """A single time tracking entry.
+
+    Attributes:
+        date: The date of the entry (e.g. "4/13/2026").
+        project: The project name.
+        description: A short description of the task.
+        combined: The combined project & description string.
+        start_time: The start timestamp in ISO 8601 format.
+        end_time: The end timestamp in ISO 8601 format.
+        hours: The number of hours for the entry.
+        notes: Optional notes.
+
+    """
+
+    date: str = Field(default="", alias="Date", description="The date of the entry")
+    project: str = Field(default="", alias="Project", description="The project name")
+    description: str = Field(
+        default="", alias="Description", description="Short description of the task"
+    )
+    combined: str = Field(
+        default="",
+        alias="Combined Project & Description",
+        description="Combined project & description string",
+    )
+    start_time: datetime = Field(
+        ..., alias="Start Time", description="Start timestamp in ISO 8601 format"
+    )
+    end_time: datetime | None = Field(
+        default=None, alias="End Time", description="End timestamp in ISO 8601 format"
+    )
+    hours: float | None = Field(
+        default=None, alias="Time (hours)", description="Number of hours for the entry"
+    )
+    notes: str = Field(default="", alias="Notes", description="Optional notes")
+
+    model_config = {"populate_by_name": True, "extra": "ignore"}
+
+    # NOTE: Validator ordering matters here. `validate_date_from_start_time`
+    # runs before `validate_end_time_and_hours` (declaration order for
+    # model_validator(mode="after")). This ensures `self.date` is filled
+    # (from start_time) before `validate_end_time_and_hours` potentially
+    # references it. Do not reorder these validators without updating
+    # the dependent logic.
+
+    @model_validator(mode="after")
+    def validate_date_from_start_time(self) -> "TimeEntry":
+        """Validate date against start_time.
+
+        If date is missing, fill it from start_time. If both present,
+        validate consistency.
+
+        Returns:
+            The validated TimeEntry instance.
+
+        Raises:
+            ValueError: If date and start_time are inconsistent.
+
+        """
+        if not self.date and self.start_time:
+            self.date = (
+                f"{self.start_time.month}/{self.start_time.day}/{self.start_time.year}"
+            )
+        elif self.date and self.start_time:
+            expected_date = (
+                f"{self.start_time.month}/{self.start_time.day}/{self.start_time.year}"
+            )
+            if self.date != expected_date:
+                msg = (
+                    f"Date {self.date!r} does not match start_time date "
+                    f"{expected_date!r}"
+                )
+                raise ValueError(msg)
+        return self
+
+    @model_validator(mode="after")
+    def validate_end_time_and_hours(self) -> "TimeEntry":
+        """Validate and backfill end_time and hours.
+
+        At least one of end_time or hours must be provided.
+        - If only end_time: backfill hours from start_time/end_time duration.
+        - If only hours: backfill end_time from start_time + hours.
+        - If both: validate they are consistent.
+
+        Returns:
+            The validated TimeEntry instance.
+
+        Raises:
+            ValueError: If neither end_time nor hours is provided, or if they are
+                inconsistent.
+
+        """
+        if self.end_time is None and self.hours is None:
+            msg = "At least one of End Time or Time (hours) must be provided"
+            raise ValueError(msg)
+
+        if self.end_time is not None and self.hours is None:
+            # Backfill hours from duration
+            delta = self.end_time - self.start_time
+            self.hours = round(delta.total_seconds() / 3600.0, 4)
+        elif self.hours is not None and self.end_time is None:
+            # Backfill end_time from start_time + hours
+            self.end_time = self.start_time + timedelta(hours=self.hours)
+        elif self.end_time is not None and self.hours is not None:
+            # Both present: validate consistency (within 1-minute tolerance)
+            delta = self.end_time - self.start_time
+            expected_hours = delta.total_seconds() / 3600.0
+            if abs(self.hours - expected_hours) > 1.0 / 60.0:
+                msg = (
+                    f"Hours {self.hours} does not match duration "
+                    f"({expected_hours:.4f}h) between start and end time"
+                )
+                raise ValueError(msg)
+        return self
+
+    @field_validator("start_time", "end_time", mode="before")
+    @classmethod
+    def parse_datetime(cls, value: str | None) -> datetime | None:
+        """Parse an ISO 8601 datetime string.
+
+        Args:
+            value: The datetime string to parse.
+
+        Returns:
+            A timezone-aware datetime object, or None if value is None.
+
+        Raises:
+            ValueError: If the value cannot be parsed as a valid ISO 8601 datetime.
+
+        """
+        if value is None or value == "":
+            return None
+        if isinstance(value, datetime):
+            return value
+        try:
+            dt = datetime.fromisoformat(value.replace("Z", "+00:00"))
+            if dt.tzinfo is None:
+                dt = dt.replace(tzinfo=timezone.utc)
+            return dt
+        except (ValueError, TypeError) as exc:
+            msg = f"Invalid datetime value: {value!r}"
+            raise ValueError(msg) from exc
+
+    @field_validator(
+        "date", "project", "description", "combined", "notes", mode="before"
+    )
+    @classmethod
+    def coerce_none_to_empty_string(cls, value: str | None) -> str:
+        """Coerce None to empty string for optional string fields.
+
+        Args:
+            value: The string value to coerce.
+
+        Returns:
+            The original string, or empty string if value is None.
+
+        """
+        if value is None:
+            return ""
+        return value
+
+    @field_validator("hours", mode="before")
+    @classmethod
+    def validate_hours(cls, value: str | float | None) -> float | None:
+        """Validate hours value is non-negative and within reasonable range.
+
+        Args:
+            value: The hours value to validate.
+
+        Returns:
+            The validated hours value, or None if value is None or empty string.
+
+        Raises:
+            ValueError: If the hours value is negative or unreasonably large.
+
+        """
+        if value is None:
+            return None
+        if isinstance(value, str):
+            if value.strip() == "":
+                return None
+            value = float(value)
+        if value < 0:
+            msg = f"Hours cannot be negative: {value}"
+            raise ValueError(msg)
+        if value > 24:
+            msg = f"Hours exceed 24 (likely data error): {value}"
+            raise ValueError(msg)
+        return round(value, 4)
+
+    def duration_seconds(self) -> float | None:
+        """Calculate the duration between start and end time in seconds.
+
+        Returns:
+            The duration in seconds, or None if start or end time is not set.
+
+        """
+        if self.start_time is None or self.end_time is None:
+            return None
+        return (self.end_time - self.start_time).total_seconds()
+
+    def duration_minutes(self) -> float | None:
+        """Calculate the duration between start and end time in minutes.
+
+        Returns:
+            The duration in minutes, or None if start or end time is not set.
+
+        """
+        seconds = self.duration_seconds()
+        if seconds is None:
+            return None
+        return seconds / 60.0
+
+
+class TimeCop:
+    """Reads and validates CSV time tracking data.
+
+    Provides methods to load CSV data and access validated time entries.
+
+    Attributes:
+        entries: A pandas DataFrame of validated time entries.
+
+    """
+
+    def __init__(self) -> None:
+        """Initialize an empty TimeCop instance."""
+        self.entries: pd.DataFrame = pd.DataFrame()
+
+    def read_csv(self, path: str | Path) -> pd.DataFrame:
+        """Read and validate entries from a CSV file.
+
+        Args:
+            path: Path to the CSV file.
+
+        Returns:
+            A pandas DataFrame of validated time entries.
+
+        Raises:
+            FileNotFoundError: If the CSV file does not exist.
+            csv.Error: If the CSV file cannot be parsed.
+            ValidationError: If any entry fails Pydantic validation.
+
+        """
+        filepath = Path(path)
+        if not filepath.exists():
+            msg = f"CSV file not found: {filepath}"
+            raise FileNotFoundError(msg)
+
+        logger.info("Reading CSV from %s", filepath)
+        content = filepath.read_text(encoding="utf-8")
+        return self.read_csv_string(content)
+
+    def read_csv_string(self, csv_data: str) -> pd.DataFrame:
+        """Read and validate entries from a CSV string.
+
+        Args:
+            csv_data: The CSV data as a string.
+
+        Returns:
+            A pandas DataFrame of validated time entries.
+
+        Raises:
+            csv.Error: If the CSV data cannot be parsed.
+
+        """
+        # Strip BOM if present (UTF-8 BOM: \ufeff)
+        cleaned = csv_data.lstrip("\ufeff")
+        reader = csv.DictReader(io.StringIO(cleaned))
+
+        # Warn about extra columns that will be ignored
+        if reader.fieldnames is not None:
+            known_fields: set[str] = set()
+            for field_name in TimeEntry.model_fields:
+                field_info = TimeEntry.model_fields[field_name]
+                known_fields.add(field_name)
+                if field_info.alias:
+                    known_fields.add(field_info.alias)
+            extra_cols = set(reader.fieldnames) - known_fields
+            if extra_cols:
+                logger.warning(
+                    "Extra columns in CSV that will be ignored: %s",
+                    sorted(extra_cols),
+                )
+
+        validated_entries = [TimeEntry.model_validate(row) for row in reader]
+        if validated_entries:
+            self.entries = pd.DataFrame(
+                [entry.model_dump() for entry in validated_entries]
+            )
+        else:
+            self.entries = pd.DataFrame()
+        logger.info("Loaded %d time entries", len(self.entries))
+        return self.entries
+
+    def total_hours(self) -> float:
+        """Calculate the total hours across all entries.
+
+        Returns:
+            The sum of hours for all entries.
+
+        """
+        if self.entries.empty:
+            return 0.0
+        return round(float(self.entries["hours"].sum()), 4)
+
+    def total_hours_by_project(self) -> dict[str, float]:
+        """Calculate total hours grouped by project.
+
+        Returns:
+            A dictionary mapping project names to total hours.
+
+        """
+        if self.entries.empty:
+            return {}
+        grouped = self.entries.groupby("project")["hours"].sum()
+        result: dict[str, float] = {
+            str(project): round(float(hours), 4) for project, hours in grouped.items()
+        }
+        return result
+
+    def entries_by_project(self, project: str) -> pd.DataFrame:
+        """Get all entries for a specific project.
+
+        Args:
+            project: The project name to filter by.
+
+        Returns:
+            A pandas DataFrame of entries matching the project.
+
+        """
+        if self.entries.empty:
+            return pd.DataFrame()
+        result: pd.DataFrame = self.entries[self.entries["project"] == project]
+        return result
+
+    def entries_by_date(self, date: str) -> pd.DataFrame:
+        """Get all entries for a specific date.
+
+        Args:
+            date: The date string to filter by (e.g. "4/13/2026").
+
+        Returns:
+            A pandas DataFrame of entries matching the date.
+
+        """
+        if self.entries.empty:
+            return pd.DataFrame()
+        result: pd.DataFrame = self.entries[self.entries["date"] == date]
+        return result
diff --git a/uv.lock b/uv.lock
index b2ce17d..641e111 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2,8 +2,16 @@ version = 1
 revision = 3
 requires-python = ">=3.10"
 resolution-markers = [
-    "python_full_version >= '3.15'",
-    "python_full_version < '3.15'",
+    "python_full_version >= '3.15' and sys_platform == 'win32'",
+    "python_full_version >= '3.15' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.15' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version == '3.14.*' and sys_platform == 'win32'",
+    "python_full_version == '3.14.*' and sys_platform == 'emscripten'",
+    "python_full_version == '3.14.*' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version < '3.11'",
 ]
 
 [[package]]
@@ -208,7 +216,7 @@ name = "exceptiongroup"
 version = "1.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
 wheels = [
@@ -398,6 +406,161 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" },
 ]
 
+[[package]]
+name = "numpy"
+version = "2.2.6"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/76/21/7d2a95e4bba9dc13d043ee156a356c0a8f0c6309dff6b21b4d71a073b8a8/numpy-2.2.6.tar.gz", hash = "sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd", size = 20276440, upload-time = "2025-05-17T22:38:04.611Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/3e/ed6db5be21ce87955c0cbd3009f2803f59fa08df21b5df06862e2d8e2bdd/numpy-2.2.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b412caa66f72040e6d268491a59f2c43bf03eb6c96dd8f0307829feb7fa2b6fb", size = 21165245, upload-time = "2025-05-17T21:27:58.555Z" },
+    { url = "https://files.pythonhosted.org/packages/22/c2/4b9221495b2a132cc9d2eb862e21d42a009f5a60e45fc44b00118c174bff/numpy-2.2.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8e41fd67c52b86603a91c1a505ebaef50b3314de0213461c7a6e99c9a3beff90", size = 14360048, upload-time = "2025-05-17T21:28:21.406Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/77/dc2fcfc66943c6410e2bf598062f5959372735ffda175b39906d54f02349/numpy-2.2.6-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:37e990a01ae6ec7fe7fa1c26c55ecb672dd98b19c3d0e1d1f326fa13cb38d163", size = 5340542, upload-time = "2025-05-17T21:28:30.931Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/4f/1cb5fdc353a5f5cc7feb692db9b8ec2c3d6405453f982435efc52561df58/numpy-2.2.6-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:5a6429d4be8ca66d889b7cf70f536a397dc45ba6faeb5f8c5427935d9592e9cf", size = 6878301, upload-time = "2025-05-17T21:28:41.613Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/17/96a3acd228cec142fcb8723bd3cc39c2a474f7dcf0a5d16731980bcafa95/numpy-2.2.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:efd28d4e9cd7d7a8d39074a4d44c63eda73401580c5c76acda2ce969e0a38e83", size = 14297320, upload-time = "2025-05-17T21:29:02.78Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/63/3de6a34ad7ad6646ac7d2f55ebc6ad439dbbf9c4370017c50cf403fb19b5/numpy-2.2.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc7b73d02efb0e18c000e9ad8b83480dfcd5dfd11065997ed4c6747470ae8915", size = 16801050, upload-time = "2025-05-17T21:29:27.675Z" },
+    { url = "https://files.pythonhosted.org/packages/07/b6/89d837eddef52b3d0cec5c6ba0456c1bf1b9ef6a6672fc2b7873c3ec4e2e/numpy-2.2.6-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:74d4531beb257d2c3f4b261bfb0fc09e0f9ebb8842d82a7b4209415896adc680", size = 15807034, upload-time = "2025-05-17T21:29:51.102Z" },
+    { url = "https://files.pythonhosted.org/packages/01/c8/dc6ae86e3c61cfec1f178e5c9f7858584049b6093f843bca541f94120920/numpy-2.2.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8fc377d995680230e83241d8a96def29f204b5782f371c532579b4f20607a289", size = 18614185, upload-time = "2025-05-17T21:30:18.703Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/c5/0064b1b7e7c89137b471ccec1fd2282fceaae0ab3a9550f2568782d80357/numpy-2.2.6-cp310-cp310-win32.whl", hash = "sha256:b093dd74e50a8cba3e873868d9e93a85b78e0daf2e98c6797566ad8044e8363d", size = 6527149, upload-time = "2025-05-17T21:30:29.788Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/dd/4b822569d6b96c39d1215dbae0582fd99954dcbcf0c1a13c61783feaca3f/numpy-2.2.6-cp310-cp310-win_amd64.whl", hash = "sha256:f0fd6321b839904e15c46e0d257fdd101dd7f530fe03fd6359c1ea63738703f3", size = 12904620, upload-time = "2025-05-17T21:30:48.994Z" },
+    { url = "https://files.pythonhosted.org/packages/da/a8/4f83e2aa666a9fbf56d6118faaaf5f1974d456b1823fda0a176eff722839/numpy-2.2.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f9f1adb22318e121c5c69a09142811a201ef17ab257a1e66ca3025065b7f53ae", size = 21176963, upload-time = "2025-05-17T21:31:19.36Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/2b/64e1affc7972decb74c9e29e5649fac940514910960ba25cd9af4488b66c/numpy-2.2.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c820a93b0255bc360f53eca31a0e676fd1101f673dda8da93454a12e23fc5f7a", size = 14406743, upload-time = "2025-05-17T21:31:41.087Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/9f/0121e375000b5e50ffdd8b25bf78d8e1a5aa4cca3f185d41265198c7b834/numpy-2.2.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3d70692235e759f260c3d837193090014aebdf026dfd167834bcba43e30c2a42", size = 5352616, upload-time = "2025-05-17T21:31:50.072Z" },
+    { url = "https://files.pythonhosted.org/packages/31/0d/b48c405c91693635fbe2dcd7bc84a33a602add5f63286e024d3b6741411c/numpy-2.2.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:481b49095335f8eed42e39e8041327c05b0f6f4780488f61286ed3c01368d491", size = 6889579, upload-time = "2025-05-17T21:32:01.712Z" },
+    { url = "https://files.pythonhosted.org/packages/52/b8/7f0554d49b565d0171eab6e99001846882000883998e7b7d9f0d98b1f934/numpy-2.2.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b64d8d4d17135e00c8e346e0a738deb17e754230d7e0810ac5012750bbd85a5a", size = 14312005, upload-time = "2025-05-17T21:32:23.332Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/dd/2238b898e51bd6d389b7389ffb20d7f4c10066d80351187ec8e303a5a475/numpy-2.2.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba10f8411898fc418a521833e014a77d3ca01c15b0c6cdcce6a0d2897e6dbbdf", size = 16821570, upload-time = "2025-05-17T21:32:47.991Z" },
+    { url = "https://files.pythonhosted.org/packages/83/6c/44d0325722cf644f191042bf47eedad61c1e6df2432ed65cbe28509d404e/numpy-2.2.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd48227a919f1bafbdda0583705e547892342c26fb127219d60a5c36882609d1", size = 15818548, upload-time = "2025-05-17T21:33:11.728Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/9d/81e8216030ce66be25279098789b665d49ff19eef08bfa8cb96d4957f422/numpy-2.2.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9551a499bf125c1d4f9e250377c1ee2eddd02e01eac6644c080162c0c51778ab", size = 18620521, upload-time = "2025-05-17T21:33:39.139Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/fd/e19617b9530b031db51b0926eed5345ce8ddc669bb3bc0044b23e275ebe8/numpy-2.2.6-cp311-cp311-win32.whl", hash = "sha256:0678000bb9ac1475cd454c6b8c799206af8107e310843532b04d49649c717a47", size = 6525866, upload-time = "2025-05-17T21:33:50.273Z" },
+    { url = "https://files.pythonhosted.org/packages/31/0a/f354fb7176b81747d870f7991dc763e157a934c717b67b58456bc63da3df/numpy-2.2.6-cp311-cp311-win_amd64.whl", hash = "sha256:e8213002e427c69c45a52bbd94163084025f533a55a59d6f9c5b820774ef3303", size = 12907455, upload-time = "2025-05-17T21:34:09.135Z" },
+    { url = "https://files.pythonhosted.org/packages/82/5d/c00588b6cf18e1da539b45d3598d3557084990dcc4331960c15ee776ee41/numpy-2.2.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41c5a21f4a04fa86436124d388f6ed60a9343a6f767fced1a8a71c3fbca038ff", size = 20875348, upload-time = "2025-05-17T21:34:39.648Z" },
+    { url = "https://files.pythonhosted.org/packages/66/ee/560deadcdde6c2f90200450d5938f63a34b37e27ebff162810f716f6a230/numpy-2.2.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:de749064336d37e340f640b05f24e9e3dd678c57318c7289d222a8a2f543e90c", size = 14119362, upload-time = "2025-05-17T21:35:01.241Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/65/4baa99f1c53b30adf0acd9a5519078871ddde8d2339dc5a7fde80d9d87da/numpy-2.2.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:894b3a42502226a1cac872f840030665f33326fc3dac8e57c607905773cdcde3", size = 5084103, upload-time = "2025-05-17T21:35:10.622Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/89/e5a34c071a0570cc40c9a54eb472d113eea6d002e9ae12bb3a8407fb912e/numpy-2.2.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:71594f7c51a18e728451bb50cc60a3ce4e6538822731b2933209a1f3614e9282", size = 6625382, upload-time = "2025-05-17T21:35:21.414Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/35/8c80729f1ff76b3921d5c9487c7ac3de9b2a103b1cd05e905b3090513510/numpy-2.2.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2618db89be1b4e05f7a1a847a9c1c0abd63e63a1607d892dd54668dd92faf87", size = 14018462, upload-time = "2025-05-17T21:35:42.174Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/3d/1e1db36cfd41f895d266b103df00ca5b3cbe965184df824dec5c08c6b803/numpy-2.2.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd83c01228a688733f1ded5201c678f0c53ecc1006ffbc404db9f7a899ac6249", size = 16527618, upload-time = "2025-05-17T21:36:06.711Z" },
+    { url = "https://files.pythonhosted.org/packages/61/c6/03ed30992602c85aa3cd95b9070a514f8b3c33e31124694438d88809ae36/numpy-2.2.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37c0ca431f82cd5fa716eca9506aefcabc247fb27ba69c5062a6d3ade8cf8f49", size = 15505511, upload-time = "2025-05-17T21:36:29.965Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/25/5761d832a81df431e260719ec45de696414266613c9ee268394dd5ad8236/numpy-2.2.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fe27749d33bb772c80dcd84ae7e8df2adc920ae8297400dabec45f0dedb3f6de", size = 18313783, upload-time = "2025-05-17T21:36:56.883Z" },
+    { url = "https://files.pythonhosted.org/packages/57/0a/72d5a3527c5ebffcd47bde9162c39fae1f90138c961e5296491ce778e682/numpy-2.2.6-cp312-cp312-win32.whl", hash = "sha256:4eeaae00d789f66c7a25ac5f34b71a7035bb474e679f410e5e1a94deb24cf2d4", size = 6246506, upload-time = "2025-05-17T21:37:07.368Z" },
+    { url = "https://files.pythonhosted.org/packages/36/fa/8c9210162ca1b88529ab76b41ba02d433fd54fecaf6feb70ef9f124683f1/numpy-2.2.6-cp312-cp312-win_amd64.whl", hash = "sha256:c1f9540be57940698ed329904db803cf7a402f3fc200bfe599334c9bd84a40b2", size = 12614190, upload-time = "2025-05-17T21:37:26.213Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/5c/6657823f4f594f72b5471f1db1ab12e26e890bb2e41897522d134d2a3e81/numpy-2.2.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0811bb762109d9708cca4d0b13c4f67146e3c3b7cf8d34018c722adb2d957c84", size = 20867828, upload-time = "2025-05-17T21:37:56.699Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/9e/14520dc3dadf3c803473bd07e9b2bd1b69bc583cb2497b47000fed2fa92f/numpy-2.2.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:287cc3162b6f01463ccd86be154f284d0893d2b3ed7292439ea97eafa8170e0b", size = 14143006, upload-time = "2025-05-17T21:38:18.291Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/06/7e96c57d90bebdce9918412087fc22ca9851cceaf5567a45c1f404480e9e/numpy-2.2.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f1372f041402e37e5e633e586f62aa53de2eac8d98cbfb822806ce4bbefcb74d", size = 5076765, upload-time = "2025-05-17T21:38:27.319Z" },
+    { url = "https://files.pythonhosted.org/packages/73/ed/63d920c23b4289fdac96ddbdd6132e9427790977d5457cd132f18e76eae0/numpy-2.2.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:55a4d33fa519660d69614a9fad433be87e5252f4b03850642f88993f7b2ca566", size = 6617736, upload-time = "2025-05-17T21:38:38.141Z" },
+    { url = "https://files.pythonhosted.org/packages/85/c5/e19c8f99d83fd377ec8c7e0cf627a8049746da54afc24ef0a0cb73d5dfb5/numpy-2.2.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f92729c95468a2f4f15e9bb94c432a9229d0d50de67304399627a943201baa2f", size = 14010719, upload-time = "2025-05-17T21:38:58.433Z" },
+    { url = "https://files.pythonhosted.org/packages/19/49/4df9123aafa7b539317bf6d342cb6d227e49f7a35b99c287a6109b13dd93/numpy-2.2.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1bc23a79bfabc5d056d106f9befb8d50c31ced2fbc70eedb8155aec74a45798f", size = 16526072, upload-time = "2025-05-17T21:39:22.638Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/6c/04b5f47f4f32f7c2b0e7260442a8cbcf8168b0e1a41ff1495da42f42a14f/numpy-2.2.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e3143e4451880bed956e706a3220b4e5cf6172ef05fcc397f6f36a550b1dd868", size = 15503213, upload-time = "2025-05-17T21:39:45.865Z" },
+    { url = "https://files.pythonhosted.org/packages/17/0a/5cd92e352c1307640d5b6fec1b2ffb06cd0dabe7d7b8227f97933d378422/numpy-2.2.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b4f13750ce79751586ae2eb824ba7e1e8dba64784086c98cdbbcc6a42112ce0d", size = 18316632, upload-time = "2025-05-17T21:40:13.331Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/3b/5cba2b1d88760ef86596ad0f3d484b1cbff7c115ae2429678465057c5155/numpy-2.2.6-cp313-cp313-win32.whl", hash = "sha256:5beb72339d9d4fa36522fc63802f469b13cdbe4fdab4a288f0c441b74272ebfd", size = 6244532, upload-time = "2025-05-17T21:43:46.099Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/3b/d58c12eafcb298d4e6d0d40216866ab15f59e55d148a5658bb3132311fcf/numpy-2.2.6-cp313-cp313-win_amd64.whl", hash = "sha256:b0544343a702fa80c95ad5d3d608ea3599dd54d4632df855e4c8d24eb6ecfa1c", size = 12610885, upload-time = "2025-05-17T21:44:05.145Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/9e/4bf918b818e516322db999ac25d00c75788ddfd2d2ade4fa66f1f38097e1/numpy-2.2.6-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0bca768cd85ae743b2affdc762d617eddf3bcf8724435498a1e80132d04879e6", size = 20963467, upload-time = "2025-05-17T21:40:44Z" },
+    { url = "https://files.pythonhosted.org/packages/61/66/d2de6b291507517ff2e438e13ff7b1e2cdbdb7cb40b3ed475377aece69f9/numpy-2.2.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:fc0c5673685c508a142ca65209b4e79ed6740a4ed6b2267dbba90f34b0b3cfda", size = 14225144, upload-time = "2025-05-17T21:41:05.695Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/25/480387655407ead912e28ba3a820bc69af9adf13bcbe40b299d454ec011f/numpy-2.2.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:5bd4fc3ac8926b3819797a7c0e2631eb889b4118a9898c84f585a54d475b7e40", size = 5200217, upload-time = "2025-05-17T21:41:15.903Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/4a/6e313b5108f53dcbf3aca0c0f3e9c92f4c10ce57a0a721851f9785872895/numpy-2.2.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:fee4236c876c4e8369388054d02d0e9bb84821feb1a64dd59e137e6511a551f8", size = 6712014, upload-time = "2025-05-17T21:41:27.321Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/30/172c2d5c4be71fdf476e9de553443cf8e25feddbe185e0bd88b096915bcc/numpy-2.2.6-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e1dda9c7e08dc141e0247a5b8f49cf05984955246a327d4c48bda16821947b2f", size = 14077935, upload-time = "2025-05-17T21:41:49.738Z" },
+    { url = "https://files.pythonhosted.org/packages/12/fb/9e743f8d4e4d3c710902cf87af3512082ae3d43b945d5d16563f26ec251d/numpy-2.2.6-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f447e6acb680fd307f40d3da4852208af94afdfab89cf850986c3ca00562f4fa", size = 16600122, upload-time = "2025-05-17T21:42:14.046Z" },
+    { url = "https://files.pythonhosted.org/packages/12/75/ee20da0e58d3a66f204f38916757e01e33a9737d0b22373b3eb5a27358f9/numpy-2.2.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:389d771b1623ec92636b0786bc4ae56abafad4a4c513d36a55dce14bd9ce8571", size = 15586143, upload-time = "2025-05-17T21:42:37.464Z" },
+    { url = "https://files.pythonhosted.org/packages/76/95/bef5b37f29fc5e739947e9ce5179ad402875633308504a52d188302319c8/numpy-2.2.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8e9ace4a37db23421249ed236fdcdd457d671e25146786dfc96835cd951aa7c1", size = 18385260, upload-time = "2025-05-17T21:43:05.189Z" },
+    { url = "https://files.pythonhosted.org/packages/09/04/f2f83279d287407cf36a7a8053a5abe7be3622a4363337338f2585e4afda/numpy-2.2.6-cp313-cp313t-win32.whl", hash = "sha256:038613e9fb8c72b0a41f025a7e4c3f0b7a1b5d768ece4796b674c8f3fe13efff", size = 6377225, upload-time = "2025-05-17T21:43:16.254Z" },
+    { url = "https://files.pythonhosted.org/packages/67/0e/35082d13c09c02c011cf21570543d202ad929d961c02a147493cb0c2bdf5/numpy-2.2.6-cp313-cp313t-win_amd64.whl", hash = "sha256:6031dd6dfecc0cf9f668681a37648373bddd6421fff6c66ec1624eed0180ee06", size = 12771374, upload-time = "2025-05-17T21:43:35.479Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/3b/d94a75f4dbf1ef5d321523ecac21ef23a3cd2ac8b78ae2aac40873590229/numpy-2.2.6-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0b605b275d7bd0c640cad4e5d30fa701a8d59302e127e5f79138ad62762c3e3d", size = 21040391, upload-time = "2025-05-17T21:44:35.948Z" },
+    { url = "https://files.pythonhosted.org/packages/17/f4/09b2fa1b58f0fb4f7c7963a1649c64c4d315752240377ed74d9cd878f7b5/numpy-2.2.6-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:7befc596a7dc9da8a337f79802ee8adb30a552a94f792b9c9d18c840055907db", size = 6786754, upload-time = "2025-05-17T21:44:47.446Z" },
+    { url = "https://files.pythonhosted.org/packages/af/30/feba75f143bdc868a1cc3f44ccfa6c4b9ec522b36458e738cd00f67b573f/numpy-2.2.6-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce47521a4754c8f4593837384bd3424880629f718d87c5d44f8ed763edd63543", size = 16643476, upload-time = "2025-05-17T21:45:11.871Z" },
+    { url = "https://files.pythonhosted.org/packages/37/48/ac2a9584402fb6c0cd5b5d1a91dcf176b15760130dd386bbafdbfe3640bf/numpy-2.2.6-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d042d24c90c41b54fd506da306759e06e568864df8ec17ccc17e9e884634fd00", size = 12812666, upload-time = "2025-05-17T21:45:31.426Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.4.6"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.15' and sys_platform == 'win32'",
+    "python_full_version >= '3.15' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.15' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version == '3.14.*' and sys_platform == 'win32'",
+    "python_full_version == '3.14.*' and sys_platform == 'emscripten'",
+    "python_full_version == '3.14.*' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d0/ad/fed0499ce6a338d2a03ebae59cd15093910c8875328855781952abf6c2fe/numpy-2.4.6.tar.gz", hash = "sha256:f3a3570c4a2a16746ac2c31a7c7c7b0c186b95ce902e33db6f28094ed7387dda", size = 20735807, upload-time = "2026-05-18T23:37:14.07Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/49/ec46835a70be8fa6446c495126ac84fdb28cb2558e1620ffb87a10c8b64c/numpy-2.4.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0280e0356c0829a18d9de1cb7eee50ec22ca639878d7240307ca0943d73cd2c4", size = 16969194, upload-time = "2026-05-18T23:33:13.503Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/0d/f5957185c0ee2f3e12f78715aa9e3b353fd83633316c8532b38faa37e3f6/numpy-2.4.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:110f8b71aacb688ec69062bb7f6938a0f8acb01b7c1c4beb453c65b6d234584d", size = 14964111, upload-time = "2026-05-18T23:33:17.795Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/40/40a40ee0ddf7ceb782c49af278894b686e586d65d8c1889c8b5da01a3d7d/numpy-2.4.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:4cfe66903cc32a9921a6733d96b19bb6abf310397581bbad89c228f5abaf0ee8", size = 5469159, upload-time = "2026-05-18T23:33:20.654Z" },
+    { url = "https://files.pythonhosted.org/packages/63/13/f9a8046535cb21deae82f8d03de9617e08882d274fad2539630761888228/numpy-2.4.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8155154c7c691289fe18f510b5d4657c68c67989f293f0535a91360392ff6538", size = 6798936, upload-time = "2026-05-18T23:33:22.987Z" },
+    { url = "https://files.pythonhosted.org/packages/33/a8/6fa8c1a345a8c85dbb21932c447bee07c30a2c2a3f31e369c0a84b300147/numpy-2.4.6-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ab0a9c4ffb1a6d95ef519fe4247dba8eb6b18ad93999f76b7f657039acabd47", size = 15966692, upload-time = "2026-05-18T23:33:26.62Z" },
+    { url = "https://files.pythonhosted.org/packages/02/03/74fe2a4cb3817d94d86402f2506554130a2f01414e299b5a843e5a8a957f/numpy-2.4.6-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:89cd468399cfd2504718f0ba50e410dca55a170b61a02ad92bb18c8a65186e93", size = 16918164, upload-time = "2026-05-18T23:33:29.955Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/80/3615be3313f7e7696609bc194b9f0101da809df79e859bdb84e0cd043f46/numpy-2.4.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c2d37ab77531417474168eb79d6d80b14f821a966818505d03013d0833edb7a8", size = 17322877, upload-time = "2026-05-18T23:33:34.724Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/ac/a691e0fe2675e370d0e08ff905adc49a1c8830e8cae03efe4477e92cd55d/numpy-2.4.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f407cb6b8e9d6d8c626bc73c945db1706035af8fd632295547bf1c9e46d092d6", size = 18651487, upload-time = "2026-05-18T23:33:38.217Z" },
+    { url = "https://files.pythonhosted.org/packages/15/a7/9bc1cd626d7bf6869bfedf27b91b6ab5dd607758bf8e959d6fa80c6a59cb/numpy-2.4.6-cp311-cp311-win32.whl", hash = "sha256:ddea102b48f9e339f3948bf22040944184627a30fdf7f858667673b9c5f033c8", size = 6233945, upload-time = "2026-05-18T23:33:41.331Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/31/7fc6239c12bce7e931463251cca4426c465e1876ba3cc785402ef4dd8f4e/numpy-2.4.6-cp311-cp311-win_amd64.whl", hash = "sha256:1e254a00cdf42b1e4d5b3d68d33af63268d41340d8885df2ab6470f2e1500147", size = 12608406, upload-time = "2026-05-18T23:33:44.131Z" },
+    { url = "https://files.pythonhosted.org/packages/27/83/140f85a466595a16382996a1bf06b2b54bcd597488921b0c9daaeeda72af/numpy-2.4.6-cp311-cp311-win_arm64.whl", hash = "sha256:ed9749eef4cbd126da3dc1d6bcb3a57f5eb7ac6a6484146bdbf743f552dfc577", size = 10479528, upload-time = "2026-05-18T23:33:50.725Z" },
+    { url = "https://files.pythonhosted.org/packages/95/2a/3d7b5ac8aac24feaf9ad7ed58f45b0bbc06d37e4338ae84c9f2298b570f9/numpy-2.4.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:001fbb8e08d942dd57599e781f2472269ee7f2755fae407b4f67b2f0b17da3f1", size = 16689119, upload-time = "2026-05-18T23:33:54.065Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/12/92c4c131527599e8288d6918e888d88726f84d805d784b771f32408aeaef/numpy-2.4.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ebfb099f8dcf083deef3ac1ca4c1503f387cf76296fcb3816b66f5ecb5f54fdb", size = 14699246, upload-time = "2026-05-18T23:33:57.621Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/fe/c0a6b7b2ca128a8fb228575147073b660656734b8ebe4d76c8fd748dcc79/numpy-2.4.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:3213d622a0283a39a93d188f3cf72b26862df52fbb4ca3697f51705016523d41", size = 5204410, upload-time = "2026-05-18T23:34:00.302Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/d4/9770d14ba719432bb90a421bfd443872ed0f70f7264b64bec12ea363d5fd/numpy-2.4.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:357cc07a6d7b0b182ff02249616a03742827ebb1277546b5c7cd7f7620a45698", size = 6551240, upload-time = "2026-05-18T23:34:02.852Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/c6/50a46a6205feba2343f1d6d17438107c5dc491ed1c736e6ea68689fd906b/numpy-2.4.6-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f9fb9157b4ce2971008323afe46053787b526ef624fea915b261468a8421a0f", size = 15671012, upload-time = "2026-05-18T23:34:05.485Z" },
+    { url = "https://files.pythonhosted.org/packages/99/60/14115e6364fa676c5397c2ad3004e527e9aa487abf5d0706ec81bbd08529/numpy-2.4.6-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:90f9849678c75fe7afa2d348ac842c168b0a4d3d61919687216dfc547976d853", size = 16645538, upload-time = "2026-05-18T23:34:09.265Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/c5/693cbe59e57db94d2231fa519ca3978dc9e19da5a8f088588f5c6e947ff2/numpy-2.4.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c1a2af6c6ef86344a6b0db6b97834208bf598db514f2b155042439b62605601a", size = 17020706, upload-time = "2026-05-18T23:34:13.053Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/fc/85b7c4eff9b4966ade25c2273cf7e7012e92366c032058653934b37de044/numpy-2.4.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e5805d5a22fd19c8ccff10a9561f9df94436b0545619ea579db2d3c35294bce2", size = 18368541, upload-time = "2026-05-18T23:34:17.024Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/81/e1b27545deedce7f4a0b348618c6b62d74e36a4dc9ccd42f3eb2f85eee32/numpy-2.4.6-cp312-cp312-win32.whl", hash = "sha256:e3eeb0aabd6bd5ce64faae67e9935203a6991b4bc2a485a767fbafb2c5125f45", size = 5962825, upload-time = "2026-05-18T23:34:20.3Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/ca/feab00bd44aa5fe1ad2c18f08b4d3bb92e26484b0b1d1443897809ed528c/numpy-2.4.6-cp312-cp312-win_amd64.whl", hash = "sha256:d8e8286dd7cea7895157318d1b91cdacac64c479f3cbc8dce548331728484751", size = 12321687, upload-time = "2026-05-18T23:34:23.095Z" },
+    { url = "https://files.pythonhosted.org/packages/63/cf/5a6d34850a39d1093558564f77ee8e8e0bee5061151b8f05a55711001ec7/numpy-2.4.6-cp312-cp312-win_arm64.whl", hash = "sha256:4081eb135ac24158bd51cdfbef16f1c64df7063b1143f24731387137c092bec8", size = 10221482, upload-time = "2026-05-18T23:34:25.876Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/82/bdab26d7438c6791ca31b7c024ca37c1eab8b726ba236129005cd4a06e45/numpy-2.4.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:511dbaf848decaaaf4b4ca48032619fb3138710c4bf7da7617765edad1ef96b0", size = 16684648, upload-time = "2026-05-18T23:34:29.41Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/30/a80189bcc7f5e4258b3fbc3968d909d1756f54d023299ecc39ad6fdb9ef8/numpy-2.4.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bf162abab1c1a736333192707cef898e735a5ca00f38f27eeedf44b39d9e85eb", size = 14693902, upload-time = "2026-05-18T23:34:33.013Z" },
+    { url = "https://files.pythonhosted.org/packages/97/12/70b5d0d7c15e1ebb8a6a84a8caa1d19e181d84fb58bb6d70aca29099dec1/numpy-2.4.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:043191bfa8eab18c776647b62723ac9dddece59743b13f49b2016094129c2b3f", size = 5198992, upload-time = "2026-05-18T23:34:36.132Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/8c/ebd2a8f8a83541f8d38cc5667e8c2b69cecfd30da6e45693e8158857d44b/numpy-2.4.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:6180d8b35af935aed8ece3a85e0a43f87393ae0ac87c8d2c8bd2c993f7270ef3", size = 6546944, upload-time = "2026-05-18T23:34:38.484Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/c5/7b863a97a91671a0338f4253bd3b5a3d3852f0692dae91711c9f4a10e787/numpy-2.4.6-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72fbe16c6fac95aedf5937fa873445cec2110be35d8a4e9433d7501fd98dae6b", size = 15669392, upload-time = "2026-05-18T23:34:41.257Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/9d/3584b9984ca4c047aea75214ce1a4c4c73d849bd71b604264b7f5653f8a8/numpy-2.4.6-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a7830bab239b79cda9c08c2da014761cafb48da6150e1da17ac06283f43b6089", size = 16633220, upload-time = "2026-05-18T23:34:45.075Z" },
+    { url = "https://files.pythonhosted.org/packages/05/ae/7c67fba23bd98caec7c99261f3a16072ade14813486b0282cb29846de832/numpy-2.4.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ef4aea96ce4d3b074422cb4f2f64e216bf9e213004bb58ecfdf50ea02ea8eb9a", size = 17020800, upload-time = "2026-05-18T23:34:49.065Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/5d/3b6725cb31d983c5e66916f5d36f6d7e5521129e4c4404d64f918292a5b6/numpy-2.4.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dfa20cc6ca228e6b155b11da03825975ce66aea520985dbbddf0f2a5a495c605", size = 18357600, upload-time = "2026-05-18T23:34:52.709Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/da/2ccc6c2fe8898dee01d90c75c5f5f914a23daf99e3e0f59516a08760c8b5/numpy-2.4.6-cp313-cp313-win32.whl", hash = "sha256:56b39e5e0622a09a25bf5baf62f4bcf0cb8a41ae6e2819cf49bbc5a74c083f91", size = 5961134, upload-time = "2026-05-18T23:34:55.618Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/cd/9cc4dc876fb065d5c220aae4d5e14826b2715331bb7618ce1fb07a679d99/numpy-2.4.6-cp313-cp313-win_amd64.whl", hash = "sha256:c4fc99836233ea196540b17ab0983aff60ed07941751930f5f4d05bc3b3b7359", size = 12318598, upload-time = "2026-05-18T23:34:58.928Z" },
+    { url = "https://files.pythonhosted.org/packages/39/1e/c0bcba1f8694116485fe28fd1be698c278fcda4141c5b0e53a2aed8b12a8/numpy-2.4.6-cp313-cp313-win_arm64.whl", hash = "sha256:a7c711e21628b52034bb5ab8d1bce291f752fcc5e92accc615778acee1ff4778", size = 10222272, upload-time = "2026-05-18T23:35:02.167Z" },
+    { url = "https://files.pythonhosted.org/packages/63/6d/cc5619247c8f4204e507f5883528372e4ac4bb189e579fb859a12e480b1f/numpy-2.4.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:112b06a867b235ef466ed3508ddf0238050df9c727cafb5301ac385b899189a1", size = 14821197, upload-time = "2026-05-18T23:35:05.468Z" },
+    { url = "https://files.pythonhosted.org/packages/00/58/f1c39161c87d9e9bed660f1ed4bafc0e403d5ec9650b6dd77aead07d489b/numpy-2.4.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:eaf7fa2de5c0be8ae6ff8e9bea2ccd725e980541244521d8d4b5f3354a27babe", size = 5326287, upload-time = "2026-05-18T23:35:08.693Z" },
+    { url = "https://files.pythonhosted.org/packages/af/57/3917ab0fd97f271a8694513581b8a36c655f111c446852c302f04ccdb6fc/numpy-2.4.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:7265a2f3d436e54ef9f2b52b5c937e6be778781bd97a590319d7348f1c1ca997", size = 6646763, upload-time = "2026-05-18T23:35:11.459Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/0f/037e64c494b67581ae18193d770adef354c41f3f2c8ebf865602d949bf8f/numpy-2.4.6-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f74a575920ab21fe304421a3fc28793d82e299cae9eccb37084e9fc7f3617c20", size = 15728070, upload-time = "2026-05-18T23:35:14.79Z" },
+    { url = "https://files.pythonhosted.org/packages/21/a6/5d2bae9c9542eb4df16dc9c46dc79c186e9bad53805dfa5399a6023c6db0/numpy-2.4.6-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ede83e07a75dd06bc501566c1eca2afc0d61677c1472ac9ad93fdee6e638a48d", size = 16681752, upload-time = "2026-05-18T23:35:18.836Z" },
+    { url = "https://files.pythonhosted.org/packages/92/14/23d1dfb410ae362cd59ce53e936b1513d545eb40db3949ced632e19a459e/numpy-2.4.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:68bb27509ac1b9a3443094260f6326150663b06abe40b73a2f81160623da5b67", size = 17086024, upload-time = "2026-05-18T23:35:22.52Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/6e/23595a2c642cdf3bc567877064bdd7f91c8b0038a4453cf2daf7248eafe9/numpy-2.4.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:a0df0043bdb289bde1f62da130d20df23d58b45429f752bc7a8fc5325a225ecd", size = 18403398, upload-time = "2026-05-18T23:35:26.398Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/90/0ac3bc947217e66dec77e7cbc6a1979d1af70b6461b82f620d3bccd5e4c8/numpy-2.4.6-cp313-cp313t-win32.whl", hash = "sha256:29a287e0cf63ff528da061de6b9f64a4618da591ca1046aafc54062e40ca7eab", size = 6084971, upload-time = "2026-05-18T23:35:29.387Z" },
+    { url = "https://files.pythonhosted.org/packages/77/71/5673e351671a1d2bd6063b91b44f70c0affea7d1516fa7a6572941ba4aa1/numpy-2.4.6-cp313-cp313t-win_amd64.whl", hash = "sha256:25c692919ac5a01f170a3bfcd62d745b24fd095c353d50812637d6fcab442e75", size = 12458532, upload-time = "2026-05-18T23:35:32.175Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/88/19d3503c5046e688f049274b27a3ef3d771152fa80d3ba3d01a3dff61abe/numpy-2.4.6-cp313-cp313t-win_arm64.whl", hash = "sha256:1e978ec1e8bd0e0e4de6bb75de9d30cbb74db6b6a2bb727618613703ca0167dd", size = 10291881, upload-time = "2026-05-18T23:35:35.465Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/91/3ab2044d05fd16d343c5ac2e69b127f1b2854040dd20b193257c78028bd3/numpy-2.4.6-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:06ca2f61ec4385a07a6977c55ba998a4466c123642b4a32694d3128fce18c079", size = 16683458, upload-time = "2026-05-18T23:35:38.353Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/62/764ce66fa4147ae6d73071a3abf804ffe606f174618697c571acdf26a7c9/numpy-2.4.6-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:38efbc8de75c7a0fc1ac190162d892787f3f47b57cc291231aafee36b80982b7", size = 14704559, upload-time = "2026-05-18T23:35:42.14Z" },
+    { url = "https://files.pythonhosted.org/packages/60/61/23f27c172f022e04025b7dc2367f4d63c1a398120607ec896228649a6f48/numpy-2.4.6-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:d581b735e177fdcdce6fed8e7e8880a3fb6ee4e3653a3ac6af01c6f4c03effc5", size = 5209716, upload-time = "2026-05-18T23:35:45.377Z" },
+    { url = "https://files.pythonhosted.org/packages/03/71/21cf70dc6ea3e3acb95fc53a265b2fc248b981f0194ceb5b475271b8809d/numpy-2.4.6-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:0a041d3d761dc3c35cc56ce0351506a02bcbc25f7b169f652435141a17db9096", size = 6543947, upload-time = "2026-05-18T23:35:47.926Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/91/64288395ee1799bd2e0b04a305dce9666da90c961e1f3fe982a05ee1c036/numpy-2.4.6-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:40fdc1ae7125e518ea98e53e69a4ebc27e1fd50510c47b7ea130cf21e5e1d42b", size = 15685197, upload-time = "2026-05-18T23:35:50.863Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/eb/ebffaa97dc55502df69584a8f0dcf07f69a3e0b3e2323670a2722db9aa39/numpy-2.4.6-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a2c306dea656c12c68f51f4cea133cbe78ca7435eb28c735eac1d3ebe73be6e8", size = 16638245, upload-time = "2026-05-18T23:35:54.752Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/0b/54f9da33128d7e350fab89c7455902eeae70349ee52bddb448dc4a576f45/numpy-2.4.6-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:33111801a01c12a8a1e3721f0a9232f8cfc8ae2c6b7098167e6f623c6073f402", size = 17036587, upload-time = "2026-05-18T23:35:58.355Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/f0/fdebc1052db1cc37c64beb22072d67cd6d1c71adca1299f53dec2b5e20d3/numpy-2.4.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ae506e6902902557576a26ff33eda8695e7ecb3cb36c3b573a0765dee114ebdb", size = 18363226, upload-time = "2026-05-18T23:36:02.845Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/b4/298628d98c72b57e57f7165ae6a481a1deaf6f3c28262a6e4c739c275930/numpy-2.4.6-cp314-cp314-win32.whl", hash = "sha256:aaf159caa35993cb1f56fb9b8e4610d35758e7ca005412eb1daa856a78c9c4b1", size = 6010196, upload-time = "2026-05-18T23:36:05.92Z" },
+    { url = "https://files.pythonhosted.org/packages/df/ac/46de6dda46478f7942f839e094970be2d4a861e005c4b3bf07c92e291a09/numpy-2.4.6-cp314-cp314-win_amd64.whl", hash = "sha256:b507f5c4c1d508876d1819b6bf9a49d365b96320b5d4993426b33a23ca4b8261", size = 12450334, upload-time = "2026-05-18T23:36:09.107Z" },
+    { url = "https://files.pythonhosted.org/packages/78/92/b8b798ac784102c0da830d2257d59358e3d3d90d1e2b3f2575dad976c5cf/numpy-2.4.6-cp314-cp314-win_arm64.whl", hash = "sha256:6f41ae150c4e32db4f3310cdaf64b1593a03dbabe29eec77fc9b50fe64061df6", size = 10495678, upload-time = "2026-05-18T23:36:12.766Z" },
+    { url = "https://files.pythonhosted.org/packages/30/34/ec28d1aa8115971537c01469ab2011ee96827930f0a124de1000cc2a7ed7/numpy-2.4.6-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ece3d2cfe132e7d51f44a832b303895e6f2d499c5e74dfbdb06ee246147a304a", size = 14823672, upload-time = "2026-05-18T23:36:16.473Z" },
+    { url = "https://files.pythonhosted.org/packages/16/bd/f6d1fede4e54e8042a7ff97bb495510f3c220f94bcd9e8b228e87c92cc0d/numpy-2.4.6-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:e3e5193ef5a3dc73bceee50f7fdc2c90dbb76c42df8d8fae3d1067a583df579e", size = 5328731, upload-time = "2026-05-18T23:36:19.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f0/e105b9e2fd728a9910103884decd6951d9dd73896b914a98d9a231de02ee/numpy-2.4.6-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:17f9ade344e7d9b464a084d69bcf18fc691cb1db67c62ed80820bf4926d78f0e", size = 6649805, upload-time = "2026-05-18T23:36:22.266Z" },
+    { url = "https://files.pythonhosted.org/packages/82/dd/1206a7ca6ab15e3f02069707ca96222e202af681bb73756da7527f3cb837/numpy-2.4.6-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cd5ffd25db4e7ba6a375693b3fc0fc1791ec636c17db3720da19bde7180ec43", size = 15730496, upload-time = "2026-05-18T23:36:25.713Z" },
+    { url = "https://files.pythonhosted.org/packages/51/e7/38d3ea825dcab85a591734decb2f6c67caa7c8367d374df1a1c3842f9b07/numpy-2.4.6-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7d92c3819208a60205a12a245c91ad70cb0a85336659b19b834205573ac8456e", size = 16679616, upload-time = "2026-05-18T23:36:29.652Z" },
+    { url = "https://files.pythonhosted.org/packages/93/b7/caabfdf53edf663e0b4eb74d7d405d83baef09eb5e83bcd32d601d72b93e/numpy-2.4.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e85b752a1e912b70eaad4fafbd4d1238007ab221de2009b9a2f5ae7461239895", size = 17085145, upload-time = "2026-05-18T23:36:33.449Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/45/68d7c33a6bcf3e5aa3bdbd57a367e6f615286dfd6482f97e8ffeb734306e/numpy-2.4.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:29cb7f67d10b479ff07c17d33e39f78c07f71c40ef30d63c153d340e96cd3fb4", size = 18403813, upload-time = "2026-05-18T23:36:37.369Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/50/0753655aa844c99cd9e018aacf76f130f1bd81d881bb74bc0aef5d73a8ba/numpy-2.4.6-cp314-cp314t-win32.whl", hash = "sha256:260a5d70215b61ab4fadf5c7baacd64821842975eea312125ed3c39a6391b063", size = 6156982, upload-time = "2026-05-18T23:36:40.817Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/d4/7c67becf668f973cb490cec3e98dfd799d866f9c989a54d355672cfa0db6/numpy-2.4.6-cp314-cp314t-win_amd64.whl", hash = "sha256:81a1cca95ed5bb92aa8b10dd2cdc9a0d3853a50fad926c28b5d7e8ea54389627", size = 12638908, upload-time = "2026-05-18T23:36:43.996Z" },
+    { url = "https://files.pythonhosted.org/packages/43/bb/e1c71a4295b1b1d1393d50dbb4f2a36283c6859d9d3892e84f00ec5a91d5/numpy-2.4.6-cp314-cp314t-win_arm64.whl", hash = "sha256:0c9136e14ed34a9e343a31c533d78a9813a69a3148332bce5e9821cb2f996e66", size = 10565867, upload-time = "2026-05-18T23:36:47.114Z" },
+    { url = "https://files.pythonhosted.org/packages/de/12/b422cc84439adc0d00de605bf4a308890ae5c26f2c71fbd73e5d08fbb0dd/numpy-2.4.6-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:55cced7c52e981362f708ad635198e97a752dfba412cc03c23bbf3bd8d5cd662", size = 16847511, upload-time = "2026-05-18T23:36:50.673Z" },
+    { url = "https://files.pythonhosted.org/packages/44/53/f481bef68011740f8849418d82db07230e825013f31f4eef5ba5b805316a/numpy-2.4.6-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d6da64deb6b8ed903e7560180a92f2d804ee1ba5eeb849ac2748b8c1aba1f6d7", size = 14889064, upload-time = "2026-05-18T23:36:53.879Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/57/42ed575c10ced8af951d426bc4e1f8aff16fd851db33f067036215a7f860/numpy-2.4.6-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:68a5124b13fa6cc2086764a20005d30bc0548146f7f5322f02fce212ca14317f", size = 5394157, upload-time = "2026-05-18T23:36:57.194Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/ef/f66cc724fcc36c1e364c67f51ae9146090b8b584f27d58b97fdae3edd737/numpy-2.4.6-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:948424b06129ce883307e8cff868c31396d8dc7630a59c61d70d98dbe70f222c", size = 6708728, upload-time = "2026-05-18T23:36:59.575Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/9c/c531f2293b91265d8b48e9b329f54fdd7ffae73cb4134ea10cca4237e9cc/numpy-2.4.6-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5dbbdb29840ca3d91ee0fece42fc29278886d908280bfec0a5846c6f901a3eb0", size = 15798374, upload-time = "2026-05-18T23:37:02.674Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/b0/413077f6b1153ed3cba361401c6783bbad6114804a000cc22eb71c13e190/numpy-2.4.6-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ad03c0965fb3c692200e74d458ca28c1dbb4ce96f9a479a8aa041ad5fabca02", size = 16747286, upload-time = "2026-05-18T23:37:06.327Z" },
+    { url = "https://files.pythonhosted.org/packages/15/ce/e5ec180bc41812edcd8daeb8639d205622c0e8c02259d8ab25a0201b3c2a/numpy-2.4.6-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:2803abfebfc990042cd494d8ce2d5f82e9d847af6d35ec486923aa19dbad5e73", size = 12504263, upload-time = "2026-05-18T23:37:09.715Z" },
+]
+
 [[package]]
 name = "packaging"
 version = "26.2"
@@ -407,6 +570,180 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" },
 ]
 
+[[package]]
+name = "pandas"
+version = "2.3.3"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11'",
+]
+dependencies = [
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "python-dateutil", marker = "python_full_version < '3.11'" },
+    { name = "pytz", marker = "python_full_version < '3.11'" },
+    { name = "tzdata", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", hash = "sha256:e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b", size = 4495223, upload-time = "2025-09-29T23:34:51.853Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3d/f7/f425a00df4fcc22b292c6895c6831c0c8ae1d9fac1e024d16f98a9ce8749/pandas-2.3.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:376c6446ae31770764215a6c937f72d917f214b43560603cd60da6408f183b6c", size = 11555763, upload-time = "2025-09-29T23:16:53.287Z" },
+    { url = "https://files.pythonhosted.org/packages/13/4f/66d99628ff8ce7857aca52fed8f0066ce209f96be2fede6cef9f84e8d04f/pandas-2.3.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e19d192383eab2f4ceb30b412b22ea30690c9e618f78870357ae1d682912015a", size = 10801217, upload-time = "2025-09-29T23:17:04.522Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/03/3fc4a529a7710f890a239cc496fc6d50ad4a0995657dccc1d64695adb9f4/pandas-2.3.3-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5caf26f64126b6c7aec964f74266f435afef1c1b13da3b0636c7518a1fa3e2b1", size = 12148791, upload-time = "2025-09-29T23:17:18.444Z" },
+    { url = "https://files.pythonhosted.org/packages/40/a8/4dac1f8f8235e5d25b9955d02ff6f29396191d4e665d71122c3722ca83c5/pandas-2.3.3-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dd7478f1463441ae4ca7308a70e90b33470fa593429f9d4c578dd00d1fa78838", size = 12769373, upload-time = "2025-09-29T23:17:35.846Z" },
+    { url = "https://files.pythonhosted.org/packages/df/91/82cc5169b6b25440a7fc0ef3a694582418d875c8e3ebf796a6d6470aa578/pandas-2.3.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:4793891684806ae50d1288c9bae9330293ab4e083ccd1c5e383c34549c6e4250", size = 13200444, upload-time = "2025-09-29T23:17:49.341Z" },
+    { url = "https://files.pythonhosted.org/packages/10/ae/89b3283800ab58f7af2952704078555fa60c807fff764395bb57ea0b0dbd/pandas-2.3.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:28083c648d9a99a5dd035ec125d42439c6c1c525098c58af0fc38dd1a7a1b3d4", size = 13858459, upload-time = "2025-09-29T23:18:03.722Z" },
+    { url = "https://files.pythonhosted.org/packages/85/72/530900610650f54a35a19476eca5104f38555afccda1aa11a92ee14cb21d/pandas-2.3.3-cp310-cp310-win_amd64.whl", hash = "sha256:503cf027cf9940d2ceaa1a93cfb5f8c8c7e6e90720a2850378f0b3f3b1e06826", size = 11346086, upload-time = "2025-09-29T23:18:18.505Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/fa/7ac648108144a095b4fb6aa3de1954689f7af60a14cf25583f4960ecb878/pandas-2.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:602b8615ebcc4a0c1751e71840428ddebeb142ec02c786e8ad6b1ce3c8dec523", size = 11578790, upload-time = "2025-09-29T23:18:30.065Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/35/74442388c6cf008882d4d4bdfc4109be87e9b8b7ccd097ad1e7f006e2e95/pandas-2.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8fe25fc7b623b0ef6b5009149627e34d2a4657e880948ec3c840e9402e5c1b45", size = 10833831, upload-time = "2025-09-29T23:38:56.071Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/e4/de154cbfeee13383ad58d23017da99390b91d73f8c11856f2095e813201b/pandas-2.3.3-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b468d3dad6ff947df92dcb32ede5b7bd41a9b3cceef0a30ed925f6d01fb8fa66", size = 12199267, upload-time = "2025-09-29T23:18:41.627Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/c9/63f8d545568d9ab91476b1818b4741f521646cbdd151c6efebf40d6de6f7/pandas-2.3.3-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b98560e98cb334799c0b07ca7967ac361a47326e9b4e5a7dfb5ab2b1c9d35a1b", size = 12789281, upload-time = "2025-09-29T23:18:56.834Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/00/a5ac8c7a0e67fd1a6059e40aa08fa1c52cc00709077d2300e210c3ce0322/pandas-2.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37b5848ba49824e5c30bedb9c830ab9b7751fd049bc7914533e01c65f79791", size = 13240453, upload-time = "2025-09-29T23:19:09.247Z" },
+    { url = "https://files.pythonhosted.org/packages/27/4d/5c23a5bc7bd209231618dd9e606ce076272c9bc4f12023a70e03a86b4067/pandas-2.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:db4301b2d1f926ae677a751eb2bd0e8c5f5319c9cb3f88b0becbbb0b07b34151", size = 13890361, upload-time = "2025-09-29T23:19:25.342Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/59/712db1d7040520de7a4965df15b774348980e6df45c129b8c64d0dbe74ef/pandas-2.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:f086f6fe114e19d92014a1966f43a3e62285109afe874f067f5abbdcbb10e59c", size = 11348702, upload-time = "2025-09-29T23:19:38.296Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/fb/231d89e8637c808b997d172b18e9d4a4bc7bf31296196c260526055d1ea0/pandas-2.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d21f6d74eb1725c2efaa71a2bfc661a0689579b58e9c0ca58a739ff0b002b53", size = 11597846, upload-time = "2025-09-29T23:19:48.856Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/bd/bf8064d9cfa214294356c2d6702b716d3cf3bb24be59287a6a21e24cae6b/pandas-2.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3fd2f887589c7aa868e02632612ba39acb0b8948faf5cc58f0850e165bd46f35", size = 10729618, upload-time = "2025-09-29T23:39:08.659Z" },
+    { url = "https://files.pythonhosted.org/packages/57/56/cf2dbe1a3f5271370669475ead12ce77c61726ffd19a35546e31aa8edf4e/pandas-2.3.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ecaf1e12bdc03c86ad4a7ea848d66c685cb6851d807a26aa245ca3d2017a1908", size = 11737212, upload-time = "2025-09-29T23:19:59.765Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/63/cd7d615331b328e287d8233ba9fdf191a9c2d11b6af0c7a59cfcec23de68/pandas-2.3.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b3d11d2fda7eb164ef27ffc14b4fcab16a80e1ce67e9f57e19ec0afaf715ba89", size = 12362693, upload-time = "2025-09-29T23:20:14.098Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/de/8b1895b107277d52f2b42d3a6806e69cfef0d5cf1d0ba343470b9d8e0a04/pandas-2.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a68e15f780eddf2b07d242e17a04aa187a7ee12b40b930bfdd78070556550e98", size = 12771002, upload-time = "2025-09-29T23:20:26.76Z" },
+    { url = "https://files.pythonhosted.org/packages/87/21/84072af3187a677c5893b170ba2c8fbe450a6ff911234916da889b698220/pandas-2.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:371a4ab48e950033bcf52b6527eccb564f52dc826c02afd9a1bc0ab731bba084", size = 13450971, upload-time = "2025-09-29T23:20:41.344Z" },
+    { url = "https://files.pythonhosted.org/packages/86/41/585a168330ff063014880a80d744219dbf1dd7a1c706e75ab3425a987384/pandas-2.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:a16dcec078a01eeef8ee61bf64074b4e524a2a3f4b3be9326420cabe59c4778b", size = 10992722, upload-time = "2025-09-29T23:20:54.139Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/4b/18b035ee18f97c1040d94debd8f2e737000ad70ccc8f5513f4eefad75f4b/pandas-2.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:56851a737e3470de7fa88e6131f41281ed440d29a9268dcbf0002da5ac366713", size = 11544671, upload-time = "2025-09-29T23:21:05.024Z" },
+    { url = "https://files.pythonhosted.org/packages/31/94/72fac03573102779920099bcac1c3b05975c2cb5f01eac609faf34bed1ca/pandas-2.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bdcd9d1167f4885211e401b3036c0c8d9e274eee67ea8d0758a256d60704cfe8", size = 10680807, upload-time = "2025-09-29T23:21:15.979Z" },
+    { url = "https://files.pythonhosted.org/packages/16/87/9472cf4a487d848476865321de18cc8c920b8cab98453ab79dbbc98db63a/pandas-2.3.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e32e7cc9af0f1cc15548288a51a3b681cc2a219faa838e995f7dc53dbab1062d", size = 11709872, upload-time = "2025-09-29T23:21:27.165Z" },
+    { url = "https://files.pythonhosted.org/packages/15/07/284f757f63f8a8d69ed4472bfd85122bd086e637bf4ed09de572d575a693/pandas-2.3.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:318d77e0e42a628c04dc56bcef4b40de67918f7041c2b061af1da41dcff670ac", size = 12306371, upload-time = "2025-09-29T23:21:40.532Z" },
+    { url = "https://files.pythonhosted.org/packages/33/81/a3afc88fca4aa925804a27d2676d22dcd2031c2ebe08aabd0ae55b9ff282/pandas-2.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4e0a175408804d566144e170d0476b15d78458795bb18f1304fb94160cabf40c", size = 12765333, upload-time = "2025-09-29T23:21:55.77Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/0f/b4d4ae743a83742f1153464cf1a8ecfafc3ac59722a0b5c8602310cb7158/pandas-2.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:93c2d9ab0fc11822b5eece72ec9587e172f63cff87c00b062f6e37448ced4493", size = 13418120, upload-time = "2025-09-29T23:22:10.109Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/c7/e54682c96a895d0c808453269e0b5928a07a127a15704fedb643e9b0a4c8/pandas-2.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:f8bfc0e12dc78f777f323f55c58649591b2cd0c43534e8355c51d3fede5f4dee", size = 10993991, upload-time = "2025-09-29T23:25:04.889Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/ca/3f8d4f49740799189e1395812f3bf23b5e8fc7c190827d55a610da72ce55/pandas-2.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:75ea25f9529fdec2d2e93a42c523962261e567d250b0013b16210e1d40d7c2e5", size = 12048227, upload-time = "2025-09-29T23:22:24.343Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/5a/f43efec3e8c0cc92c4663ccad372dbdff72b60bdb56b2749f04aa1d07d7e/pandas-2.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:74ecdf1d301e812db96a465a525952f4dde225fdb6d8e5a521d47e1f42041e21", size = 11411056, upload-time = "2025-09-29T23:22:37.762Z" },
+    { url = "https://files.pythonhosted.org/packages/46/b1/85331edfc591208c9d1a63a06baa67b21d332e63b7a591a5ba42a10bb507/pandas-2.3.3-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6435cb949cb34ec11cc9860246ccb2fdc9ecd742c12d3304989017d53f039a78", size = 11645189, upload-time = "2025-09-29T23:22:51.688Z" },
+    { url = "https://files.pythonhosted.org/packages/44/23/78d645adc35d94d1ac4f2a3c4112ab6f5b8999f4898b8cdf01252f8df4a9/pandas-2.3.3-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:900f47d8f20860de523a1ac881c4c36d65efcb2eb850e6948140fa781736e110", size = 12121912, upload-time = "2025-09-29T23:23:05.042Z" },
+    { url = "https://files.pythonhosted.org/packages/53/da/d10013df5e6aaef6b425aa0c32e1fc1f3e431e4bcabd420517dceadce354/pandas-2.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a45c765238e2ed7d7c608fc5bc4a6f88b642f2f01e70c0c23d2224dd21829d86", size = 12712160, upload-time = "2025-09-29T23:23:28.57Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/17/e756653095a083d8a37cbd816cb87148debcfcd920129b25f99dd8d04271/pandas-2.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c4fc4c21971a1a9f4bdb4c73978c7f7256caa3e62b323f70d6cb80db583350bc", size = 13199233, upload-time = "2025-09-29T23:24:24.876Z" },
+    { url = "https://files.pythonhosted.org/packages/04/fd/74903979833db8390b73b3a8a7d30d146d710bd32703724dd9083950386f/pandas-2.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:ee15f284898e7b246df8087fc82b87b01686f98ee67d85a17b7ab44143a3a9a0", size = 11540635, upload-time = "2025-09-29T23:25:52.486Z" },
+    { url = "https://files.pythonhosted.org/packages/21/00/266d6b357ad5e6d3ad55093a7e8efc7dd245f5a842b584db9f30b0f0a287/pandas-2.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1611aedd912e1ff81ff41c745822980c49ce4a7907537be8692c8dbc31924593", size = 10759079, upload-time = "2025-09-29T23:26:33.204Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/05/d01ef80a7a3a12b2f8bbf16daba1e17c98a2f039cbc8e2f77a2c5a63d382/pandas-2.3.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6d2cefc361461662ac48810cb14365a365ce864afe85ef1f447ff5a1e99ea81c", size = 11814049, upload-time = "2025-09-29T23:27:15.384Z" },
+    { url = "https://files.pythonhosted.org/packages/15/b2/0e62f78c0c5ba7e3d2c5945a82456f4fac76c480940f805e0b97fcbc2f65/pandas-2.3.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ee67acbbf05014ea6c763beb097e03cd629961c8a632075eeb34247120abcb4b", size = 12332638, upload-time = "2025-09-29T23:27:51.625Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/33/dd70400631b62b9b29c3c93d2feee1d0964dc2bae2e5ad7a6c73a7f25325/pandas-2.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c46467899aaa4da076d5abc11084634e2d197e9460643dd455ac3db5856b24d6", size = 12886834, upload-time = "2025-09-29T23:28:21.289Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/18/b5d48f55821228d0d2692b34fd5034bb185e854bdb592e9c640f6290e012/pandas-2.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6253c72c6a1d990a410bc7de641d34053364ef8bcd3126f7e7450125887dffe3", size = 13409925, upload-time = "2025-09-29T23:28:58.261Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/3d/124ac75fcd0ecc09b8fdccb0246ef65e35b012030defb0e0eba2cbbbe948/pandas-2.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:1b07204a219b3b7350abaae088f451860223a52cfb8a6c53358e7948735158e5", size = 11109071, upload-time = "2025-09-29T23:32:27.484Z" },
+    { url = "https://files.pythonhosted.org/packages/89/9c/0e21c895c38a157e0faa1fb64587a9226d6dd46452cac4532d80c3c4a244/pandas-2.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2462b1a365b6109d275250baaae7b760fd25c726aaca0054649286bcfbb3e8ec", size = 12048504, upload-time = "2025-09-29T23:29:31.47Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/82/b69a1c95df796858777b68fbe6a81d37443a33319761d7c652ce77797475/pandas-2.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0242fe9a49aa8b4d78a4fa03acb397a58833ef6199e9aa40a95f027bb3a1b6e7", size = 11410702, upload-time = "2025-09-29T23:29:54.591Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/88/702bde3ba0a94b8c73a0181e05144b10f13f29ebfc2150c3a79062a8195d/pandas-2.3.3-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a21d830e78df0a515db2b3d2f5570610f5e6bd2e27749770e8bb7b524b89b450", size = 11634535, upload-time = "2025-09-29T23:30:21.003Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/1e/1bac1a839d12e6a82ec6cb40cda2edde64a2013a66963293696bbf31fbbb/pandas-2.3.3-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2e3ebdb170b5ef78f19bfb71b0dc5dc58775032361fa188e814959b74d726dd5", size = 12121582, upload-time = "2025-09-29T23:30:43.391Z" },
+    { url = "https://files.pythonhosted.org/packages/44/91/483de934193e12a3b1d6ae7c8645d083ff88dec75f46e827562f1e4b4da6/pandas-2.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d051c0e065b94b7a3cea50eb1ec32e912cd96dba41647eb24104b6c6c14c5788", size = 12699963, upload-time = "2025-09-29T23:31:10.009Z" },
+    { url = "https://files.pythonhosted.org/packages/70/44/5191d2e4026f86a2a109053e194d3ba7a31a2d10a9c2348368c63ed4e85a/pandas-2.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3869faf4bd07b3b66a9f462417d0ca3a9df29a9f6abd5d0d0dbab15dac7abe87", size = 13202175, upload-time = "2025-09-29T23:31:59.173Z" },
+]
+
+[[package]]
+name = "pandas"
+version = "3.0.3"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.15' and sys_platform == 'win32'",
+    "python_full_version >= '3.15' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.15' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version == '3.14.*' and sys_platform == 'win32'",
+    "python_full_version == '3.14.*' and sys_platform == 'emscripten'",
+    "python_full_version == '3.14.*' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+]
+dependencies = [
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "python-dateutil", marker = "python_full_version >= '3.11'" },
+    { name = "tzdata", marker = "(python_full_version >= '3.11' and sys_platform == 'emscripten') or (python_full_version >= '3.11' and sys_platform == 'win32')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f8/87/4341c6252d1c47b08768c3d25ac487362bf403f0313ddae4a2a26c9b1b4c/pandas-3.0.3.tar.gz", hash = "sha256:696a4a00a2a2a35d4e5deb3fc946641b96c944f02230e4f76137fe35d806c4fc", size = 4651414, upload-time = "2026-05-11T18:54:29.21Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/42/16/b5c76b838fd9bf6ce84d3a53346b8874ec05c5f0040d75ef2c320100cd2a/pandas-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:455f6f8139d4282188f526868dbc3c828470e88a3d9d59a891bd46a455f21b98", size = 10338495, upload-time = "2026-05-11T18:52:11.558Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/b0/a4ffc4ae74d2d822200dcc46898987d8eb6032d1e2b219cae39da6f5cbcc/pandas-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4e15135e2ee5df1063313e2425ceef8ac0f4ae775893815b0923651b806a5639", size = 9938250, upload-time = "2026-05-11T18:52:17.005Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/b2/3323601a52caee42c019e370090ca4544b241437240ca04f786cce82b0cf/pandas-3.0.3-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:05f1f1752b8533ea03f7f39a9c15b1a058d067bb48f4748948e7a8691e0510f2", size = 10770558, upload-time = "2026-05-11T18:52:19.865Z" },
+    { url = "https://files.pythonhosted.org/packages/32/f1/bbecd2f867b97abebe0f9b53d750f862251b40337e061b36676ded3d920f/pandas-3.0.3-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8a1e45c80cceb3b4a21bc5939d52e8cbd8d9b7305309219d59e9754d9ce09e27", size = 11274611, upload-time = "2026-05-11T18:52:22.622Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/4f/eafabf2d5fae5adf143b4d18d3706c5efdc368a7c4eb1ee8a3eddabbd0f6/pandas-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:14da8316da4d0c5a77618425996bfb1248ca87fc2c1486e6fde4652bd18b5824", size = 11784670, upload-time = "2026-05-11T18:52:25.4Z" },
+    { url = "https://files.pythonhosted.org/packages/49/44/1eb20389301b57b19cc099a1c2f662501f72f08a65f912d05822613c1532/pandas-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a55066a0505dae0ba2b50a46637db34b46f9094c65c5d4800794ef6335010938", size = 12353708, upload-time = "2026-05-11T18:52:28.139Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/62/c321f13b5ba1819fc8dca456c7fce578da2dcfecff1abbf0eaddf8406c0f/pandas-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:6674ab18ad8c57802867264b00e15e7bb904700cdd9046e3b2fa1fce237439ea", size = 9907609, upload-time = "2026-05-11T18:52:30.982Z" },
+    { url = "https://files.pythonhosted.org/packages/53/85/1b7f563ebc6357c27233a02a96b589bcce1fa9c6eb89fb4f0e56421d277e/pandas-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:5cc09a68b3120e0f54870dede8287a7bb1fa463907e4fcec1ea77cab6179bf7a", size = 9165596, upload-time = "2026-05-11T18:52:33.334Z" },
+    { url = "https://files.pythonhosted.org/packages/24/f1/392f8c5bfc16f66a0d2d41561c01627c228fe7ed2a0d056ef11315042570/pandas-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fed2ff7fd9779120e388e285fc029bd5cf9490cdd2e4166a9ee22c0e49a9ab09", size = 10357846, upload-time = "2026-05-11T18:52:36.143Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/3d/b16412745651e855f357e5e66930248688378853a6e2698a214e331fba1f/pandas-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b168fc218fd80a6cbdbdbc1a97ddc7889ed057d7eb45f50d866ceab5f39904c4", size = 9899550, upload-time = "2026-05-11T18:52:38.976Z" },
+    { url = "https://files.pythonhosted.org/packages/31/a8/fa2535168fffcedf67f4f6de28d2dd903a747ca7c8ea6989451aaeb3a92f/pandas-3.0.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0383c72c75cdcca61a9e116e611143902dbfd08bff356829c2f6d1cf40a9ca8c", size = 10412965, upload-time = "2026-05-11T18:52:41.915Z" },
+    { url = "https://files.pythonhosted.org/packages/65/b6/09b01cdbc15224e2850365192d17b7bdebb8bdbd8780ed221fcdf0d9a515/pandas-3.0.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6dc0b3fd2169c9157deed50b4d519553a3655c8c6a96027136d654592be973a9", size = 10894600, upload-time = "2026-05-11T18:52:45.02Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/a4/2eb28f2fccb4ced4a2c79ab2a5dee9ade1ebf44922ebad6fea158c9f95d4/pandas-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7e65d5407dc0b394f509699650e4a2ec01c0514f21850f453fa60f3be79a5dbf", size = 11422824, upload-time = "2026-05-11T18:52:48.058Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/45/830bb57f533a4604b355e07edcb8ea18cf88b5f94e5fca92f27052d7c597/pandas-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f8894dc474d648fe7b6ff0ca9b0bd73950d19952bc1a6534540762c5d79d305c", size = 11950889, upload-time = "2026-05-11T18:52:50.905Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/c5/fc1b368f303087d20e8c9bf3d6ceb186263cfac0ade735cd938538bea839/pandas-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:c7be265b62cef88e253a941e4698604973736dcfe242fdb5198f0f7bc473cdcc", size = 9755463, upload-time = "2026-05-11T18:52:53.386Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bd/fda8f9705b1b09c6ebe14bfc0fa0e4ec8584d54ea673628f157ff55131af/pandas-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:557409bc4178e70ee8d9ddb494798e51ebf6ea59330f6be22c51bab2a7db6c49", size = 9066158, upload-time = "2026-05-11T18:52:56.038Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/90/62d8302883c44308c477e222c3daf7c813a34c8e96985882fbd53d964352/pandas-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:67b3b64c11910cfa29f4e94a14d3bff9ee693b6fc76055e7cad549cee0aec5fa", size = 10331071, upload-time = "2026-05-11T18:52:58.838Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/ae/6a6493c783a101f165e4356953ba3c74d6f77f0042fa7d753da9dfbb640c/pandas-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:39436b377d56d2a2e52d0395bdbee171f01068e99af5250509aceeb929f765c7", size = 9875690, upload-time = "2026-05-11T18:53:01.431Z" },
+    { url = "https://files.pythonhosted.org/packages/62/7c/5df8e9f56c69a2769fbe9382a5ef8f2658c007e376434e1e2cbb57ad895f/pandas-3.0.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d4be06d68f9ddcfc645b87534911da79a8fbffc7573c80e0edcf42a5020624d8", size = 10381634, upload-time = "2026-05-11T18:53:04.393Z" },
+    { url = "https://files.pythonhosted.org/packages/99/68/1237369725aa617bb358263d535803e3053fdbc593513ec5ed9c9896b5b6/pandas-3.0.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a4eeb6830daf35a71cc09649bd823e2b542dac246cdee9614c6e4bd65028cd6a", size = 10891243, upload-time = "2026-05-11T18:53:07.643Z" },
+    { url = "https://files.pythonhosted.org/packages/25/93/77d108e8af7222b4a503ebde0e30215b1c2e4f8e53a526431890f22d5586/pandas-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1928e07221f82db493cd4af1e23c1bfca524a19a4699887975bff68f49a72bfb", size = 11388659, upload-time = "2026-05-11T18:53:10.634Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/bd/eff5b4399f332ac386c853f6cd2bd3fa2ca0061b9f36ecd9c4d7c4265649/pandas-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51b1fe551acb77dac643c6fda86084d8d446c10fe64b06a9cc29c4cc8540e7f2", size = 11942880, upload-time = "2026-05-11T18:53:13.536Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/20/559ace4200982c3887d0b86bfd0d856a2143ef8ddab63cc07934951a964c/pandas-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:a82d532a3351d435432cd913edbccaf8b8e01d4dd0e5ced5a8d2e8ecd94c7e44", size = 9757091, upload-time = "2026-05-11T18:53:16.306Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/66/69055a09fe200f29f922a3eeec4804611900b95f52d932ece3393c3c0c19/pandas-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:275c14e0fce14a2ec20eee474aecd305478ea3c1e6f6a9d8fe219a165542717e", size = 9057282, upload-time = "2026-05-11T18:53:18.768Z" },
+    { url = "https://files.pythonhosted.org/packages/57/0e/efe801b0e6811e8e650cd21b7f2608e30f08a7067e2bf6e8752b0d56ee3c/pandas-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:46997386d528eb40376ecd6b033cf4a8a1e5282580f68f43de875b78cba2199d", size = 10767016, upload-time = "2026-05-11T18:53:21.227Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/dc/eb55135a1d5f0f0519f28da1f609a206d2cad1f9c35c32d51e38dd7261ae/pandas-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:261e308dfb22448384b7580cf719d2f998fe2966c92893c3e77d14008af1f066", size = 10420210, upload-time = "2026-05-11T18:53:23.982Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/3e/b1d5d955ce33ffecb407465a60bc32769d74fcf68224b7ae67ae11d4dea4/pandas-3.0.3-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dd1a5d1def6a46002e964510bdc67c368aa0951df5d1d9f8365336f5a1f490cd", size = 10336126, upload-time = "2026-05-11T18:53:26.731Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/76/a01261711ab60a22d71b862f0de20e4c504bf80457270ad8cb42110f6abc/pandas-3.0.3-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d72828c20c6d6e83e1e22a6a3b47b326b71664112fa9705dcbccfd7a39b62085", size = 10728051, upload-time = "2026-05-11T18:53:29.125Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/21/ea191195e587b18cf682e97f433f81b2d0fbe341380e80a3e0d6e4403c8e/pandas-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:d26cbe1fcfc12e8fd900e2454163e466b2d3af84f7c75481df7683ffc073d870", size = 11350796, upload-time = "2026-05-11T18:53:32.056Z" },
+    { url = "https://files.pythonhosted.org/packages/64/69/f0eaaf54939f0e8c6768fd06be9af2cef9b36048b96dfb9e1b2c685a807e/pandas-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:3e91cec1879ada0624fc3dc9953c5cbd60208e59c0db28f540c5d6d47502422f", size = 11799741, upload-time = "2026-05-11T18:53:34.985Z" },
+    { url = "https://files.pythonhosted.org/packages/45/a4/865e0e510cae5fc2194de4db28be638952de942571ba9125934fd9c01d47/pandas-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:08d789b41f87e0905880e293cedf6197ce71fe67cc081358b1e148a491b9bd13", size = 10499958, upload-time = "2026-05-11T18:53:37.857Z" },
+    { url = "https://files.pythonhosted.org/packages/86/54/effdcc3c0ff7a08037889200e148ebe94c16c4f653be078c7b3675955df1/pandas-3.0.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:3650109c0f22879df8bd6179ab9ee3d7f1d1d4e7e0094a3f0032d9f51e2e64ac", size = 10336065, upload-time = "2026-05-11T18:53:41.099Z" },
+    { url = "https://files.pythonhosted.org/packages/68/10/bf2d6738d72748b961a3751ab89522d58c54efc36a8e1a12161216cd45cf/pandas-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:bab900348131a7db1f69a7309ef141fd5680f1487094193bcbbb61791573bf8f", size = 9926101, upload-time = "2026-05-11T18:53:43.515Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/e9/e35cf11c8a136e757b956f5f0efdcaa50aecde85ea055f1898dfc68262f3/pandas-3.0.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ba7e08b9ac1d54569cd1e256e3668975ed624d6826f7b68df0342b012007bddb", size = 10457553, upload-time = "2026-05-11T18:53:46.394Z" },
+    { url = "https://files.pythonhosted.org/packages/58/3b/1cdec6772bdbaf7b25dab360c59f03cadf05492dd724c6540af905389b07/pandas-3.0.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d71c63ae4ebdbf70209742096f1fc46a83a0613c99d4b23766cced9ff8cd62a", size = 10914065, upload-time = "2026-05-11T18:53:49.134Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/c2/1ef644445fcd72e3627bceec77e3560636f87ddce4ed841afe76b83b5bf9/pandas-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e3a2ec42c98ffa2565a67e08e218d06d72576d758d90facb7c00805194d8f360", size = 11459188, upload-time = "2026-05-11T18:53:52.527Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/49/4d8d4f42cbc9c4adc7a1870f269c02cbd6cd40d059622c06fb298addcbad/pandas-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:335f62418ed562cfc3c49e9e196375c28b729dcef8543abf4f9438e381bf3c76", size = 11982966, upload-time = "2026-05-11T18:53:55.043Z" },
+    { url = "https://files.pythonhosted.org/packages/38/55/792619469bab9882d8bbd5865d45a72f6478762d04a9af4bf0d08c503e95/pandas-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:3c20a521bbb85902f79f7270c80a59e1b5452d96d170c034f207181870f97ac5", size = 9876755, upload-time = "2026-05-11T18:53:58.067Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/af/33c469653b0ba03b50c3a98192d4c07f0c75c66b263ceb097fce0ee97d31/pandas-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:a2d2dff8a04f3917b55ab3910c32990f8ddf7eceba114947838cefa976a68977", size = 9198658, upload-time = "2026-05-11T18:54:00.733Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/fa/b8c257bd76b8bd060c3a9151c1fca05e9b9c5e3af5d0f549c0356f6d143d/pandas-3.0.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:0d589105b3c14645af1738ff279b2995102d8f7a03b0a66dc8d95550eb513e04", size = 10787242, upload-time = "2026-05-11T18:54:03.564Z" },
+    { url = "https://files.pythonhosted.org/packages/54/eb/f19206ffb0bf1919002969aa448b4702c6594845156a6f8050674855aac3/pandas-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:13fc1e853d9e04743d11ba75a985ccbc2a317fe07d8af61e445a6fd24dacd6a6", size = 10436369, upload-time = "2026-05-11T18:54:06.311Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/24/c7c39fb4fe22b71a0c2d78bf0c585c600092d85f94f086d2b3b2f6ca27e2/pandas-3.0.3-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:819959dab7bbd0049c15623fbac4e29a191b9528160a61fb1032242d8ced2d9c", size = 10358306, upload-time = "2026-05-11T18:54:09.085Z" },
+    { url = "https://files.pythonhosted.org/packages/16/ec/dd2a9eb7fa1204df88c0864164e35b228ac581062ac612ba0a67fd812e4c/pandas-3.0.3-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:60ae316d3fd75d1858d450d0db0103ea2be3e7d4a95ec2f064f7e2ae63f7b028", size = 10758394, upload-time = "2026-05-11T18:54:11.956Z" },
+    { url = "https://files.pythonhosted.org/packages/95/6e/00c61ea8e85b4f6d8d35e11852a1a4998fc7fafc91c6a602d1cc9c972d64/pandas-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bd3a518890b400d32f9023722dc9a9a5c969f00b415419a3c06c043f09bb5d7d", size = 11375717, upload-time = "2026-05-11T18:54:14.539Z" },
+    { url = "https://files.pythonhosted.org/packages/31/89/8fc1c268969fac43688d65fd92e67df24bd128d53cb4d2eee534cd307399/pandas-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:9c39be2d709d01fa972a0cabc522389fceca4f3969332ba25a7d6c5802cf976a", size = 11828897, upload-time = "2026-05-11T18:54:17.146Z" },
+    { url = "https://files.pythonhosted.org/packages/56/3b/e7d20dea247a3e6dc0bd8a6953854afbedc03951def4e7371e05e7263e25/pandas-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4db8c527972a821cf5286b40ccc57642a39bc62e62022b42f99f8a67fca8c3a1", size = 10900855, upload-time = "2026-05-11T18:54:19.72Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/54/68a0978d1ef8502b8492099beaa6e7a0c1b32e3b5d4f677f5810cb08711c/pandas-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b2c95f8bfc1ee412bf482605d7bfd30c12d1d26bd59fdd91efeef1d4718decb1", size = 9466464, upload-time = "2026-05-11T18:54:22.754Z" },
+]
+
+[[package]]
+name = "pandas-stubs"
+version = "2.3.3.260113"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11'",
+]
+dependencies = [
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "types-pytz", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/92/5d/be23854a73fda69f1dbdda7bc10fbd6f930bd1fa87aaec389f00c901c1e8/pandas_stubs-2.3.3.260113.tar.gz", hash = "sha256:076e3724bcaa73de78932b012ec64b3010463d377fa63116f4e6850643d93800", size = 116131, upload-time = "2026-01-13T22:30:16.704Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/c6/df1fe324248424f77b89371116dab5243db7f052c32cc9fe7442ad9c5f75/pandas_stubs-2.3.3.260113-py3-none-any.whl", hash = "sha256:ec070b5c576e1badf12544ae50385872f0631fc35d99d00dc598c2954ec564d3", size = 168246, upload-time = "2026-01-13T22:30:15.244Z" },
+]
+
+[[package]]
+name = "pandas-stubs"
+version = "3.0.3.260530"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.15' and sys_platform == 'win32'",
+    "python_full_version >= '3.15' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.15' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version == '3.14.*' and sys_platform == 'win32'",
+    "python_full_version == '3.14.*' and sys_platform == 'emscripten'",
+    "python_full_version == '3.14.*' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.11' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+]
+dependencies = [
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/aa/c41a8a0ff86fd85dbb3ec0c1f3fa488ca64a8b5f82654ae1b07d84acefe5/pandas_stubs-3.0.3.260530.tar.gz", hash = "sha256:d1efe47b2e5a312c047d7feabec5cb7a55365747983420077e9fcbe9ab74f714", size = 113183, upload-time = "2026-05-30T17:47:40.34Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/e0/99ec5b02203c4e9ce878bc63d8caa06ac1f891e4d63bded9a5ced70fcb4f/pandas_stubs-3.0.3.260530-py3-none-any.whl", hash = "sha256:a6277eb1c8cebf48d9b2413fcd2e9a6b4ff479c934a223c29eacbc3058c4cb55", size = 173780, upload-time = "2026-05-30T17:47:39.13Z" },
+]
+
 [[package]]
 name = "pathspec"
 version = "1.1.1"
@@ -598,33 +935,88 @@ wheels = [
 ]
 
 [[package]]
-name = "python-package-template"
-source = { editable = "." }
+name = "python-dateutil"
+version = "2.9.0.post0"
+source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "pydantic" },
-    { name = "typer" },
+    { name = "six" },
 ]
-
-[package.dev-dependencies]
-dev = [
-    { name = "mypy" },
-    { name = "pytest" },
-    { name = "pytest-cov" },
-    { name = "ruff" },
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
 ]
 
-[package.metadata]
-requires-dist = [
-    { name = "pydantic", specifier = ">=2.0" },
-    { name = "typer", specifier = ">=0.12.0" },
+[[package]]
+name = "pytz"
+version = "2026.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ff/46/dd499ec9038423421951e4fad73051febaa13d2df82b4064f87af8b8c0c3/pytz-2026.2.tar.gz", hash = "sha256:0e60b47b29f21574376f218fe21abc009894a2321ea16c6754f3cad6eb7cdd6a", size = 320861, upload-time = "2026-05-04T01:35:29.667Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/dd/96da98f892250475bdf2328112d7468abdd4acc7b902b6af23f4ed958ea0/pytz-2026.2-py2.py3-none-any.whl", hash = "sha256:04156e608bee23d3792fd45c94ae47fae1036688e75032eea2e3bf0323d1f126", size = 510141, upload-time = "2026-05-04T01:35:27.408Z" },
 ]
 
-[package.metadata.requires-dev]
-dev = [
-    { name = "mypy" },
-    { name = "pytest", specifier = ">=7.0" },
-    { name = "pytest-cov", specifier = ">=7.1.0" },
-    { name = "ruff" },
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" },
+    { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" },
+    { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" },
+    { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" },
+    { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" },
+    { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" },
+    { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
+    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
+    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
+    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
+    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
+    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
 ]
 
 [[package]]
@@ -674,6 +1066,57 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" },
 ]
 
+[[package]]
+name = "six"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
+]
+
+[[package]]
+name = "timetracker-utils"
+source = { editable = "." }
+dependencies = [
+    { name = "pandas", version = "2.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "pandas", version = "3.0.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "pydantic" },
+    { name = "pyyaml" },
+    { name = "typer" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "mypy" },
+    { name = "pandas-stubs", version = "2.3.3.260113", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "pandas-stubs", version = "3.0.3.260530", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "pytest" },
+    { name = "pytest-cov" },
+    { name = "ruff" },
+    { name = "types-pyyaml" },
+    { name = "uv" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "pandas", specifier = ">=2.3.3" },
+    { name = "pydantic", specifier = ">=2.0" },
+    { name = "pyyaml", specifier = ">=6.0.3" },
+    { name = "typer", specifier = ">=0.12.0" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "mypy" },
+    { name = "pandas-stubs", specifier = ">=2.3.3.260113" },
+    { name = "pytest", specifier = ">=7.0" },
+    { name = "pytest-cov", specifier = ">=7.1.0" },
+    { name = "ruff" },
+    { name = "types-pyyaml", specifier = ">=6.0.12.20260518" },
+    { name = "uv", specifier = ">=0.11.21" },
+]
+
 [[package]]
 name = "tomli"
 version = "2.4.1"
@@ -743,6 +1186,24 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/3f/f9/2b3ff4e56e5fa7debfaf9eb135d0da96f3e9a1d5b27222223c7296336e5f/typer-0.25.1-py3-none-any.whl", hash = "sha256:75caa44ed46a03fb2dab8808753ffacdbfea88495e74c85a28c5eefcf5f39c89", size = 58409, upload-time = "2026-04-30T19:32:18.271Z" },
 ]
 
+[[package]]
+name = "types-pytz"
+version = "2026.2.0.20260518"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9f/d9/9fa4019d2235bd374293e1fd4153879b28b6ae1d2bae98addd352c9713f2/types_pytz-2026.2.0.20260518.tar.gz", hash = "sha256:e5d254329e9c4e91f0781b22c43a4bb2d10bb044d97b24c4b05d45567b0eae16", size = 10871, upload-time = "2026-05-18T06:02:45.789Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/89/41e80670779a223d8bc8bc83019a619988cfa5c432cedac5cec23884fbc4/types_pytz-2026.2.0.20260518-py3-none-any.whl", hash = "sha256:3a12eaa38f476bd650902a9c9bb442f03f3c7dee2be5c5848bce61bd708d205a", size = 10125, upload-time = "2026-05-18T06:02:44.968Z" },
+]
+
+[[package]]
+name = "types-pyyaml"
+version = "6.0.12.20260518"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b8/83/4a1afc3fbfcf5b8d46fc390cd95ed6b0dc9010a265f4e9f46314efffa37a/types_pyyaml-6.0.12.20260518.tar.gz", hash = "sha256:d917f83fb38462550338c1297faedd860b3ec83912b96b1e3d73255f7473e466", size = 17850, upload-time = "2026-05-18T06:01:58.675Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/06/a2/c01db32be2ae7d6a1689972f3c492b149ee4e164b12fdfd9f64b50888215/types_pyyaml-6.0.12.20260518-py3-none-any.whl", hash = "sha256:d2150f75a231c9fe9c7463bd29487d93e60bac90400287351384bc2284eba7cd", size = 20312, upload-time = "2026-05-18T06:01:57.368Z" },
+]
+
 [[package]]
 name = "typing-extensions"
 version = "4.15.0"
@@ -763,3 +1224,38 @@ sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac
 wheels = [
     { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
 ]
+
+[[package]]
+name = "tzdata"
+version = "2026.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ba/19/1b9b0e29f30c6d35cb345486df41110984ea67ae69dddbc0e8a100999493/tzdata-2026.2.tar.gz", hash = "sha256:9173fde7d80d9018e02a662e168e5a2d04f87c41ea174b139fbef642eda62d10", size = 198254, upload-time = "2026-04-24T15:22:08.651Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/e4/dccd7f47c4b64213ac01ef921a1337ee6e30e8c6466046018326977efd95/tzdata-2026.2-py2.py3-none-any.whl", hash = "sha256:bbe9af844f658da81a5f95019480da3a89415801f6cc966806612cc7169bffe7", size = 349321, upload-time = "2026-04-24T15:22:05.876Z" },
+]
+
+[[package]]
+name = "uv"
+version = "0.11.21"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f3/f9/f45bb1c251962ee614afd58ccd3dc06ada7869d04987efc2858a81cc4e0f/uv-0.11.21.tar.gz", hash = "sha256:083882c73373a16de4c136d54e3386a52388dead5048a07505e25578b157182f", size = 4259001, upload-time = "2026-06-11T18:18:26.468Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6f/a5/1c863b931f3aba6e07547929b8cb45875038de00678bfd2fbabcd76faeef/uv-0.11.21-py3-none-linux_armv6l.whl", hash = "sha256:48c36eb170a5e7a668c1d13d2c8edeb017a3e6484c224f1521b540a6bda9e50b", size = 23747368, upload-time = "2026-06-11T18:19:21.724Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/8c/66d22f9152a014fbb17b1308394efe274e860b8beb4933f051396f96dd9f/uv-0.11.21-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:88d8283f6ea9f0cdbb7717e6e08e916c32a8b8b7e11c72fcc6426a4c4eeb89e0", size = 22992460, upload-time = "2026-06-11T18:18:33.543Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/f7/31d62c17837c9ae79cc6d5351fc5d54e8926e78b0315b4b6c187e0d1d50d/uv-0.11.21-py3-none-macosx_11_0_arm64.whl", hash = "sha256:9c11169a049ec8bf9ddc6a9f55fba9a240942ec8005faaaf4393f00ff7a4c16e", size = 21762931, upload-time = "2026-06-11T18:18:41.155Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/04/c5503fc1015095db71c280526f45537f3bb06855ce281ff1761b85d149bf/uv-0.11.21-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:00193e4e077c27ee3d66da356744dbf0b3aa59356dfbd9a9efb1dc8469af8ad7", size = 23716032, upload-time = "2026-06-11T18:19:17.03Z" },
+    { url = "https://files.pythonhosted.org/packages/13/ac/46132335772fcdc38e5b5ec76701a8df8e3707605909b5fed46783689501/uv-0.11.21-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l.whl", hash = "sha256:870f48082df673016f465b068f40ad5aa7d2d3cfbcfb4e73724630684003a2ab", size = 23330010, upload-time = "2026-06-11T18:19:00.825Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/d4/cfa1ea36706c32006dea9bf0a819b56c22af8270ea3a2b57562ce96c2d45/uv-0.11.21-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:af08e0d8f43da43bc68930aee56ca5f38ccfbc79d45b6e8a7d5051f1e975684f", size = 23339731, upload-time = "2026-06-11T18:18:52.395Z" },
+    { url = "https://files.pythonhosted.org/packages/96/c5/b34d3cdf05a069c583ef368e6db90242f842d7eb26b246981b3ca8799c27/uv-0.11.21-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4530761c565f3a519a68f36628ee51f2b467b66573e2023e9073641219b60d23", size = 24657820, upload-time = "2026-06-11T18:19:25.62Z" },
+    { url = "https://files.pythonhosted.org/packages/be/b9/89b4e3909111c14311d4a1551afb37f0669587dc1f4ae7e26ec5baea6c09/uv-0.11.21-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:66906cfa7c29c2cf4ea5117cf5614b0b83078ff669e664e2187071fcb24c85c1", size = 25744586, upload-time = "2026-06-11T18:19:09.311Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/7b/51d53d9fb1aaf38a613c2d20b40583ee2aa47fc000724a00aecbd5e61431/uv-0.11.21-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:525ef0eb56ff982357a321eca953307d824ab6f58473630c69521e8085f12b0a", size = 24990030, upload-time = "2026-06-11T18:18:29.618Z" },
+    { url = "https://files.pythonhosted.org/packages/de/70/3347f736911b73df1f31c0823d6502891f3c49fdeb157fe8060b18c08d1c/uv-0.11.21-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b9ecdefa81db7e966d1655988cad6f840316228381dd69131ebc4ae9362bbccd", size = 25110133, upload-time = "2026-06-11T18:19:13.307Z" },
+    { url = "https://files.pythonhosted.org/packages/61/b5/b92538042d78550626ec7ac98b525bcb81ded8605c7ca9d6e35a1454ba71/uv-0.11.21-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:4ed98ff3165bf7b339692d0df918b87e6d36eb0bed5183466330d27d5730d57b", size = 23755172, upload-time = "2026-06-11T18:18:19.189Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/1a/5c8993f95d4384baeaf00b96df0111af3c941a34e4466cde0d52b0b6ad99/uv-0.11.21-py3-none-manylinux_2_31_riscv64.musllinux_1_1_riscv64.whl", hash = "sha256:0e7916874f125a6f6af4cddd95f892ef19a4bb65c146afea7e544b0f98c63d02", size = 24468447, upload-time = "2026-06-11T18:19:04.572Z" },
+    { url = "https://files.pythonhosted.org/packages/66/2c/d4db24f9aeab8fce106633cd0388df4c0cf9f0991a2b5d9f58d061a031f7/uv-0.11.21-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:05e2f2e0fbf7c423f8287011ba0d2d69464f26a5f13b33df05cd491fbe5a910a", size = 24564716, upload-time = "2026-06-11T18:19:29.559Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/53/c61711e81f9f8d34dd020340ace968499b2539d3bb4ac09d39339df54a9d/uv-0.11.21-py3-none-musllinux_1_1_i686.whl", hash = "sha256:b756dd2b368d7cc4aeb48249d06e1250bfcf81f0313ff7d7ec2ccafcd3ee4c93", size = 23917742, upload-time = "2026-06-11T18:18:57.187Z" },
+    { url = "https://files.pythonhosted.org/packages/84/21/210a5562a6a0eddfbe4890eb48e67f167be0307e75f029ca46b8f6386e5d/uv-0.11.21-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:88668a27959df9188ff72b0314f6b14f6acf6090964bb0748974239183ecb51c", size = 25330418, upload-time = "2026-06-11T18:18:37.383Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/3c/81979463de0278facaa59ed3940b9c62f25a68d737d1a6f11cc3f922fba3/uv-0.11.21-py3-none-win32.whl", hash = "sha256:a00c78f3eea6db7967d98a505b01b7d80354517c7ff34f51701949f39c7b53e6", size = 22633520, upload-time = "2026-06-11T18:18:44.992Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/51/e682e060813424467f14ae964dd7022f8fc537fea5803b5aab0ba1eca9cc/uv-0.11.21-py3-none-win_amd64.whl", hash = "sha256:d956ba9470d5267cc0ea3d7572cac3bf045bc78adad5b031b5558c6df13d2e19", size = 25291878, upload-time = "2026-06-11T18:18:23.832Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/ef/8b1d92f9501963ef8694bb17ad80ba9926d049240d2da0a4f879aa37f3e2/uv-0.11.21-py3-none-win_arm64.whl", hash = "sha256:f64a851e429e6afb96f3a0b688995757ed3697bf1078509e2da8220ffc9805cd", size = 23715885, upload-time = "2026-06-11T18:18:48.596Z" },
+]