geo-micro 0.1.0__tar.gz

geo_micro-0.1.0/LICENSE

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

geo_micro-0.1.0/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: geo-micro
+Version: 0.1.0
+Summary: A zero-dependency micro-utility for fast GeoJSON sanitisation and spatial checks.
+Author-email: Coby Williams <cobyw16@hotmail.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: GIS
+License-File: LICENSE
+Project-URL: Homepage, https://github.com/LionEmpire/geo-micro
+
+# geo-micro
+
+A zero-dependency, ultra-lightweight (<10KB) Python utility for GeoJSON sanitisation, coordinate order correction, bounding box calculations, and fast ray-casted point-in-polygon checks.
+Designed for AWS Lambda functions, microservices, and edge computing environments where heavy C-based libraries like Shapely or GDAL are overkill.
+
+## Features
+
+- Zero External Dependencies
+- Dirty Data Repair (string coordinates to floats and auto-closes unclosed polygon rings)
+- Coordinate Swapper: (`[Lat, Lng]` to `[Lng, Lat]` and vice versa)
+- Point-in-Polygon
+
+## Quickstart
+
+```python
+from geomicro import GeoMicro, convert_coords
+
+# 1. Fix Lat/Lng order for a list of coordinates
+bad_coords = [[-27.468, 153.028], [-27.470, 153.030]]
+fixed = convert_coords(bad_coords, mode="to_geojson")
+
+# 2. Check containment and bounding boxes
+polygon_feature = {
+    "type": "Polygon",
+    "coordinates": [[[153.0, -27.0], [154.0, -27.0], [154.0, -28.0], [153.0, -27.0]]]
+}
+
+geo = GeoMicro(polygon_feature)
+print(geo.bbox()) # (153.0, -28.0, 154.0, -27.0)
+print(geo.contains([153.5, -27.5])) # True
+```
+

geo_micro-0.1.0/README.md

@@ -0,0 +1,31 @@
+# geo-micro
+
+A zero-dependency, ultra-lightweight (<10KB) Python utility for GeoJSON sanitisation, coordinate order correction, bounding box calculations, and fast ray-casted point-in-polygon checks.
+Designed for AWS Lambda functions, microservices, and edge computing environments where heavy C-based libraries like Shapely or GDAL are overkill.
+
+## Features
+
+- Zero External Dependencies
+- Dirty Data Repair (string coordinates to floats and auto-closes unclosed polygon rings)
+- Coordinate Swapper: (`[Lat, Lng]` to `[Lng, Lat]` and vice versa)
+- Point-in-Polygon
+
+## Quickstart
+
+```python
+from geomicro import GeoMicro, convert_coords
+
+# 1. Fix Lat/Lng order for a list of coordinates
+bad_coords = [[-27.468, 153.028], [-27.470, 153.030]]
+fixed = convert_coords(bad_coords, mode="to_geojson")
+
+# 2. Check containment and bounding boxes
+polygon_feature = {
+    "type": "Polygon",
+    "coordinates": [[[153.0, -27.0], [154.0, -27.0], [154.0, -28.0], [153.0, -27.0]]]
+}
+
+geo = GeoMicro(polygon_feature)
+print(geo.bbox()) # (153.0, -28.0, 154.0, -27.0)
+print(geo.contains([153.5, -27.5])) # True
+```

geo_micro-0.1.0/geomicro/__init__.py

@@ -0,0 +1,24 @@
+from .core import (
+    sanitize_coord,
+    swap_lat_lng,
+    lat_lng_to_geojson,
+    geojson_to_lat_lng,
+    convert_coords,
+    auto_repair_ring,
+    get_bbox,
+    point_in_polygon,
+    GeoMicro,
+)
+
+__version__ = "0.1.0"
+__all__ = [
+    "sanitize_coord",
+    "swap_lat_lng",
+    "lat_lng_to_geojson",
+    "geojson_to_lat_lng",
+    "convert_coords",
+    "auto_repair_ring",
+    "get_bbox",
+    "point_in_polygon",
+    "GeoMicro",
+]

geo_micro-0.1.0/geomicro/core.py

@@ -0,0 +1,168 @@
+"""
+geo-micro: Zero-dependency GeoJSON micro-utility.
+Lightweight, pure-Python geometry sanitisation and spatial checks.
+"""
+
+from typing import List, Tuple, Union, Dict, Any
+
+PointType = Union[List[float], Tuple[float, float]]
+BoundingBox = Tuple[float, float, float, float]  # (min_lng, min_lat, max_lng, max_lat)
+
+
+def sanitize_coord(coord: Any) -> Tuple[float, float]:
+    """Ensures coordinates are valid floats."""
+    try:
+        lng = float(coord[0])
+        lat = float(coord[1])
+        return lng, lat
+    except (IndexError, TypeError, ValueError) as e:
+        raise ValueError(f"Invalid coordinate format: {coord}") from e
+
+
+def lat_lng_to_geojson(point: PointType) -> Tuple[float, float]:
+    """
+    Converts a single (Latitude, Longitude) pair into standard GeoJSON (Longitude, Latitude).
+    Example: (-27.468, 153.028) -> (153.028, -27.468)
+    """
+    lat, lng = sanitize_coord(point)
+    return lng, lat
+
+
+def geojson_to_lat_lng(point: PointType) -> Tuple[float, float]:
+    """
+    Converts a single GeoJSON (Longitude, Latitude) pair into standard (Latitude, Longitude).
+    Example: (153.028, -27.468) -> (-27.468, 153.028)
+    """
+    lng, lat = sanitize_coord(point)
+    return lat, lng
+
+def swap_lat_lng(coord: PointType) -> Tuple[float, float]:
+    """Swaps a (Lat, Lng) pair to (Lng, Lat) or vice versa."""
+    a, b = sanitize_coord(coord)
+    return b, a
+
+def convert_coords(coords: List[Any], mode: str = "to_geojson") -> List[Any]:
+    """
+    Recursively converts coordinates across nested structures (arrays, rings, polygons).
+    
+    :param coords: List of coordinate pairs or nested lists.
+    :param mode: 'to_geojson' (swaps Lat/Lng -> Lng/Lat) or 'to_latlng' (swaps Lng/Lat -> Lat/Lng).
+    """
+    if not coords:
+        return []
+    if isinstance(coords[0], (int, float, str)):
+        if mode == "to_geojson":
+            lng, lat = lat_lng_to_geojson(coords)
+            return [lng, lat]
+        elif mode == "to_latlng":
+            lat, lng = geojson_to_lat_lng(coords)
+            return [lat, lng]
+        else:
+            raise ValueError(f"Invalid mode: '{mode}'. Use 'to_geojson' or 'to_latlng'.")
+            
+    return [convert_coords(c, mode=mode) for c in coords]
+
+
+def auto_repair_ring(ring: List[PointType]) -> List[Tuple[float, float]]:
+    """
+    Cleans ring coordinates: casts string values to floats and ensures 
+    the polygon ring is closed (first point equals last point).
+    """
+    if len(ring) < 3:
+        raise ValueError("A polygon ring must contain at least 3 points.")
+    
+    clean_ring = [sanitize_coord(p) for p in ring]
+    
+    # Close ring if open
+    if clean_ring[0] != clean_ring[-1]:
+        clean_ring.append(clean_ring[0])
+        
+    return clean_ring
+
+
+def get_bbox(geometry_or_geojson: Dict[str, Any]) -> BoundingBox:
+    """
+    Computes a (min_lng, min_lat, max_lng, max_lat) bounding box for any
+    supported GeoJSON object (Point, LineString, Polygon, Feature, FeatureCollection).
+    """
+    coords: List[Tuple[float, float]] = []
+
+    def _extract_coords(obj: Any):
+        if isinstance(obj, dict):
+            if obj.get("type") == "FeatureCollection":
+                for feat in obj.get("features", []):
+                    _extract_coords(feat)
+            elif obj.get("type") == "Feature":
+                _extract_coords(obj.get("geometry", {}))
+            elif "coordinates" in obj:
+                _extract_coords(obj["coordinates"])
+        elif isinstance(obj, list):
+            if len(obj) >= 2 and isinstance(obj[0], (int, float, str)) and isinstance(obj[1], (int, float, str)):
+                coords.append(sanitize_coord(obj))
+            else:
+                for sub in obj:
+                    _extract_coords(sub)
+
+    _extract_coords(geometry_or_geojson)
+
+    if not coords:
+        raise ValueError("No valid coordinates found to calculate bounding box.")
+
+    lngs = [c[0] for c in coords]
+    lats = [c[1] for c in coords]
+    
+    return min(lngs), min(lats), max(lngs), max(lats)
+
+
+def point_in_polygon(point: PointType, polygon_ring: List[PointType]) -> bool:
+    """
+    Determines if a point is inside a polygon ring using the Ray-Casting algorithm.
+    Expects coordinates in standard GeoJSON [Lng, Lat] format.
+    """
+    px, py = sanitize_coord(point)
+    ring = auto_repair_ring(polygon_ring)
+    
+    inside = False
+    n = len(ring)
+    
+    j = n - 1
+    for i in range(n):
+        xi, yi = ring[i]
+        xj, yj = ring[j]
+        
+        # Ray-casting intersection check
+        intersect = ((yi > py) != (yj > py)) and (px < (xj - xi) * (py - yi) / (yj - yi + 1e-12) + xi)
+        if intersect:
+            inside = not inside
+        j = i
+        
+    return inside
+
+
+class GeoMicro:
+    """Convenience wrapper class for fluent chaining."""
+    
+    def __init__(self, geojson: Dict[str, Any]):
+        self.geojson = geojson
+
+    def bbox(self) -> BoundingBox:
+        return get_bbox(self.geojson)
+
+    def contains(self, point: PointType) -> bool:
+        geom_type = self.geojson.get("type")
+        
+        if geom_type == "Polygon":
+            coords = self.geojson.get("coordinates", [])
+        elif geom_type == "Feature":
+            coords = self.geojson.get("geometry", {}).get("coordinates", [])
+        else:
+            raise NotImplementedError(f"Point containment for type '{geom_type}' is not directly supported.")
+            
+        if not coords:
+            raise ValueError("No coordinates found in GeoJSON object.")
+
+        outer_ring = coords[0]
+        if isinstance(outer_ring, list) and len(outer_ring) > 0 and isinstance(outer_ring[0], list) and isinstance(outer_ring[0][0], (list, tuple)):
+            outer_ring = outer_ring[0]
+
+        return point_in_polygon(point, outer_ring)

geo_micro-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["flit_core >=3.2,<4"]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "geo-micro"
+version = "0.1.0"
+description = "A zero-dependency micro-utility for fast GeoJSON sanitisation and spatial checks."
+readme = "README.md"
+authors = [{ name = "Coby Williams", email = "cobyw16@hotmail.com" }]
+license = { file = "LICENSE" }
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: GIS",
+]
+requires-python = ">=3.8"
+
+[project.urls]
+Homepage = "https://github.com/LionEmpire/geo-micro"
+
+[tool.pytest.ini_options]
+pythonpath = "."
+testpaths = ["tests"]
+
+[tool.flit.module]
+name = "geomicro"