logisticspy 0.1.0__py3-none-any.whl

logisticspy/__init__.py

@@ -0,0 +1,43 @@
+"""
+logisticspy: A Python toolkit for logistics and supply chain calculations.
+
+The first module, ``logisticspy.weight``, calculates volumetric (dimensional)
+and chargeable weight for air, courier, sea, road, and rail freight shipments.
+More tools will be added over time.
+
+Top-level convenience imports let you do either of:
+
+    import logisticspy
+    logisticspy.calculate(...)
+
+    from logisticspy.weight import chargeable_weight
+    chargeable_weight.calculate(...)
+"""
+
+from .weight import (
+    calculate,
+    calculate_consignment,
+    WeightResult,
+    ConsolidatedResult,
+    Mode,
+    DEFAULT_DIVISORS,
+    DIVISOR_PRESETS,
+    UnsupportedUnitError,
+    UnsupportedModeError,
+    UnsupportedPresetError,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "calculate",
+    "calculate_consignment",
+    "WeightResult",
+    "ConsolidatedResult",
+    "Mode",
+    "DEFAULT_DIVISORS",
+    "DIVISOR_PRESETS",
+    "UnsupportedUnitError",
+    "UnsupportedModeError",
+    "UnsupportedPresetError",
+]

logisticspy/weight/__init__.py

@@ -0,0 +1,28 @@
+"""
+logisticspy.weight: Calculate volumetric (dimensional) and chargeable weight
+for air, courier, sea, road, and rail freight shipments.
+"""
+
+from .chargeable_weight import (
+    calculate,
+    calculate_consignment,
+    WeightResult,
+    ConsolidatedResult,
+    UnsupportedUnitError,
+    UnsupportedModeError,
+    UnsupportedPresetError,
+)
+from .divisors import Mode, DEFAULT_DIVISORS, DIVISOR_PRESETS
+
+__all__ = [
+    "calculate",
+    "calculate_consignment",
+    "WeightResult",
+    "ConsolidatedResult",
+    "Mode",
+    "DEFAULT_DIVISORS",
+    "DIVISOR_PRESETS",
+    "UnsupportedUnitError",
+    "UnsupportedModeError",
+    "UnsupportedPresetError",
+]

logisticspy/weight/chargeable_weight.py

@@ -0,0 +1,291 @@
+"""
+Core calculation logic for volumetric (dimensional) and chargeable weight.
+"""
+
+from dataclasses import dataclass
+from typing import Optional, List
+
+from .divisors import (
+    Mode,
+    DEFAULT_DIVISORS,
+    DIVISOR_PRESETS,
+    SEA_CBM_TO_KG,
+    LENGTH_TO_CM,
+    WEIGHT_TO_KG,
+)
+
+
+class UnsupportedUnitError(ValueError):
+    """Raised when an unrecognized unit is supplied."""
+
+
+class UnsupportedModeError(ValueError):
+    """Raised when an unrecognized transport mode is supplied."""
+
+
+class UnsupportedPresetError(ValueError):
+    """Raised when an unrecognized divisor preset is supplied."""
+
+
+@dataclass
+class WeightResult:
+    """Result of a chargeable weight calculation for a single package."""
+
+    actual_weight_kg: float
+    volumetric_weight_kg: float
+    chargeable_weight_kg: float
+    basis: str  # "actual" or "volumetric"
+    volume_m3: float
+    mode: str
+    divisor: Optional[float] = None  # None for sea (CBM-based)
+
+    def to_dict(self) -> dict:
+        return {
+            "actual_weight_kg": round(self.actual_weight_kg, 6),
+            "volumetric_weight_kg": round(self.volumetric_weight_kg, 6),
+            "chargeable_weight_kg": round(self.chargeable_weight_kg, 6),
+            "basis": self.basis,
+            "volume_m3": round(self.volume_m3, 6),
+            "mode": self.mode,
+            "divisor": self.divisor,
+        }
+
+
+@dataclass
+class ConsolidatedResult:
+    """Result of a chargeable weight calculation across multiple packages."""
+
+    packages: List[WeightResult]
+    total_actual_weight_kg: float
+    total_volumetric_weight_kg: float
+    total_chargeable_weight_kg: float
+    basis: str
+    mode: str
+    per_piece: bool
+
+    def to_dict(self) -> dict:
+        return {
+            "packages": [p.to_dict() for p in self.packages],
+            "total_actual_weight_kg": round(self.total_actual_weight_kg, 6),
+            "total_volumetric_weight_kg": round(self.total_volumetric_weight_kg, 6),
+            "total_chargeable_weight_kg": round(self.total_chargeable_weight_kg, 6),
+            "basis": self.basis,
+            "mode": self.mode,
+            "per_piece": self.per_piece,
+        }
+
+
+def _to_cm(value: float, unit: str) -> float:
+    unit = unit.lower()
+    if unit not in LENGTH_TO_CM:
+        raise UnsupportedUnitError(
+            f"Unsupported length unit '{unit}'. "
+            f"Supported units: {sorted(LENGTH_TO_CM)}"
+        )
+    return value * LENGTH_TO_CM[unit]
+
+
+def _to_kg(value: float, unit: str) -> float:
+    unit = unit.lower()
+    if unit not in WEIGHT_TO_KG:
+        raise UnsupportedUnitError(
+            f"Unsupported weight unit '{unit}'. "
+            f"Supported units: {sorted(WEIGHT_TO_KG)}"
+        )
+    return value * WEIGHT_TO_KG[unit]
+
+
+def _resolve_mode(mode) -> Mode:
+    if isinstance(mode, Mode):
+        return mode
+    try:
+        return Mode(str(mode).lower())
+    except ValueError:
+        raise UnsupportedModeError(
+            f"Unsupported mode '{mode}'. "
+            f"Supported modes: {[m.value for m in Mode]}"
+        )
+
+
+def _resolve_divisor(
+    mode: Mode, divisor_preset: Optional[str], divisor: Optional[float]
+) -> Optional[float]:
+    """Resolve the divisor to use, following precedence:
+    explicit divisor > named preset > mode default.
+    Returns None for SEA mode (CBM-based, no divisor applies).
+    """
+    if mode == Mode.SEA:
+        return None
+
+    if divisor is not None:
+        return divisor
+
+    if divisor_preset is not None:
+        key = divisor_preset.lower()
+        if key not in DIVISOR_PRESETS:
+            raise UnsupportedPresetError(
+                f"Unsupported divisor_preset '{divisor_preset}'. "
+                f"Supported presets: {sorted(DIVISOR_PRESETS)}"
+            )
+        return DIVISOR_PRESETS[key]
+
+    return DEFAULT_DIVISORS[mode]
+
+
+def calculate(
+    length: float,
+    width: float,
+    height: float,
+    actual_weight: float,
+    mode,
+    unit: str = "cm",
+    weight_unit: str = "kg",
+    divisor_preset: Optional[str] = None,
+    divisor: Optional[float] = None,
+) -> WeightResult:
+    """
+    Calculate volumetric and chargeable weight for a single package.
+
+    Args:
+        length, width, height: Package dimensions.
+        actual_weight: Physical (scale) weight of the package.
+        mode: Transport mode - "air", "courier", "sea", "road", or "rail"
+              (or a Mode enum value).
+        unit: Unit for dimensions. One of "cm", "m", "mm", "in", "ft".
+              Default "cm".
+        weight_unit: Unit for actual_weight. One of "kg", "g", "lb", "oz".
+              Default "kg".
+        divisor_preset: Optional named divisor preset ("a" = 5000,
+              "b" = 6000) to use instead of the mode default. These are
+              generic labels for two widely-used divisor values in the
+              freight/parcel industry - they are not tied to any specific
+              carrier. Ignored for sea mode.
+        divisor: Optional explicit divisor (cm^3 per kg) overriding both
+              the preset and mode default. Ignored for sea mode.
+
+    Returns:
+        WeightResult with actual, volumetric, and chargeable weights in kg,
+        plus the basis ("actual" or "volumetric") used for billing.
+
+    Notes:
+        - For sea freight, volumetric weight is derived from CBM
+          (cubic meters) x 1000, following the common "1 CBM = 1000 kg"
+          weight-or-measurement (W/M) convention. Some carriers use
+          different ratios or apply this only above certain thresholds.
+        - Divisors of 5000 and 6000 (presets "a" and "b") are both widely
+          used across the freight and parcel industry for different
+          modes, services, and regions. Always confirm the applicable
+          divisor with your specific carrier or contract for
+          billing-critical calculations.
+    """
+    resolved_mode = _resolve_mode(mode)
+
+    if length <= 0 or width <= 0 or height <= 0:
+        raise ValueError("Dimensions must be positive numbers.")
+    if actual_weight < 0:
+        raise ValueError("actual_weight must be non-negative.")
+
+    length_cm = _to_cm(length, unit)
+    width_cm = _to_cm(width, unit)
+    height_cm = _to_cm(height, unit)
+    actual_weight_kg = _to_kg(actual_weight, weight_unit)
+
+    volume_cm3 = length_cm * width_cm * height_cm
+    volume_m3 = volume_cm3 / 1_000_000
+
+    resolved_divisor = _resolve_divisor(resolved_mode, divisor_preset, divisor)
+
+    if resolved_mode == Mode.SEA:
+        volumetric_weight_kg = volume_m3 * SEA_CBM_TO_KG
+    else:
+        volumetric_weight_kg = volume_cm3 / resolved_divisor
+
+    chargeable_weight_kg = max(actual_weight_kg, volumetric_weight_kg)
+    basis = "volumetric" if volumetric_weight_kg > actual_weight_kg else "actual"
+
+    return WeightResult(
+        actual_weight_kg=actual_weight_kg,
+        volumetric_weight_kg=volumetric_weight_kg,
+        chargeable_weight_kg=chargeable_weight_kg,
+        basis=basis,
+        volume_m3=volume_m3,
+        mode=resolved_mode.value,
+        divisor=resolved_divisor,
+    )
+
+
+def calculate_consignment(
+    packages: List[dict],
+    mode,
+    unit: str = "cm",
+    weight_unit: str = "kg",
+    divisor_preset: Optional[str] = None,
+    divisor: Optional[float] = None,
+    per_piece: bool = False,
+) -> ConsolidatedResult:
+    """
+    Calculate chargeable weight across multiple packages in a consignment.
+
+    Args:
+        packages: List of dicts, each with keys "length", "width", "height",
+              "actual_weight", and optionally "quantity" (default 1).
+              Dimensions/weights are interpreted using the shared `unit`
+              and `weight_unit` arguments unless overridden per-package
+              with "unit" / "weight_unit" keys.
+        mode, unit, weight_unit, divisor_preset, divisor: See `calculate()`.
+        per_piece: If True, chargeable weight is computed per package
+              (actual vs volumetric compared individually, then summed -
+              a convention some couriers use). If False (default), totals
+              of actual and volumetric weight are summed separately first,
+              and chargeable weight is the max of the two totals.
+
+    Returns:
+        ConsolidatedResult with per-package results and consignment totals.
+    """
+    if not packages:
+        raise ValueError("packages list must not be empty.")
+
+    results: List[WeightResult] = []
+
+    for pkg in packages:
+        quantity = pkg.get("quantity", 1)
+        if quantity <= 0:
+            raise ValueError("quantity must be a positive integer.")
+
+        pkg_unit = pkg.get("unit", unit)
+        pkg_weight_unit = pkg.get("weight_unit", weight_unit)
+
+        result = calculate(
+            length=pkg["length"],
+            width=pkg["width"],
+            height=pkg["height"],
+            actual_weight=pkg["actual_weight"],
+            mode=mode,
+            unit=pkg_unit,
+            weight_unit=pkg_weight_unit,
+            divisor_preset=divisor_preset,
+            divisor=divisor,
+        )
+
+        for _ in range(quantity):
+            results.append(result)
+
+    total_actual = sum(r.actual_weight_kg for r in results)
+    total_volumetric = sum(r.volumetric_weight_kg for r in results)
+
+    if per_piece:
+        total_chargeable = sum(r.chargeable_weight_kg for r in results)
+    else:
+        total_chargeable = max(total_actual, total_volumetric)
+
+    overall_basis = "volumetric" if total_volumetric > total_actual else "actual"
+
+    return ConsolidatedResult(
+        packages=results,
+        total_actual_weight_kg=total_actual,
+        total_volumetric_weight_kg=total_volumetric,
+        total_chargeable_weight_kg=total_chargeable,
+        basis=overall_basis,
+        mode=_resolve_mode(mode).value,
+        per_piece=per_piece,
+    )

logisticspy/weight/divisors.py

@@ -0,0 +1,72 @@
+"""
+Volumetric (dimensional) weight divisors and conversion factors.
+
+Divisors represent cubic cm per kg.
+Volumetric weight = volume / divisor.
+
+Sea freight is handled differently: chargeable weight is typically based
+on CBM (cubic meters), with 1 CBM commonly treated as equivalent to
+1000 kg (i.e. volume_m3 * 1000 -> kg), under a "weight or measurement"
+(W/M) basis.
+
+Common divisor values seen across the freight and parcel industry:
+- 5000: a widely-used divisor for parcel/express-style shipments
+- 6000: a widely-used divisor for general air cargo
+- Road/rail freight commonly uses 3000-5000 depending on region and mode
+
+These values vary by carrier, service level, region, and contract terms.
+Always confirm the applicable divisor with your specific carrier for
+billing-critical calculations.
+"""
+
+from enum import Enum
+
+
+class Mode(str, Enum):
+    AIR = "air"
+    COURIER = "courier"
+    SEA = "sea"
+    ROAD = "road"
+    RAIL = "rail"
+
+
+# Default divisors in cm^3 per kg, applied as: volumetric_weight_kg = volume_cm3 / divisor
+# SEA mode is handled separately via CBM calculation (see calculator.py)
+DEFAULT_DIVISORS = {
+    Mode.AIR: 6000,
+    Mode.COURIER: 5000,
+    Mode.ROAD: 3000,
+    Mode.RAIL: 3000,
+    # Mode.SEA intentionally omitted - handled via CBM x 1000
+}
+
+# Named divisor presets, for users who want to refer to common values by
+# label rather than remembering raw numbers. These are generic industry
+# conventions, not tied to any specific carrier - always confirm the
+# applicable value with your own carrier or contract.
+DIVISOR_PRESETS = {
+    "a": 5000,
+    "b": 6000,
+}
+
+# Sea freight: 1 cubic meter (CBM) is conventionally treated as
+# equivalent to 1000 kg for chargeable weight purposes (the "W/M" -
+# weight or measurement - basis many ocean carriers use as a reference).
+SEA_CBM_TO_KG = 1000
+
+# Length unit conversions to centimeters
+LENGTH_TO_CM = {
+    "cm": 1.0,
+    "m": 100.0,
+    "mm": 0.1,
+    "in": 2.54,
+    "ft": 30.48,
+}
+
+# Weight unit conversions to kilograms
+WEIGHT_TO_KG = {
+    "kg": 1.0,
+    "g": 0.001,
+    "lb": 0.45359237,
+    "oz": 0.0283495231,
+}

logisticspy-0.1.0.dist-info/METADATA

@@ -0,0 +1,220 @@
+Metadata-Version: 2.4
+Name: logisticspy
+Version: 0.1.0
+Summary: A Python toolkit for logistics and supply chain calculations
+Author: krishnanz550i-cmyk
+License: MIT
+Project-URL: Homepage, https://github.com/krishnanz550i-cmyk/logisticspy
+Project-URL: Issues, https://github.com/krishnanz550i-cmyk/logisticspy/issues
+Keywords: logistics,supply chain,freight,chargeable weight
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# logisticspy
+
+A Python toolkit for logistics and supply chain calculations.
+
+`logisticspy` is a growing collection of clean, well-tested tools for
+common logistics and supply chain problems. The first module,
+**`logisticspy.weight`**, calculates volumetric (dimensional) weight and
+chargeable weight for air, courier, sea, road, and rail freight shipments.
+More tools (volume, freight, inventory, and others) will be added over
+time.
+
+## Install
+
+```bash
+pip install logisticspy
+```
+
+## Quick start
+
+You can use the chargeable weight tools either via the top-level package
+or via the `weight` module:
+
+```python
+# Option 1: top-level import
+import logisticspy
+
+result = logisticspy.calculate(
+    length=60, width=40, height=40, unit="cm",
+    actual_weight=18, weight_unit="kg",
+    mode="air",
+)
+
+# Option 2: import the weight module
+from logisticspy.weight import chargeable_weight
+
+result = chargeable_weight.calculate(
+    length=60, width=40, height=40, unit="cm",
+    actual_weight=18, weight_unit="kg",
+    mode="air",
+)
+
+print(result.volumetric_weight_kg)   # 19.2
+print(result.chargeable_weight_kg)   # 19.2
+print(result.basis)                  # "volumetric"
+```
+
+## The `weight` module: chargeable weight
+
+Carriers bill shipments based on whichever is greater: the **actual
+weight** or the **volumetric weight** (calculated from package
+dimensions). This module implements that calculation cleanly, with
+support for multiple units, transport modes, named divisor presets, and
+multi-package consignments.
+
+### Supported modes and default divisors
+
+| Mode      | Default divisor (cm³/kg) |
+|-----------|---------------------------|
+| `air`     | 6000 |
+| `courier` | 5000 |
+| `road`    | 3000 |
+| `rail`    | 3000 |
+| `sea`     | N/A (uses CBM × 1000, see below) |
+
+These are sensible starting defaults based on common conventions seen
+across the freight and parcel industry. They are **not** tied to any
+specific carrier - always confirm the applicable divisor with your own
+carrier or contract for billing-critical calculations.
+
+### Divisor presets
+
+Two divisor values - 5000 and 6000 - are both widely used across the
+industry, often for different services, regions, or contracts (sometimes
+even by the same carrier depending on the product). Rather than guessing
+which one applies to your situation, you can refer to them by generic
+preset labels and swap between them easily:
+
+| Preset | Divisor |
+|--------|---------|
+| `"a"`  | 5000 |
+| `"b"`  | 6000 |
+
+```python
+import logisticspy
+
+# Same package, two different divisor conventions
+pkg = dict(length=60, width=40, height=40, actual_weight=10, mode="air")
+
+result_a = logisticspy.calculate(**pkg, divisor_preset="a")  # divisor 5000
+result_b = logisticspy.calculate(**pkg, divisor_preset="b")  # divisor 6000
+
+print(result_a.volumetric_weight_kg)  # 19.2
+print(result_b.volumetric_weight_kg)  # 16.0
+```
+
+This makes it easy to compare "what would this shipment cost under each
+convention" without hardcoding either value, and to plug in your own
+carrier's documented divisor (whether that happens to be 5000, 6000, or
+something else entirely) via `divisor_preset` or a raw `divisor=` value.
+
+You can also pass an explicit divisor directly, which overrides any preset:
+
+```python
+result = logisticspy.calculate(**pkg, divisor=4500)
+```
+
+### Units
+
+#### Input units
+
+Dimensions accept `cm`, `m`, `mm`, `in`, `ft` (default `cm`).
+Weights accept `kg`, `g`, `lb`, `oz` (default `kg`).
+
+```python
+result = logisticspy.calculate(
+    length=20, width=15, height=10, unit="in",
+    actual_weight=5, weight_unit="lb",
+    mode="courier",
+)
+```
+
+#### Output units (always normalized)
+
+Regardless of the input units you choose, **all results are returned in
+a single fixed unit system**:
+
+| Field | Unit |
+|-------|------|
+| `actual_weight_kg`, `volumetric_weight_kg`, `chargeable_weight_kg` | kilograms (kg) |
+| `volume_m3` | cubic meters (m³) |
+
+The input units (`unit`, `weight_unit`) are only used to *interpret* the
+numbers you pass in - they are converted to centimeters and kilograms
+internally before any calculation happens. The output is never expressed
+back in the input units.
+
+If you need the result in a different unit (e.g. pounds), convert the
+returned kg value yourself - the library does not provide unit conversion
+on outputs.
+
+### Sea freight (CBM)
+
+Sea freight chargeable weight is derived from volume in cubic meters
+(CBM), using the common 1 CBM ≈ 1000 kg convention:
+
+```python
+result = logisticspy.calculate(
+    length=1, width=1, height=1, unit="m",
+    actual_weight=500, mode="sea",
+)
+print(result.volumetric_weight_kg)  # 1000.0
+```
+
+Divisor presets are ignored for sea mode, since it uses a CBM-based
+calculation rather than a divisor.
+
+### Multi-package consignments
+
+```python
+import logisticspy
+
+packages = [
+    {"length": 50, "width": 40, "height": 40, "actual_weight": 10},
+    {"length": 60, "width": 40, "height": 40, "actual_weight": 25, "quantity": 2},
+]
+
+result = logisticspy.calculate_consignment(packages, mode="air")
+
+print(result.total_actual_weight_kg)
+print(result.total_volumetric_weight_kg)
+print(result.total_chargeable_weight_kg)
+```
+
+By default, totals are compared (`sum(actual)` vs `sum(volumetric)`).
+Some couriers calculate chargeable weight per package and sum those - use
+`per_piece=True` for that behavior:
+
+```python
+result = logisticspy.calculate_consignment(packages, mode="air", per_piece=True)
+```
+
+## Roadmap
+
+`logisticspy` is designed to grow into a broader logistics toolkit.
+`chargeable_weight` is the first module; additional tools (e.g. volume,
+freight, and inventory calculations) will be added over time.
+
+## Disclaimer
+
+This library implements widely-used industry conventions for
+illustrative and estimation purposes. Divisors and CBM ratios vary by
+carrier, service level, region, and contract terms. Always confirm exact
+billing methodology with your carrier or freight forwarder for
+invoicing-critical calculations.
+
+## License
+
+MIT

logisticspy-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+logisticspy/__init__.py,sha256=H4X2MNhhLn7vcLUYhvdMIK6_VB6_Cv587R-WOpesDZQ,993
+logisticspy/weight/__init__.py,sha256=94IdASrAiVchplZA6i3TUQoErHgKNA7t4TPVlKX35SE,656
+logisticspy/weight/chargeable_weight.py,sha256=tTjHgBlXAetOEqDQ5bJv8YHeRY35zvzlsUCM-YbPSss,9725
+logisticspy/weight/divisors.py,sha256=I4E5JcZGnxZU8ysfDoudje_rtHtQRVBli0oizGOcwEI,2107
+logisticspy-0.1.0.dist-info/licenses/LICENSE,sha256=dSwPcwW5G_idlsArqi07jZ0aEczyuJ1jpJ92cGvWuAs,1075
+logisticspy-0.1.0.dist-info/METADATA,sha256=bSZ7A-nswv6VzE32-zx8RFyoZA-Vuhz1LqFpN7_-AOE,6784
+logisticspy-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+logisticspy-0.1.0.dist-info/top_level.txt,sha256=pXagobTJb9Npe89H4jqfrGhY7dStvu2QKz5F5o7Y5ec,12
+logisticspy-0.1.0.dist-info/RECORD,,

logisticspy-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
+

logisticspy-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 krishnanz550i-cmyk
+
+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.

logisticspy-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+logisticspy