coordshift 0.1.0__py3-none-any.whl

coordshift/__init__.py

@@ -0,0 +1,13 @@
+"""
+coordshift — Universal coordinate system conversion for CSV and tabular data.
+
+Basic usage:
+    from coordshift import convert
+    df = convert("input.csv", from_crs="EPSG:4326", to_crs="EPSG:2965", x="lon", y="lat")
+"""
+
+from coordshift.core import convert
+from coordshift.crs import resolve_crs, search_crs
+
+__version__ = "0.1.0"
+__all__ = ["convert", "resolve_crs", "search_crs"]

coordshift/cli.py

@@ -0,0 +1,145 @@
+"""
+cli.py — Command line interface for coordshift.
+
+Built with Click. This file is intentionally thin — it parses arguments
+and calls functions from core.py and io.py. No conversion logic lives here.
+
+Entry point is defined in pyproject.toml:
+    [project.scripts]
+    coordshift = "coordshift.cli:cli"
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import click
+from pandas.errors import EmptyDataError, ParserError
+
+from coordshift import __version__
+from coordshift.core import convert as convert_file
+from coordshift.crs import CRSError, search_crs
+from coordshift.presets import PRESETS
+
+
+def _configure_utf8_stdio() -> None:
+    """Use UTF-8 for stdout/stderr when possible (Windows consoles often default to cp1252)."""
+    for stream in (getattr(sys, "stdout", None), getattr(sys, "stderr", None)):
+        if stream is None or not hasattr(stream, "reconfigure"):
+            continue
+        try:
+            stream.reconfigure(encoding="utf-8")
+        except (AttributeError, OSError, ValueError):
+            continue
+
+
+_configure_utf8_stdio()
+
+
+def _default_output_path(input_path: str) -> str:
+    """Return input path with ``_converted`` inserted before the file extension."""
+    p = Path(input_path)
+    if p.suffix:
+        return str(p.with_name(f"{p.stem}_converted{p.suffix}"))
+    return str(p.with_name(f"{p.name}_converted"))
+
+
+def _format_preset_line(name: str, epsg: str, description: str) -> str:
+    """Format one preset for terminal output."""
+    return f"{name}  →  {epsg}  —  {description}"
+
+
+@click.group()
+@click.version_option(version=__version__)
+def cli():
+    """coordshift — Universal coordinate system conversion for CSV data."""
+    pass
+
+
+@cli.command()
+@click.argument("filepath", type=click.Path(exists=True))
+@click.option("--from", "from_crs", required=True, help="Source CRS (e.g. EPSG:4326, wgs84)")
+@click.option("--to", "to_crs", required=True, help="Target CRS (e.g. EPSG:2965, indiana-east)")
+@click.option("--x", default=None, help="X/longitude/easting column name (auto-detected if omitted)")
+@click.option("--y", default=None, help="Y/latitude/northing column name (auto-detected if omitted)")
+@click.option(
+    "--suffix",
+    default="_converted",
+    show_default=True,
+    help="Suffix for the output column names (e.g. '_proj' produces lon_proj, lat_proj). "
+    "Original X/Y columns are always kept; converted values go into new columns "
+    "placed right after the originals.",
+)
+@click.option("--out", default=None, help="Output file path (default: input_converted.csv)")
+def convert(filepath, from_crs, to_crs, x, y, suffix, out):
+    """Convert coordinate columns in a CSV file from one CRS to another.
+
+    Original X/Y columns are preserved. Converted values are written to new
+    columns (e.g. lon_converted, lat_converted) placed immediately after the
+    originals. Use --suffix to customise the column name suffix.
+    """
+    output_path = out if out else _default_output_path(filepath)
+    x_col = x if x else None
+    y_col = y if y else None
+
+    try:
+        df = convert_file(
+            filepath,
+            from_crs,
+            to_crs,
+            x=x_col,
+            y=y_col,
+            output=output_path,
+            suffix=suffix,
+        )
+    except (
+        CRSError,
+        ValueError,
+        KeyError,
+        OSError,
+        TypeError,
+        EmptyDataError,
+        ParserError,
+        FileNotFoundError,
+    ) as e:
+        click.secho(str(e), fg="red")
+        raise SystemExit(1) from e
+
+    n = len(df)
+    click.echo(
+        f"Converted {n} row(s) from {from_crs!r} to {to_crs!r}. "
+        f"Output: {output_path}"
+    )
+
+
+@cli.command()
+@click.argument("query")
+def search(query):
+    """Search for a CRS by name or keyword. Example: coordshift search 'indiana'"""
+    results = search_crs(query)
+    if not results:
+        click.echo(f"No presets found matching: {query}")
+        return
+    for row in sorted(results, key=lambda r: r["name"]):
+        click.echo(
+            _format_preset_line(
+                row["name"],
+                str(row["epsg"]),
+                str(row["description"]),
+            )
+        )
+
+
+@cli.command()
+def list_crs():
+    """List all built-in CRS presets."""
+    for name in sorted(PRESETS.keys()):
+        data = PRESETS[name]
+        click.echo(
+            _format_preset_line(
+                name,
+                str(data["epsg"]),
+                str(data.get("description", "")),
+            )
+        )

coordshift/core.py

@@ -0,0 +1,126 @@
+"""
+core.py — The main conversion logic.
+
+This is the heart of coordshift. Everything else (CLI, file I/O) calls
+functions from here. Keeping conversion logic here means it can be used
+both from the command line and from Python scripts.
+"""
+
+import pandas as pd
+from pyproj import Transformer
+from pyproj.exceptions import CRSError as PyprojCRSError
+
+from coordshift.crs import CRSError, resolve_crs
+
+from . import io
+
+
+def transform_points(
+    xs: list[float],
+    ys: list[float],
+    from_crs: str,
+    to_crs: str,
+) -> tuple[list[float], list[float]]:
+    """
+    Transform a list of X/Y points from one CRS to another.
+
+    Args:
+        xs: List of X values (longitude or easting).
+        ys: List of Y values (latitude or northing).
+        from_crs: Source CRS string (e.g. from ``resolve_crs`` or an EPSG code).
+        to_crs: Target CRS string in the same forms as ``from_crs``.
+
+    Returns:
+        Tuple of (transformed_xs, transformed_ys).
+    """
+    try:
+        transformer = Transformer.from_crs(from_crs, to_crs, always_xy=True)
+    except PyprojCRSError as e:
+        raise CRSError(
+            f"Could not build coordinate transform from {from_crs!r} to {to_crs!r}: {e}. "
+            "Use resolvable CRS strings or preset names. "
+            "Run `coordshift search` to list presets."
+        ) from e
+    tx, ty = transformer.transform(xs, ys)
+    return [float(v) for v in tx], [float(v) for v in ty]
+
+
+def convert(
+    filepath: str,
+    from_crs: str,
+    to_crs: str,
+    x: str | None = None,
+    y: str | None = None,
+    output: str | None = None,
+    suffix: str = "_converted",
+) -> pd.DataFrame:
+    """
+    Convert coordinate columns in a CSV file from one CRS to another.
+
+    The original X/Y columns are always preserved. Converted values are written
+    to new columns named ``{x}{suffix}`` and ``{y}{suffix}``, inserted immediately
+    after their respective originals.
+
+    Args:
+        filepath: Path to the input CSV file.
+        from_crs: Source CRS — EPSG code (e.g. "EPSG:4326"), PROJ string, or preset name.
+        to_crs: Target CRS — same formats accepted.
+        x: Name of the X/longitude/easting column. Auto-detected if not provided.
+        y: Name of the Y/latitude/northing column. Auto-detected if not provided.
+        output: Path to save the output CSV. If None, returns DataFrame only.
+        suffix: Suffix appended to X/Y column names to form the output column names
+            (default ``"_converted"``). For example, with ``x="lon"`` and
+            ``suffix="_proj"``, the output column is ``"lon_proj"``.
+
+    Returns:
+        pandas DataFrame with original coordinate columns preserved and new converted
+        columns inserted immediately after them. All other columns are unchanged.
+    """
+    from_resolved = resolve_crs(from_crs)
+    to_resolved = resolve_crs(to_crs)
+
+    df_in = io.read_csv(filepath)
+    x_col = x
+    y_col = y
+    if x_col is None or y_col is None:
+        auto_x, auto_y = io.detect_columns(df_in)
+        if x_col is None:
+            x_col = auto_x
+        if y_col is None:
+            y_col = auto_y
+
+    if x_col is None or y_col is None:
+        raise ValueError(
+            "Could not determine X/Y columns. "
+            "Pass x= and y= with column names, or use recognizable names such as "
+            f"lon/lat (hints: {io.X_COLUMN_HINTS}, {io.Y_COLUMN_HINTS})."
+        )
+
+    x_out = f"{x_col}{suffix}"
+    y_out = f"{y_col}{suffix}"
+    for name in (x_out, y_out):
+        if name in df_in.columns:
+            raise ValueError(
+                f"Column {name!r} already exists. Choose a different --suffix or rename the input column."
+            )
+
+    out = df_in.copy()
+    xs = out[x_col].astype(float).tolist()
+    ys = out[y_col].astype(float).tolist()
+    new_xs, new_ys = transform_points(xs, ys, from_resolved, to_resolved)
+
+    out[x_out] = new_xs
+    out[y_out] = new_ys
+
+    # Insert the new columns immediately after their originals
+    cols = [c for c in out.columns if c not in (x_out, y_out)]
+    x_idx = cols.index(x_col)
+    cols.insert(x_idx + 1, x_out)
+    y_idx = cols.index(y_col)
+    cols.insert(y_idx + 1, y_out)
+    out = out[cols]
+
+    if output is not None:
+        io.write_csv(out, output)
+
+    return out

coordshift/crs.py

@@ -0,0 +1,95 @@
+"""
+crs.py — CRS resolution and search.
+
+Responsible for turning whatever the user types (EPSG code, PROJ string,
+friendly name like "indiana-east") into something pyproj can use.
+"""
+
+from pyproj import CRS
+from pyproj.exceptions import CRSError as PyprojCRSError
+
+from coordshift.presets import PRESETS
+
+
+class CRSError(ValueError):
+    """Raised when a CRS string cannot be resolved."""
+    pass
+
+
+def _normalize_preset_key(user_input: str) -> str:
+    """Normalize user text for lookup in PRESETS (lowercase, hyphenated)."""
+    return user_input.strip().lower().replace(" ", "-")
+
+
+def resolve_crs(crs_input: str) -> str:
+    """
+    Resolve a CRS input string to a canonical form pyproj can use.
+
+    Accepts:
+        - EPSG codes as string: "EPSG:4326" or "4326"
+        - PROJ strings: "+proj=longlat +datum=WGS84"
+        - Preset names: "wgs84", "indiana-east", "nad83"
+
+    Args:
+        crs_input: The CRS string to resolve.
+
+    Returns:
+        A CRS string ready for pyproj.
+
+    Raises:
+        CRSError: If the CRS cannot be resolved.
+    """
+    raw = crs_input.strip()
+    if not raw:
+        raise CRSError(
+            "Empty CRS input. Provide an EPSG code, PROJ string, or preset name "
+            "(try `coordshift search`)."
+        )
+
+    preset_key = _normalize_preset_key(raw)
+    if preset_key in PRESETS:
+        return str(PRESETS[preset_key]["epsg"])
+
+    try:
+        crs = CRS(raw)
+    except PyprojCRSError as e:
+        raise CRSError(
+            f"Could not resolve CRS {raw!r}: {e}. "
+            "Try an EPSG code, a PROJ string, or a preset name. "
+            "Run `coordshift search` to list presets."
+        ) from e
+
+    epsg = crs.to_epsg()
+    if epsg is not None:
+        return f"EPSG:{epsg}"
+    return crs.to_wkt()
+
+
+def search_crs(query: str) -> list[dict]:
+    """
+    Search for CRS presets matching a query string.
+
+    Args:
+        query: Search term (e.g. "indiana", "state plane", "utm zone 16").
+
+    Returns:
+        List of matching preset dicts with keys: name, epsg, description.
+    """
+    q = query.strip().lower()
+    if not q:
+        return []
+
+    matches: list[dict] = []
+    for name, data in PRESETS.items():
+        description = str(data.get("description", ""))
+        haystack_name = name.lower()
+        haystack_desc = description.lower()
+        if q in haystack_name or q in haystack_desc:
+            matches.append(
+                {
+                    "name": name,
+                    "epsg": data["epsg"],
+                    "description": description,
+                }
+            )
+    return matches

coordshift/io.py

@@ -0,0 +1,65 @@
+"""
+io.py — File reading, column detection, and output writing.
+
+Handles everything related to getting data in and out of coordshift.
+Kept separate from core.py so conversion logic stays clean and testable
+without needing actual files.
+"""
+
+import pandas as pd
+
+# Common column name patterns we'll try to auto-detect
+X_COLUMN_HINTS = ["lon", "longitude", "long", "x", "easting", "x_coord", "lng"]
+Y_COLUMN_HINTS = ["lat", "latitude", "y", "northing", "y_coord"]
+
+
+def _first_column_matching_hints(df: pd.DataFrame, hints: list[str]) -> str | None:
+    """Return the first DataFrame column whose normalized name matches a hint."""
+    hint_set = {h.lower() for h in hints}
+    for col in df.columns:
+        normalized = str(col).strip().lower()
+        if normalized in hint_set:
+            return str(col)
+    return None
+
+
+def read_csv(filepath: str) -> pd.DataFrame:
+    """
+    Read a CSV file into a pandas DataFrame.
+
+    Args:
+        filepath: Path to the CSV file.
+
+    Returns:
+        pandas DataFrame.
+    """
+    return pd.read_csv(filepath)
+
+
+def detect_columns(df: pd.DataFrame) -> tuple[str | None, str | None]:
+    """
+    Try to auto-detect which columns contain X and Y coordinates.
+
+    Checks column names against known patterns (lon, lat, easting, etc.)
+    Case-insensitive. Returns None for either if it can't find a match.
+
+    Args:
+        df: The input DataFrame.
+
+    Returns:
+        Tuple of (x_column_name, y_column_name). Either may be None.
+    """
+    x_col = _first_column_matching_hints(df, X_COLUMN_HINTS)
+    y_col = _first_column_matching_hints(df, Y_COLUMN_HINTS)
+    return x_col, y_col
+
+
+def write_csv(df: pd.DataFrame, filepath: str) -> None:
+    """
+    Write a DataFrame to a CSV file.
+
+    Args:
+        df: The DataFrame to write.
+        filepath: Output file path.
+    """
+    df.to_csv(filepath, index=False)

coordshift/presets.py

@@ -0,0 +1,69 @@
+"""
+presets.py — Friendly name to EPSG mappings.
+
+Lets users type "indiana-east" instead of "EPSG:2965". Add more as needed.
+Organized by category. EPSG realizations vary by entry: most State Plane zones
+use classic NAD83; Iowa uses NAD83(2011). Check each entry's description.
+"""
+
+PRESETS: dict[str, dict] = {
+    # --- Geographic (lat/lon) ---
+    "wgs84": {
+        "epsg": "EPSG:4326",
+        "description": "WGS84 Geographic (lat/lon) — GPS default",
+    },
+    "nad83": {
+        "epsg": "EPSG:4269",
+        "description": "NAD83 Geographic (lat/lon) — North America",
+    },
+
+    # --- Indiana State Plane ---
+    "indiana-east": {
+        "epsg": "EPSG:2965",
+        "description": "Indiana State Plane East (NAD83, meters)",
+    },
+    "indiana-west": {
+        "epsg": "EPSG:2966",
+        "description": "Indiana State Plane West (NAD83, meters)",
+    },
+
+    # --- Iowa State Plane (NAD83(2011), ftUS) — proj4.js needs explicit defs in web app ---
+    "iowa-north-ftus": {
+        "epsg": "EPSG:6463",
+        "description": "Iowa State Plane North (NAD83(2011), US survey feet)",
+    },
+
+    # --- Arizona State Plane ---
+    "arizona-east": {
+        "epsg": "EPSG:2223",
+        "description": "Arizona State Plane East (NAD83, feet)",
+    },
+    "arizona-central": {
+        "epsg": "EPSG:2224",
+        "description": "Arizona State Plane Central (NAD83, feet)",
+    },
+    "arizona-west": {
+        "epsg": "EPSG:2225",
+        "description": "Arizona State Plane West (NAD83, feet)",
+    },
+
+    # --- UTM (NAD83) ---
+    "utm-15n": {
+        "epsg": "EPSG:26915",
+        "description": "UTM Zone 15N (NAD83) — Central US",
+    },
+    "utm-16n": {
+        "epsg": "EPSG:26916",
+        "description": "UTM Zone 16N (NAD83) — Indiana/Ohio area",
+    },
+    "utm-17n": {
+        "epsg": "EPSG:26917",
+        "description": "UTM Zone 17N (NAD83) — Eastern US",
+    },
+
+    # --- Web / Mapping ---
+    "web-mercator": {
+        "epsg": "EPSG:3857",
+        "description": "Web Mercator — Google Maps, OpenStreetMap",
+    },
+}

coordshift-0.1.0.dist-info/METADATA

@@ -0,0 +1,242 @@
+Metadata-Version: 2.4
+Name: coordshift
+Version: 0.1.0
+Summary: Universal coordinate system conversion for CSV and tabular data
+Author: Nick Fulton
+License-Expression: MIT
+Keywords: gis,coordinates,crs,projection,epsg,pyproj,survey,gnss
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: GIS
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyproj>=3.5
+Requires-Dist: pandas>=2.0
+Requires-Dist: click>=8.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=4.0; extra == "dev"
+Dynamic: license-file
+
+# coordshift
+
+> **⚠ Alpha software — use with caution**
+>
+> coordshift is in early development (pre-v1.0). APIs and output formats may change without notice.
+> **Always verify converted coordinates against a trusted independent source before using them in any survey, legal, safety-critical, or production workflow.**
+> The authors provide no warranty and accept no liability for errors in coordinate conversion results. Use at your own risk.
+
+Universal coordinate system conversion for CSV and tabular data — built for GIS analysts, surveyors, and drone mapping workflows.
+
+## What it does
+
+`coordshift` reprojects coordinate columns in CSV files from one CRS to another, using any system supported by PROJ. It ships as both a command-line tool and a Python library, plus a standalone browser-based converter (`coordshift.html`) that works entirely offline.
+
+**CLI**
+
+```bash
+coordshift convert input.csv --from EPSG:4326 --to EPSG:2965 --x lon --y lat
+```
+
+**Python**
+
+```python
+from coordshift import convert
+
+df = convert("input.csv", from_crs="EPSG:4326", to_crs="EPSG:2965", x="lon", y="lat")
+```
+
+**Browser**
+
+Open `coordshift.html` in any modern browser — no install required.
+
+## Why this exists
+
+Tools like cs2cs, ogr2ogr, and raw pyproj are powerful but assume you already speak PROJ. `coordshift` targets practitioners who need fast, repeatable conversions without wrestling with syntax.
+
+## What's included
+
+- Convert any EPSG/PROJ CRS to any other
+- Auto-detect common column names (lat, lon, x, y, easting, northing, etc.)
+- Source and target CRS via EPSG code, PROJ string, or friendly preset name
+- Preserve all columns in output — original X/Y columns are always kept
+- Converted coordinates written to new columns placed immediately after the originals
+- Customisable output column suffix (default `_converted`, e.g. `lon_converted`, `lat_converted`)
+- CLI for one-off conversions
+- Python API for scripting and pipelines
+- Browser-based converter (`coordshift.html`) with map preview — works offline
+
+## Planned
+
+- Vertical coordinate support (ellipsoidal ↔ orthometric, GEOID)
+- Batch conversion across multiple files
+- Output to GeoJSON or Shapefile
+
+## Installation
+
+Install from source until the first PyPI release:
+
+```bash
+git clone https://github.com/FultonGeo/coordshift.git
+cd coordshift
+pip install -e .
+```
+
+Or, once published:
+
+```bash
+pip install coordshift
+```
+
+## Usage
+
+### CLI
+
+Basic conversion (original `lon`/`lat` columns are preserved; converted values go into `lon_converted`/`lat_converted` placed right after them):
+
+```bash
+coordshift convert input.csv --from EPSG:4326 --to EPSG:2965 --x lon --y lat
+```
+
+With output path:
+
+```bash
+coordshift convert input.csv --from EPSG:4326 --to EPSG:2965 --x lon --y lat --out output.csv
+```
+
+Custom column name suffix (produces `lon_proj`, `lat_proj` instead of the default `lon_converted`, `lat_converted`):
+
+```bash
+coordshift convert input.csv --from EPSG:4326 --to EPSG:2965 --suffix _proj
+```
+
+PROJ strings (use a single line on Windows, or wrap as your shell allows):
+
+```bash
+coordshift convert input.csv \
+  --from "+proj=longlat +datum=WGS84" \
+  --to "+proj=tmerc +lat_0=37.5 +lon_0=-85.66666667 +k=0.999966667 +x_0=100000 +y_0=250000 +ellps=GRS80" \
+  --x longitude --y latitude
+```
+
+List presets and search CRS:
+
+```bash
+coordshift list-crs
+coordshift search "indiana east"
+```
+
+### Python API
+
+```python
+from coordshift import convert, search_crs
+
+df = convert(
+    "field_points.csv",
+    from_crs="EPSG:4326",
+    to_crs="EPSG:2965",
+    x="lon",
+    y="lat",
+)
+# df now has lon, lon_converted, lat, lat_converted (plus any other original columns)
+df.to_csv("field_points_converted.csv", index=False)
+
+results = search_crs("indiana east")
+```
+
+See [docs/examples.md](docs/examples.md) for more detailed examples.
+
+### Browser app
+
+Open `coordshift.html` in any modern browser (Chrome, Firefox, Edge, Safari). No server or internet connection required after the page loads. Features include:
+
+- Upload a CSV and pick coordinate columns
+- Search and select source/target CRS from a built-in catalog of State Plane zones, UTM, and common geographic systems
+- Preview converted points on an interactive map
+- Download the converted CSV
+
+## Project structure
+
+```text
+coordshift/
+├── coordshift/         # Python package
+│   ├── __init__.py    # Public API
+│   ├── core.py        # Conversion (pyproj)
+│   ├── cli.py         # CLI (Click)
+│   ├── io.py          # CSV I/O, column detection
+│   ├── crs.py         # CRS resolution
+│   └── presets.py     # Friendly name → EPSG
+├── tests/
+│   ├── test_core.py
+│   ├── test_cli.py
+│   ├── test_io.py
+│   └── fixtures/
+├── docs/
+│   └── examples.md
+├── scripts/           # Developer tooling (regenerate HTML catalog)
+├── coordshift.html    # Standalone browser-based converter
+├── pyproject.toml
+├── README.md
+└── LICENSE
+```
+
+## Development setup
+
+```bash
+git clone https://github.com/FultonGeo/coordshift.git
+cd coordshift
+python -m venv venv
+```
+
+Activate the virtual environment:
+
+- **Windows (PowerShell):** `.\venv\Scripts\Activate.ps1`
+- **macOS / Linux:** `source venv/bin/activate`
+
+Then:
+
+```bash
+pip install -e ".[dev]"
+pytest
+```
+
+Run the linter:
+
+```bash
+ruff check coordshift/
+```
+
+## Dependencies
+
+- [pyproj](https://pyproj4.github.io/pyproj/) — PROJ bindings
+- [pandas](https://pandas.pydata.org/) — tabular data
+- [click](https://click.palletsprojects.com/) — CLI
+
+## Contributing
+
+Contributions welcome. Open an issue before large changes so direction stays aligned.
+
+1. Fork the repo
+2. Create a branch: `git checkout -b feature/my-feature`
+3. Commit and push
+4. Open a pull request
+
+## Disclaimer
+
+coordshift is alpha software provided **as-is**, without warranty of any kind, express or implied. Coordinate conversion results depend on the accuracy of the underlying PROJ library, the correctness of the CRS definitions used, and the quality of the input data. Always double-check converted coordinates against an authoritative source before using them in any survey, engineering, legal, or safety-critical context. The authors and contributors are not responsible for errors, losses, or damages arising from the use of this software.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Author
+
+Nick Fulton — geospatial work, FAA Part 107, drone and survey experience.
+
+Repository: [FultonGeo/coordshift](https://github.com/FultonGeo/coordshift).

coordshift-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+coordshift/__init__.py,sha256=D28qTXzsDi2Uv85wN7WXlhncFLRuDSQpXpilYPHqjuw,389
+coordshift/cli.py,sha256=Ls7gHHJr22CMIqSocgHj9hXkCgnugD5nPYkBugzkW1E,4510
+coordshift/core.py,sha256=1fegbqyCNudl2A3-YWeXO7Up3V3B5lqS-NI0YMTpJmg,4264
+coordshift/crs.py,sha256=c1lBfN8yX9ntq3m-4pwT2ocD4-q52yfIPlHYRTFGmx0,2597
+coordshift/io.py,sha256=_KeVd6yTfQOjPZbP0ZSiO8mgiagSjIuDKuLIGS84E04,1863
+coordshift/presets.py,sha256=JmNxp-0eF6LMQmy9GrIUVQ2AhmO7aK_641rP34WpL1A,2063
+coordshift-0.1.0.dist-info/licenses/LICENSE,sha256=eHl6bQTjsn-zTuTG4p1ZdJ4iKi3_E2h5F2UV2M2jiBo,1068
+coordshift-0.1.0.dist-info/METADATA,sha256=PKJ51XyFaLYkVPRVC5MRKFRN4g9E7ZUhU2Rrhw5fWj8,7475
+coordshift-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+coordshift-0.1.0.dist-info/entry_points.txt,sha256=RFWkxqwyiGQjQ7HjNbruaGJ-VyJrLZag5KqbaJ3eTMo,50
+coordshift-0.1.0.dist-info/top_level.txt,sha256=9XCGmRJi3oJXAKYePggBuLMjDX6FkBbzvQ8lOH2FXVg,11
+coordshift-0.1.0.dist-info/RECORD,,

coordshift-0.1.0.dist-info/WHEEL

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

coordshift-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+coordshift = coordshift.cli:cli

coordshift-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nick Fulton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

coordshift-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+coordshift