groundmeas 0.3.1__py3-none-any.whl

groundmeas/models.py

@@ -0,0 +1,215 @@
+"""
+groundmeas.models
+=================
+
+Pydantic/SQLModel data models for earthing measurements.
+
+Defines:
+- Location: a measurement site with geographic coordinates.
+- Measurement: a test event with metadata and related items.
+- MeasurementItem: a measured data point (e.g. impedance, resistivity) with
+  magnitude and optional complex components.
+
+Includes an SQLAlchemy event listener to ensure consistency between
+value, value_real/value_imag, and value_angle_deg fields.
+"""
+
+import logging
+import math
+import numpy as np
+from datetime import datetime, timezone
+from typing import Optional, List, Literal
+
+from sqlalchemy import Column, String, event
+from sqlmodel import SQLModel, Field, Relationship
+
+from pydantic import field_validator
+
+logger = logging.getLogger(__name__)
+
+
+MeasurementType = Literal[
+    "prospective_touch_voltage",
+    "touch_voltage",
+    "earth_potential_rise",
+    "step_voltage",
+    "transferred_potential",
+    "earth_fault_current",
+    "earthing_current",
+    "shield_current",
+    "earthing_resistance",
+    "earthing_impedance",
+    "soil_resistivity",
+]
+
+MethodType = Literal[
+    "staged_fault_test",
+    "injection_remote_substation",
+    "injection_earth_electrode",
+]
+
+AssetType = Literal[
+    "substation",
+    "overhead_line_tower",
+    "cable",
+    "cable_cabinet",
+    "house",
+    "pole_mounted_transformer",
+    "mv_lv_earthing_system",
+]
+
+
+class Location(SQLModel, table=True):
+    """
+    A geographic location where measurements are taken.
+
+    Attributes:
+        id: Auto-generated primary key.
+        name: Human-readable site name.
+        latitude: Decimal degrees latitude.
+        longitude: Decimal degrees longitude.
+        altitude: Altitude in meters (optional).
+        measurements: Back-reference to Measurement records for this site.
+    """
+
+    id: Optional[int] = Field(default=None, primary_key=True)
+    name: str = Field(..., description="Site name")
+    latitude: Optional[float] = Field(None, description="Latitude (°)")
+    longitude: Optional[float] = Field(None, description="Longitude (°)")
+    altitude: Optional[float] = Field(None, description="Altitude (m)")
+    measurements: List["Measurement"] = Relationship(back_populates="location")
+
+
+class Measurement(SQLModel, table=True):
+    """
+    A single earthing measurement event.
+
+    Attributes:
+        id: Auto-generated primary key.
+        timestamp: UTC datetime when the measurement occurred.
+        location_id: FK to Location.
+        location: Relationship to the Location object.
+        method: Measurement method used.
+        voltage_level_kv: System voltage in kilovolts (optional).
+        asset_type: Type of asset under test.
+        fault_resistance_ohm: Fault resistance in ohms (optional).
+        operator: Name or identifier of the operator (optional).
+        description: Free-text notes (optional).
+        items: List of MeasurementItem objects associated to this event.
+    """
+
+    id: Optional[int] = Field(default=None, primary_key=True)
+    timestamp: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc),
+        description="UTC timestamp of measurement",
+    )
+    location_id: Optional[int] = Field(default=None, foreign_key="location.id")
+    location: Optional[Location] = Relationship(back_populates="measurements")
+    method: MethodType = Field(
+        sa_column=Column(String, nullable=False), description="Measurement method"
+    )
+    voltage_level_kv: Optional[float] = Field(None, description="Voltage level in kV")
+    asset_type: AssetType = Field(
+        sa_column=Column(String, nullable=False), description="Type of asset"
+    )
+    fault_resistance_ohm: Optional[float] = Field(
+        None, description="Fault resistance (Ω)"
+    )
+    operator: Optional[str] = Field(None, description="Operator name")
+    description: Optional[str] = Field(None, description="Notes")
+    items: List["MeasurementItem"] = Relationship(back_populates="measurement")
+
+
+class MeasurementItem(SQLModel, table=True):
+    """
+    A single data point within a Measurement.
+
+    Supports both real/imaginary and magnitude/angle representations.
+
+    Attributes:
+        id: Auto-generated primary key.
+        measurement_type: Type of this data point.
+        value: Scalar magnitude (Ω or other unit).
+        value_real: Real component, if complex (Ω).
+        value_imag: Imaginary component, if complex (Ω).
+        value_angle_deg: Phase angle in degrees (optional).
+        unit: Unit string, e.g. "Ω", "m".
+        description: Free-text notes (optional).
+        frequency_hz: Frequency in Hz (optional).
+        additional_resistance_ohm: Extra series resistance (optional).
+        input_impedance_ohm: Instrument input impedance (optional).
+        measurement_distance_m: Depth or distance for resistivity (optional).
+        measurement_id: FK to parent Measurement.
+        measurement: Relationship to the Measurement object.
+    """
+
+    id: Optional[int] = Field(default=None, primary_key=True)
+    measurement_type: MeasurementType = Field(
+        sa_column=Column(String, nullable=False), description="Data point type"
+    )
+    value: Optional[float] = Field(None, description="Magnitude or scalar value")
+    value_real: Optional[float] = Field(None, description="Real part of complex value")
+    value_imag: Optional[float] = Field(
+        None, description="Imaginary part of complex value"
+    )
+    value_angle_deg: Optional[float] = Field(None, description="Phase angle in degrees")
+    unit: str = Field(..., description="Unit of the measurement")
+    description: Optional[str] = Field(None, description="Item notes")
+    frequency_hz: Optional[float] = Field(None, description="Frequency (Hz)")
+    additional_resistance_ohm: Optional[float] = Field(
+        None, description="Additional series resistance (Ω)"
+    )
+    input_impedance_ohm: Optional[float] = Field(
+        None, description="Instrument input impedance (Ω)"
+    )
+    measurement_distance_m: Optional[float] = Field(
+        None, description="Depth/distance for soil resistivity (m)"
+    )
+    measurement_id: Optional[int] = Field(default=None, foreign_key="measurement.id")
+    measurement: Optional[Measurement] = Relationship(back_populates="items")
+
+
+@event.listens_for(MeasurementItem, "before_insert", propagate=True)
+@event.listens_for(MeasurementItem, "before_update", propagate=True)
+def _compute_magnitude(mapper, connection, target: MeasurementItem):
+    """
+    SQLAlchemy event listener to enforce and propagate between
+    complex and polar representations:
+
+      - If `value` is None but real/imag are set, computes magnitude
+        and phase angle (degrees).
+      - If `value` is set and `value_angle_deg` is set, computes
+        `value_real` and `value_imag`.
+      - If neither representation is present, raises ValueError.
+
+    Raises:
+        ValueError: if no valid value is provided.
+    """
+    try:
+        # Case A: only rectangular given → compute scalar and angle
+        if target.value is None:
+            if target.value_real is not None or target.value_imag is not None:
+                r = target.value_real or 0.0
+                i = target.value_imag or 0.0
+                target.value = math.hypot(r, i)
+                target.value_angle_deg = float(np.degrees(np.arctan2(i, r)))
+            else:
+                logger.error(
+                    "MeasurementItem %s lacks both magnitude and real/imag components",
+                    getattr(target, "id", "<new>"),
+                )
+                raise ValueError(
+                    "Either `value` or at least one of (`value_real`, `value_imag`) must be provided"
+                )
+        # Case B: polar given → compute rectangular components
+        elif target.value_angle_deg is not None:
+            angle_rad = math.radians(target.value_angle_deg)
+            target.value_real = float(target.value * math.cos(angle_rad))
+            target.value_imag = float(target.value * math.sin(angle_rad))
+    except Exception:
+        # Ensure that any unexpected error in conversion is logged
+        logger.exception(
+            "Failed to compute magnitude/angle for MeasurementItem %s",
+            getattr(target, "id", "<new>"),
+        )
+        raise

groundmeas/plots.py

@@ -0,0 +1,198 @@
+# src/groundmeas/plots.py
+
+import matplotlib.pyplot as plt
+from typing import Tuple, Union, List, Dict, Any, Optional
+import warnings
+import numpy as np
+
+from .analytics import (
+    impedance_over_frequency,
+    real_imag_over_frequency,
+    voltage_vt_epr,
+)
+
+
+def plot_imp_over_f(
+    measurement_ids: Union[int, List[int]], normalize_freq_hz: Optional[float] = None
+) -> plt.Figure:
+    """
+    Plot earthing impedance versus frequency for one or multiple measurements on a single figure.
+
+    Args:
+        measurement_ids: single ID or list of Measurement IDs.
+        normalize_freq_hz: if provided, normalize each impedance curve by its impedance at this frequency.
+
+    Returns:
+        A matplotlib Figure containing all curves.
+
+    Raises:
+        ValueError: if normalize_freq_hz is specified but a measurement lacks that frequency,
+                    or if no data is available for a single measurement.
+    """
+    # Normalize input to list
+    single = isinstance(measurement_ids, int)
+    ids: List[int] = [measurement_ids] if single else list(measurement_ids)
+
+    # Create a single figure and axis
+    fig, ax = plt.subplots()
+
+    plotted = False
+    for mid in ids:
+        # Retrieve impedance-frequency map
+        freq_imp = impedance_over_frequency(mid)
+        if not freq_imp:
+            warnings.warn(
+                f"No earthing_impedance data for measurement_id={mid}; skipping curve",
+                UserWarning,
+            )
+            continue
+
+        # Sort frequencies
+        freqs = sorted(freq_imp.keys())
+        imps = [freq_imp[f] for f in freqs]
+
+        # Normalize if requested
+        if normalize_freq_hz is not None:
+            baseline = freq_imp.get(normalize_freq_hz)
+            if baseline is None:
+                raise ValueError(
+                    f"Measurement {mid} has no impedance at {normalize_freq_hz} Hz for normalization"
+                )
+            imps = [val / baseline for val in imps]
+
+        # Plot the curve
+        ax.plot(freqs, imps, marker="o", linestyle="-", label=f"ID {mid}")
+        plotted = True
+
+    if not plotted:
+        if single:
+            raise ValueError(
+                f"No earthing_impedance data available for measurement_id={measurement_ids}"
+            )
+        else:
+            raise ValueError(
+                "No earthing_impedance data available for the provided measurement IDs."
+            )
+
+    # Labels and title
+    ax.set_xlabel("Frequency (Hz)")
+    ylabel = (
+        "Normalized Impedance" if normalize_freq_hz is not None else "Impedance (Ω)"
+    )
+    ax.set_ylabel(ylabel)
+    title = "Impedance vs Frequency"
+    if normalize_freq_hz is not None:
+        title += f" (Normalized @ {normalize_freq_hz} Hz)"
+    ax.set_title(title)
+
+    # Grid and scientific tick formatting
+    ax.grid(True, which="both", linestyle="--", linewidth=0.5)
+    ax.ticklabel_format(axis="y", style="sci", scilimits=(0, 0))
+
+    # Legend
+    ax.legend()
+    fig.tight_layout()
+    return fig
+
+
+def plot_rho_f_model(
+    measurement_ids: List[int],
+    rho_f: Tuple[float, float, float, float, float],
+    rho: Union[float, List[float]] = 100,
+) -> plt.Figure:
+    """
+    Plot measured impedance and rho-f model on the same axes.
+
+    Args:
+        measurement_ids: list of Measurement IDs.
+        rho_f: tuple (k1, k2, k3, k4, k5).
+        rho: single float or list of rho values. For list, multiple model curves are plotted.
+
+    Returns:
+        A matplotlib Figure with measured and modeled impedance magnitude vs frequency.
+    """
+    # Plot measured curves
+    fig = plot_imp_over_f(measurement_ids)
+    ax = fig.axes[0]
+
+    # Gather real/imag data
+    rimap = real_imag_over_frequency(measurement_ids)
+    # Union of frequencies
+    all_freqs = set()
+    for freq_map in rimap.values():
+        all_freqs.update(freq_map.keys())
+    freqs = sorted(all_freqs)
+
+    # Unpack model coefficients
+    k1, k2, k3, k4, k5 = rho_f
+
+    # Normalize rho parameter to list
+    rhos: List[float] = [rho] if isinstance(rho, (int, float)) else list(rho)
+
+    # Plot model curves for each rho
+    for rho_val in rhos:
+        model_mag = [
+            abs((k1) * rho_val + (k2 + 1j * k3) * f + (k4 + 1j * k5) * rho_val * f)
+            for f in freqs
+        ]
+        ax.plot(
+            freqs, model_mag, linestyle="--", linewidth=2, label=f"Model (ρ={rho_val})"
+        )
+
+    ax.legend()
+    return fig
+
+
+def plot_voltage_vt_epr(
+    measurement_ids: Union[int, List[int]],
+    frequency: float = 50.0
+) -> plt.Figure:
+    """
+    Bar‐plot of EPR and both min/max of prospective and actual touch voltages.
+
+    For each measurement ID you’ll see:
+      • EPR (V) at x–width
+      • Prospective TV max & min overlayed at x
+      • Actual      TV max & min overlayed at x+width
+
+    All voltage bars start at zero so the longer (max) bars show their full length
+    behind the shorter (min) bars.
+    """
+    # 1) get the numbers
+    data = voltage_vt_epr(measurement_ids, frequency=frequency)
+    single = isinstance(measurement_ids, int)
+    ids: List[int] = [measurement_ids] if single else list(measurement_ids)
+    if single:
+        data = {measurement_ids: data}
+
+    # 2) prepare figure
+    fig, ax = plt.subplots()
+    x = np.arange(len(ids))
+    width = 0.25
+
+    # 3) EPR bars
+    epr = [data[mid].get("epr", 0.0) for mid in ids]
+    ax.bar(x - width, epr, width, label="EPR (V/A)", color="C0")
+
+    # 4) Prospective TV (V/A): max behind (semi‐transparent), min on top
+    vtp_max = [data[mid].get("vtp_max", 0.0) for mid in ids]
+    vtp_min = [data[mid].get("vtp_min", 0.0) for mid in ids]
+    ax.bar(x, vtp_max, width, color="C1", alpha=0.6, label="Vtp max")
+    ax.bar(x, vtp_min, width, color="C1", alpha=1.0, label="Vtp min")
+
+    # 5) Actual TV (V/A): max behind, min on top
+    vt_max = [data[mid].get("vt_max", 0.0) for mid in ids]
+    vt_min = [data[mid].get("vt_min", 0.0) for mid in ids]
+    ax.bar(x + width, vt_max, width, color="C2", alpha=0.6, label="Vt max")
+    ax.bar(x + width, vt_min, width, color="C2", alpha=1.0, label="Vt min")
+
+    # 6) formatting
+    ax.set_xticks(x)
+    ax.set_xticklabels([str(mid) for mid in ids])
+    ax.set_xlabel("Measurement ID")
+    ax.set_ylabel("V/A")
+    ax.set_title(f"EPR & Touch Voltages Min/Max @ {frequency} Hz")
+    ax.legend()
+    ax.grid(True, which="both", linestyle="--", linewidth=0.5)
+    fig.tight_layout()
+    return fig

groundmeas-0.3.1.dist-info/METADATA

@@ -0,0 +1,233 @@
+Metadata-Version: 2.4
+Name: groundmeas
+Version: 0.3.1
+Summary: 
+License-File: LICENSE
+Author: Christian Ehlert
+Author-email: christian.ehlert@mailbox.org
+Requires-Python: >=3.12
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: matplotlib (>=3.10.1,<4.0.0)
+Requires-Dist: numpy (>=2.2.5,<3.0.0)
+Requires-Dist: pandas (>=2.2.3,<3.0.0)
+Requires-Dist: prompt_toolkit (>=3.0.48,<4.0.0)
+Requires-Dist: sqlite-utils (>=3.38,<4.0)
+Requires-Dist: sqlmodel (>=0.0.24,<0.0.25)
+Requires-Dist: typer (>=0.15.3,<0.16.0)
+Description-Content-Type: text/markdown
+
+# groundmeas: Grounding System Measurements & Analysis
+
+**groundmeas** is a Python package for collecting, storing, analyzing, and visualizing earthing (grounding) measurement data.
+
+---
+
+## Project Description
+
+groundmeas provides:
+
+* **Database models & CRUD** via SQLModel/SQLAlchemy (`Location`, `Measurement`, `MeasurementItem`).
+* **Export utilities** to JSON, CSV, and XML.
+* **Analytics routines** for impedance-over-frequency, real–imaginary processing, rho–f model fitting, and shield-current split factors (`calculate_split_factor`).
+* **Plotting helpers** for impedance vs frequency and model overlays using Matplotlib.
+* **CLI** (`gm-cli`) with interactive entry, DB-backed autocomplete, listing, add/edit items and measurements, default DB config, and JSON import/export.
+
+It’s designed to help engineers and researchers work with earthing measurement campaigns, automate data pipelines, and quickly gain insights on soil resistivity and grounding impedance behavior.
+
+---
+
+## Technical Background
+
+In grounding studies, measurements of earth electrode impedance are taken over a range of frequencies, and soil resistivity measurements at various depths are collected.
+
+* **Earthing Impedance** $Z$ vs. **Frequency** (f): typically expressed in Ω.
+* **Soil Resistivity** (ρ) vs. **Depth** (d): used to model frequency‑dependent behavior.
+* **rho–f Model**: fits the relationship
+
+  $$
+  Z(ρ, f) = k_1·ρ + (k_2 + j·k_3)·f + (k_4 + j·k_5)·ρ·f
+  $$
+
+where $k_1…k_5$ are real coefficients determined by least‑squares across multiple measurements.
+
+---
+
+## Installation
+
+Requires Python 3.12+:
+
+```bash
+git clone https://github.com/Ce1ectric/groundmeas.git
+cd groundmeas
+poetry install
+poetry shell
+```
+
+or using pip locally:
+```bash
+git clone https://github.com/Ce1ectric/groundmeas.git
+cd groundmeas
+pip install .
+```
+
+Or install via pip: `pip install groundmeas`.
+
+---
+
+## Usage
+### 0. CLI quickstart
+
+```bash
+gm-cli --db path/to/data.db add-measurement   # interactive wizard with autocomplete
+gm-cli --db path/to/data.db list-measurements
+gm-cli --db path/to/data.db list-items 1
+gm-cli --db path/to/data.db edit-measurement 1   # edit a measurement with defaults prefilled
+gm-cli --db path/to/data.db import-json notebooks/measurements/foo_measurement.json
+gm-cli --db path/to/data.db export-json out.json
+# Add a single item to an existing measurement
+gm-cli --db path/to/data.db add-item 5
+# Edit an existing item
+gm-cli --db path/to/data.db edit-item 42
+# Analytics from CLI
+gm-cli --db path/to/data.db impedance-over-frequency 1 --json-out imp.json
+gm-cli --db path/to/data.db rho-f-model 1 2 3 --json-out rho.json
+gm-cli --db path/to/data.db voltage-vt-epr 1 2 -f 50 --json-out vt.json
+gm-cli --db path/to/data.db calculate-split-factor --earth-fault-id 10 --shield-id 11 --shield-id 12
+# Plotting from CLI (writes images)
+gm-cli --db path/to/data.db plot-impedance 1 2 --out imp.png
+gm-cli --db path/to/data.db plot-rho-f-model 1 2 3 --out rho.png
+gm-cli --db path/to/data.db plot-voltage-vt-epr 1 2 --out vt.png
+# Save a default DB path (~/.config/groundmeas/config.json) so --db is optional
+gm-cli set-default-db path/to/data.db
+# Enable shell completion (example for zsh)
+gm-cli --install-completion zsh
+```
+
+Set `GROUNDMEAS_DB` to avoid passing `--db` each time.
+
+### 1. Database Setup
+
+Initialize or connect to a SQLite database (tables will be created automatically):
+
+```python
+from groundmeas.db import connect_db
+connect_db("mydata.db", echo=True)
+```
+
+### 2. Creating Measurements
+
+Insert a measurement (optionally with nested location) and its items:
+
+```python
+from groundmeas.db import create_measurement, create_item
+
+# Create measurement with nested Location
+meas_id = create_measurement({
+    "timestamp": "2025-01-01T12:00:00",
+    "method": "staged_fault_test",
+    "voltage_level_kv": 10.0,
+    "asset_type": "substation",
+    "location": {"name": "Site A", "latitude": 52.0, "longitude": 13.0},
+})
+
+# Add earthing impedance item
+item_id = create_item({
+    "measurement_type": "earthing_impedance",
+    "frequency_hz": 50.0,
+    "value": 12.3
+}, measurement_id=meas_id)
+```
+
+### 3. Exporting Data
+
+Export measurements (and nested items) to various formats:
+
+```python
+from groundmeas.export import (
+    export_measurements_to_json,
+    export_measurements_to_csv,
+    export_measurements_to_xml,
+)
+
+export_measurements_to_json("data.json")
+export_measurements_to_csv("data.csv")
+export_measurements_to_xml("data.xml")
+```
+
+### 4. Analytics
+
+Compute relevant connections between quantities of the earthing system: 
+- impedance and 
+- real / imaginary parts over frequency, 
+- fit the rho–f model
+- prospective touch voltage vs. Earth Potential Rise
+
+```python
+from groundmeas.analytics import (
+    impedance_over_frequency,
+    real_imag_over_frequency,
+    rho_f_model,
+    voltage_vt_epr,
+    shield_currents_for_location,
+    calculate_split_factor,
+)
+
+# Impedance vs frequency for a single measurement
+imp_map = impedance_over_frequency(1)
+
+# Real & Imag components for multiple measurements
+ri_map = real_imag_over_frequency([1, 2, 3])
+
+# Fit rho–f model across measurements [1,2,3]
+k1, k2, k3, k4, k5 = rho_f_model([1, 2, 3])
+
+# summarise the min, max measured touch voltages and the EPR for multiple measurements 
+touch_min, touch_max, epr = voltage_vt_epr([1, 2, 3])
+
+# Gather available shield currents at a site and compute split factors
+candidates = shield_currents_for_location(location_id=5, frequency_hz=50.0)
+# Pick the shield_current item IDs that share the same angle reference
+shield_ids = [c["id"] for c in candidates]
+split = calculate_split_factor(
+    earth_fault_current_id=42,
+    shield_current_ids=shield_ids,
+)
+split_factor = split["split_factor"]
+local_earthing_current = split["local_earthing_current"]["value"]
+```
+
+### 5. Plotting
+
+Visualize raw and modeled curves:
+
+```python
+from groundmeas.plots import plot_imp_over_f, plot_rho_f_model
+
+# Raw impedance curves
+fig1 = plot_imp_over_f([1, 2, 3])
+fig1.show()
+
+# Normalized at 50 Hz
+fig2 = plot_imp_over_f(1, normalize_freq_hz=50)
+fig2.show()
+
+# Overlay rho–f model
+fig3 = plot_rho_f_model([1,2,3], (k1,k2,k3,k4,k5), rho=[100, 200])
+fig3.show()
+```
+
+## Contributing
+
+Pull requests are welcome!
+For major changes, please open an issue first to discuss.
+Ensure tests pass and add new tests for your changes.
+
+---
+
+## License
+
+MIT License. See [LICENSE](LICENSE) for details.
+

groundmeas-0.3.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+groundmeas/__init__.py,sha256=uIF7B3aewIWQZjigqinH4-wt8cYOWne0JhbZm1mims4,2271
+groundmeas/analytics.py,sha256=atyH3KYm4hOECuq5eUR8e8JOvpS49TGcrNdP_MCmRHI,18093
+groundmeas/cli.py,sha256=KP7JKpzrIwKljkWW74sGnKtg4wyPQ9kmNELhTjBek4M,30462
+groundmeas/db.py,sha256=p4F8rl_CME6skcAgGWF9HgRTMxvS4dWRw9XF5z4fEk8,13709
+groundmeas/export.py,sha256=cBY7zJaXXHCdRqJXwSCuhnX6ywMoo7Jbp0hhPxnEUjM,5687
+groundmeas/models.py,sha256=LgnRbxdjwDtAyxcB8PaLutL4L1os1fh2P_888jDV7Uk,8270
+groundmeas/plots.py,sha256=oeYp9HqIRGPdtnUDVMrL0sYGHkyF0stmAZp12WxVzbU,6424
+groundmeas-0.3.1.dist-info/METADATA,sha256=VT-a_DSZ50gh0jfV-UlsomIH9gy3z4_RhU2qDXfzrMw,7142
+groundmeas-0.3.1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+groundmeas-0.3.1.dist-info/entry_points.txt,sha256=YW0mRPeeW_evhusVPCOW4AfFTCTBAIG1MMy91exwRZY,45
+groundmeas-0.3.1.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+groundmeas-0.3.1.dist-info/RECORD,,

groundmeas-0.3.1.dist-info/WHEEL

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

groundmeas-0.3.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+gm-cli=groundmeas.cli:app
+