geoai-py 0.2.2__py2.py3-none-any.whl → 0.2.3__py2.py3-none-any.whl

geoai/__init__.py

@@ -2,7 +2,7 @@
 
 __author__ = """Qiusheng Wu"""
 __email__ = "giswqs@gmail.com"
-__version__ = "0.2.2"
+__version__ = "0.2.3"
 
 
 import os

geoai/common.py

@@ -4,7 +4,7 @@ import os
 from collections.abc import Iterable
 from typing import Any, Dict, List, Optional, Tuple, Type, Union, Callable
 import matplotlib.pyplot as plt
-
+import geopandas as gpd
 import leafmap
 import torch
 import numpy as np
@@ -17,7 +17,7 @@ from torchgeo.samplers import RandomGeoSampler, Units
 from torchgeo.transforms import indices
 
 
-def viz_raster(
+def view_raster(
     source: str,
     indexes: Optional[int] = None,
     colormap: Optional[str] = None,
@@ -85,7 +85,7 @@ def viz_raster(
     return m
 
 
-def viz_image(
+def view_image(
     image: Union[np.ndarray, torch.Tensor],
     transpose: bool = False,
     bdx: Optional[int] = None,
@@ -436,3 +436,188 @@ def dict_to_image(
     else:
         image = leafmap.array_to_image(da, **kwargs)
         return image
+
+
+def view_vector(
+    vector_data,
+    column=None,
+    cmap="viridis",
+    figsize=(10, 10),
+    title=None,
+    legend=True,
+    basemap=False,
+    alpha=0.7,
+    edge_color="black",
+    classification="quantiles",
+    n_classes=5,
+    highlight_index=None,
+    highlight_color="red",
+    scheme=None,
+    save_path=None,
+    dpi=300,
+):
+    """
+    Visualize vector datasets with options for styling, classification, basemaps and more.
+
+    This function visualizes GeoDataFrame objects with customizable symbology.
+    It supports different vector types (points, lines, polygons), attribute-based
+    classification, and background basemaps.
+
+    Args:
+        vector_data (geopandas.GeoDataFrame): The vector dataset to visualize.
+        column (str, optional): Column to use for choropleth mapping. If None,
+            a single color will be used. Defaults to None.
+        cmap (str or matplotlib.colors.Colormap, optional): Colormap to use for
+            choropleth mapping. Defaults to "viridis".
+        figsize (tuple, optional): Figure size as (width, height) in inches.
+            Defaults to (10, 10).
+        title (str, optional): Title for the plot. Defaults to None.
+        legend (bool, optional): Whether to display a legend. Defaults to True.
+        basemap (bool, optional): Whether to add a web basemap. Requires contextily.
+            Defaults to False.
+        alpha (float, optional): Transparency of the vector features, between 0-1.
+            Defaults to 0.7.
+        edge_color (str, optional): Color for feature edges. Defaults to "black".
+        classification (str, optional): Classification method for choropleth maps.
+            Options: "quantiles", "equal_interval", "natural_breaks".
+            Defaults to "quantiles".
+        n_classes (int, optional): Number of classes for choropleth maps.
+            Defaults to 5.
+        highlight_index (list, optional): List of indices to highlight.
+            Defaults to None.
+        highlight_color (str, optional): Color to use for highlighted features.
+            Defaults to "red".
+        scheme (str, optional): MapClassify classification scheme. Overrides
+            classification parameter if provided. Defaults to None.
+        save_path (str, optional): Path to save the figure. If None, the figure
+            is not saved. Defaults to None.
+        dpi (int, optional): DPI for saved figure. Defaults to 300.
+
+    Returns:
+        matplotlib.axes.Axes: The Axes object containing the plot.
+
+    Examples:
+        >>> import geopandas as gpd
+        >>> cities = gpd.read_file("cities.shp")
+        >>> view_vector(cities, "population", cmap="Reds", basemap=True)
+
+        >>> roads = gpd.read_file("roads.shp")
+        >>> view_vector(roads, "type", basemap=True, figsize=(12, 8))
+    """
+    import contextily as ctx
+
+    if isinstance(vector_data, str):
+        vector_data = gpd.read_file(vector_data)
+
+    # Check if input is a GeoDataFrame
+    if not isinstance(vector_data, gpd.GeoDataFrame):
+        raise TypeError("Input data must be a GeoDataFrame")
+
+    # Make a copy to avoid changing the original data
+    gdf = vector_data.copy()
+
+    # Set up figure and axis
+    fig, ax = plt.subplots(figsize=figsize)
+
+    # Determine geometry type
+    geom_type = gdf.geometry.iloc[0].geom_type
+
+    # Plotting parameters
+    plot_kwargs = {"alpha": alpha, "ax": ax}
+
+    # Set up keyword arguments based on geometry type
+    if "Point" in geom_type:
+        plot_kwargs["markersize"] = 50
+        plot_kwargs["edgecolor"] = edge_color
+    elif "Line" in geom_type:
+        plot_kwargs["linewidth"] = 1
+    elif "Polygon" in geom_type:
+        plot_kwargs["edgecolor"] = edge_color
+
+    # Classification options
+    if column is not None:
+        if scheme is not None:
+            # Use mapclassify scheme if provided
+            plot_kwargs["scheme"] = scheme
+        else:
+            # Use classification parameter
+            if classification == "quantiles":
+                plot_kwargs["scheme"] = "quantiles"
+            elif classification == "equal_interval":
+                plot_kwargs["scheme"] = "equal_interval"
+            elif classification == "natural_breaks":
+                plot_kwargs["scheme"] = "fisher_jenks"
+
+        plot_kwargs["k"] = n_classes
+        plot_kwargs["cmap"] = cmap
+        plot_kwargs["column"] = column
+        plot_kwargs["legend"] = legend
+
+    # Plot the main data
+    gdf.plot(**plot_kwargs)
+
+    # Highlight specific features if requested
+    if highlight_index is not None:
+        gdf.iloc[highlight_index].plot(
+            ax=ax, color=highlight_color, edgecolor="black", linewidth=2, zorder=5
+        )
+
+    # Add basemap if requested
+    if basemap:
+        try:
+            ctx.add_basemap(ax, crs=gdf.crs, source=ctx.providers.OpenStreetMap.Mapnik)
+        except Exception as e:
+            print(f"Could not add basemap: {e}")
+
+    # Set title if provided
+    if title:
+        ax.set_title(title, fontsize=14)
+
+    # Remove axes if not needed
+    ax.set_axis_off()
+
+    # Adjust layout
+    plt.tight_layout()
+
+    # Save figure if a path is provided
+    if save_path:
+        plt.savefig(save_path, dpi=dpi, bbox_inches="tight")
+
+    return ax
+
+
+def view_vector_interactive(
+    vector_data,
+    **kwargs,
+):
+    """
+    Visualize vector datasets with options for styling, classification, basemaps and more.
+
+    This function visualizes GeoDataFrame objects with customizable symbology.
+    It supports different vector types (points, lines, polygons), attribute-based
+    classification, and background basemaps.
+
+    Args:
+        vector_data (geopandas.GeoDataFrame): The vector dataset to visualize.
+        **kwargs: Additional keyword arguments to pass to GeoDataFrame.explore() function.
+        See https://geopandas.org/en/stable/docs/reference/api/geopandas.GeoDataFrame.explore.html
+
+    Returns:
+        folium.Map: The map object with the vector data added.
+
+    Examples:
+        >>> import geopandas as gpd
+        >>> cities = gpd.read_file("cities.shp")
+        >>> view_vector_interactive(cities)
+
+        >>> roads = gpd.read_file("roads.shp")
+        >>> view_vector_interactive(roads, figsize=(12, 8))
+    """
+    if isinstance(vector_data, str):
+        vector_data = gpd.read_file(vector_data)
+
+    # Check if input is a GeoDataFrame
+    if not isinstance(vector_data, gpd.GeoDataFrame):
+        raise TypeError("Input data must be a GeoDataFrame")
+
+    return vector_data.explore(**kwargs)

geoai/extract.py

@@ -198,7 +198,7 @@ class BuildingFootprintExtractor:
 
             # Define the repository ID and model filename
             repo_id = "giswqs/geoai"  # Update with your actual username/repo
-            filename = "usa_building_footprints.pth"
+            filename = "building_footprints_usa.pth"
 
             # Ensure cache directory exists
             # cache_dir = os.path.join(
@@ -718,7 +718,7 @@ class BuildingFootprintExtractor:
         if "confidence" in gdf.columns:
             # Create a colorbar legend
             sm = plt.cm.ScalarMappable(
-                cmap=plt.cm.viridis,
+                cmap=plt.get_cmap("viridis"),
                 norm=plt.Normalize(gdf.confidence.min(), gdf.confidence.max()),
             )
             sm.set_array([])

geoai/geoai.py

@@ -2,3 +2,4 @@
 
 from .common import *
 from .preprocess import *
+from .extract import *

geoai/preprocess.py

@@ -13,7 +13,7 @@ import pandas as pd
 from rasterio.windows import Window
 from rasterio import features
 from rasterio.plot import show
-from shapely.geometry import box, shape
+from shapely.geometry import box, shape, mapping
 import matplotlib.pyplot as plt
 from tqdm import tqdm
 from torchvision.transforms import RandomRotation
@@ -945,32 +945,6 @@ def batch_raster_to_vector(
     return None
 
 
-# # Example usage
-# if __name__ == "__main__":
-#     # Single file conversion example
-#     gdf = raster_to_vector(
-#         raster_path="output/labels/tile_000001.tif",
-#         output_path="output/labels/tile_000001.geojson",
-#         threshold=0,
-#         min_area=10,
-#         simplify_tolerance=0.5,
-#         class_values=[1],  # For a binary mask, use [1]
-#         attribute_name='class',
-#         plot_result=True
-#     )
-
-# Batch conversion example
-# batch_raster_to_vector(
-#     input_dir="path/to/labels",
-#     output_dir="path/to/vectors",
-#     pattern="*.tif",
-#     threshold=0,
-#     min_area=10,
-#     class_values=[1, 2, 3],  # For a multiclass mask
-#     merge_output=True
-# )
-
-
 def vector_to_raster(
     vector_path,
     output_path=None,
@@ -1280,39 +1254,6 @@ def batch_vector_to_raster(
     return output_files
 
 
-# # Example usage
-# if __name__ == "__main__":
-#     # Single file conversion example
-#     raster_data = vector_to_raster(
-#         vector_path="buildings_train.geojson",
-#         output_path="buildings_train.tif",
-#         reference_raster="naip_train.tif",  # Optional, can use other parameters instead
-#         # attribute_field="class",  # Optional, uses field values for pixel values
-#         all_touched=True,  # Ensures small features are captured
-#         plot_result=True
-#     )
-
-# Example with custom dimensions
-# raster_data = vector_to_raster(
-#     vector_path="path/to/buildings.geojson",
-#     output_path="path/to/rasterized_buildings.tif",
-#     pixel_size=0.5,  # 0.5 meter resolution
-#     bounds=(454780, 5277567, 456282, 5278242),  # from original data
-#     crs="EPSG:26911",
-#     output_shape=(1350, 3000),  # custom dimensions
-#     attribute_field="class"
-# )
-
-# Batch conversion example
-# output_files = batch_vector_to_raster(
-#     vector_path="path/to/buildings.geojson",
-#     output_dir="path/to/output",
-#     reference_rasters=["path/to/ref1.tif", "path/to/ref2.tif"],
-#     attribute_field="class",
-#     all_touched=True
-# )
-
-
 def export_geotiff_tiles(
     in_raster,
     out_folder,
@@ -1823,8 +1764,22 @@ def export_geotiff_tiles(
         return stats
 
 
-def create_overview_image(src, tile_coordinates, output_path, tile_size, stride):
-    """Create an overview image showing all tiles and their status."""
+def create_overview_image(
+    src, tile_coordinates, output_path, tile_size, stride, geojson_path=None
+):
+    """Create an overview image showing all tiles and their status, with optional GeoJSON export.
+
+    Args:
+        src (rasterio.io.DatasetReader): The source raster dataset.
+        tile_coordinates (list): A list of dictionaries containing tile information.
+        output_path (str): The path where the overview image will be saved.
+        tile_size (int): The size of each tile in pixels.
+        stride (int): The stride between tiles in pixels. Controls overlap between adjacent tiles.
+        geojson_path (str, optional): If provided, exports the tile rectangles as GeoJSON to this path.
+
+    Returns:
+        str: Path to the saved overview image.
+    """
     # Read a reduced version of the source image
     overview_scale = max(
         1, int(max(src.width, src.height) / 2000)
@@ -1857,6 +1812,10 @@ def create_overview_image(src, tile_coordinates, output_path, tile_size, stride)
     plt.figure(figsize=(12, 12))
     plt.imshow(rgb)
 
+    # If GeoJSON export is requested, prepare GeoJSON structures
+    if geojson_path:
+        features = []
+
     # Draw tile boundaries
     for tile in tile_coordinates:
         # Convert bounds to pixel coordinates in overview
@@ -1886,6 +1845,43 @@ def create_overview_image(src, tile_coordinates, output_path, tile_size, stride)
                 fontsize=8,
             )
 
+        # Add to GeoJSON features if exporting
+        if geojson_path:
+            # Create a polygon from the bounds (already in geo-coordinates)
+            minx, miny, maxx, maxy = bounds
+            polygon = box(minx, miny, maxx, maxy)
+
+            # Calculate overlap with neighboring tiles
+            overlap = 0
+            if stride < tile_size:
+                overlap = tile_size - stride
+
+            # Create a GeoJSON feature
+            feature = {
+                "type": "Feature",
+                "geometry": mapping(polygon),
+                "properties": {
+                    "index": tile["index"],
+                    "has_features": tile["has_features"],
+                    "bounds_pixel": [
+                        tile["x"],
+                        tile["y"],
+                        tile["x"] + tile_size,
+                        tile["y"] + tile_size,
+                    ],
+                    "tile_size_px": tile_size,
+                    "stride_px": stride,
+                    "overlap_px": overlap,
+                },
+            }
+
+            # Add any additional properties from the tile
+            for key, value in tile.items():
+                if key not in ["x", "y", "index", "has_features", "bounds"]:
+                    feature["properties"][key] = value
+
+            features.append(feature)
+
     plt.title("Tile Overview (Green = Contains Features, Red = Empty)")
     plt.axis("off")
     plt.tight_layout()
@@ -1894,42 +1890,134 @@ def create_overview_image(src, tile_coordinates, output_path, tile_size, stride)
 
     print(f"Overview image saved to {output_path}")
 
+    # Export GeoJSON if requested
+    if geojson_path:
+        geojson_collection = {
+            "type": "FeatureCollection",
+            "features": features,
+            "properties": {
+                "crs": (
+                    src.crs.to_string()
+                    if hasattr(src.crs, "to_string")
+                    else str(src.crs)
+                ),
+                "total_tiles": len(features),
+                "source_raster_dimensions": [src.width, src.height],
+            },
+        }
+
+        # Save to file
+        with open(geojson_path, "w") as f:
+            json.dump(geojson_collection, f)
+
+        print(f"GeoJSON saved to {geojson_path}")
+
+    return output_path
+
 
-# # Example usage
-# if __name__ == "__main__":
-#     # Try to install tqdm if not available
-#     try:
-#         import tqdm
-#     except ImportError:
-#         print("Installing tqdm progress bar library...")
-#         import sys
-#         import subprocess
-
-#         subprocess.check_call([sys.executable, "-m", "pip", "install", "tqdm"])
-#         import tqdm
-
-#     # Example with vector class data
-#     export_geotiff_tiles(
-#         in_raster="naip_train.tif",
-#         out_folder="geotiff_output_vector",
-#         in_class_data="buildings_train.geojson",
-#         tile_size=256,
-#         stride=128,
-#         class_value_field="class",
-#         buffer_radius=2,
-#         create_overview=True,
-#     )
-
-#     # Example with raster class data
-#     export_geotiff_tiles(
-#         in_raster="naip_train.tif",
-#         out_folder="geotiff_output_raster",
-#         in_class_data="buildings_train.tif",  # This would be a raster mask
-#         tile_size=256,
-#         stride=128,
-#         create_overview=True,
-#         skip_empty_tiles=True,
-#     )
+def export_tiles_to_geojson(
+    tile_coordinates, src, output_path, tile_size=None, stride=None
+):
+    """
+    Export tile rectangles directly to GeoJSON without creating an overview image.
+
+    Args:
+        tile_coordinates (list): A list of dictionaries containing tile information.
+        src (rasterio.io.DatasetReader): The source raster dataset.
+        output_path (str): The path where the GeoJSON will be saved.
+        tile_size (int, optional): The size of each tile in pixels. Only needed if not in tile_coordinates.
+        stride (int, optional): The stride between tiles in pixels. Used to calculate overlaps between tiles.
+
+    Returns:
+        str: Path to the saved GeoJSON file.
+    """
+    features = []
+
+    for tile in tile_coordinates:
+        # Get the size from the tile or use the provided parameter
+        tile_width = tile.get("width", tile.get("size", tile_size))
+        tile_height = tile.get("height", tile.get("size", tile_size))
+
+        if tile_width is None or tile_height is None:
+            raise ValueError(
+                "Tile size not found in tile data and no tile_size parameter provided"
+            )
+
+        # Get bounds from the tile
+        if "bounds" in tile:
+            # If bounds are already in geo coordinates
+            minx, miny, maxx, maxy = tile["bounds"]
+        else:
+            # Try to calculate bounds from transform if available
+            if hasattr(src, "transform"):
+                # Convert pixel coordinates to geo coordinates
+                window_transform = src.transform
+                x, y = tile["x"], tile["y"]
+                minx = window_transform[2] + x * window_transform[0]
+                maxy = window_transform[5] + y * window_transform[4]
+                maxx = minx + tile_width * window_transform[0]
+                miny = maxy + tile_height * window_transform[4]
+            else:
+                raise ValueError(
+                    "Cannot determine bounds. Neither 'bounds' in tile nor transform in src."
+                )
+
+        # Calculate overlap with neighboring tiles if stride is provided
+        overlap = 0
+        if stride is not None and stride < tile_width:
+            overlap = tile_width - stride
+
+        # Create a polygon from the bounds
+        polygon = box(minx, miny, maxx, maxy)
+
+        # Create a GeoJSON feature
+        feature = {
+            "type": "Feature",
+            "geometry": mapping(polygon),
+            "properties": {
+                "index": tile["index"],
+                "has_features": tile.get("has_features", False),
+                "tile_width_px": tile_width,
+                "tile_height_px": tile_height,
+            },
+        }
+
+        # Add overlap information if stride is provided
+        if stride is not None:
+            feature["properties"]["stride_px"] = stride
+            feature["properties"]["overlap_px"] = overlap
+
+        # Add additional properties from the tile
+        for key, value in tile.items():
+            if key not in ["bounds", "geometry"]:
+                feature["properties"][key] = value
+
+        features.append(feature)
+
+    # Create the GeoJSON collection
+    geojson_collection = {
+        "type": "FeatureCollection",
+        "features": features,
+        "properties": {
+            "crs": (
+                src.crs.to_string() if hasattr(src.crs, "to_string") else str(src.crs)
+            ),
+            "total_tiles": len(features),
+            "source_raster_dimensions": (
+                [src.width, src.height] if hasattr(src, "width") else None
+            ),
+        },
+    }
+
+    # Create directory if it doesn't exist
+    os.makedirs(os.path.dirname(os.path.abspath(output_path)) or ".", exist_ok=True)
+
+    # Save to file
+    with open(output_path, "w") as f:
+        json.dump(geojson_collection, f)
+
+    print(f"GeoJSON saved to {output_path}")
+    return output_path
 
 
 def export_training_data(
@@ -2674,22 +2762,3 @@ def export_training_data(
 
     # Return statistics
     return stats, out_folder
-
-
-# if __name__ == "__main__":
-#     # Example parameters
-#     export_training_data(
-#         in_raster="naip_train.tif",
-#         out_folder="output",
-#         in_class_data="buildings_train.geojson",
-#         image_chip_format="GEOTIFF",  # Use GeoTIFF format to preserve georeference
-#         tile_size_x=256,
-#         tile_size_y=256,
-#         stride_x=128,  # Use overlapping tiles to increase chance of capturing features
-#         stride_y=128,
-#         metadata_format="PASCAL_VOC",
-#         class_value_field="class",
-#         buffer_radius=2,  # Add small buffer to buildings to ensure they're captured
-#         all_touched=True,  # Ensure small features are rasterized
-#         save_geotiff=True,  # Always save as GeoTIFF regardless of image_chip_format
-#     )

{geoai_py-0.2.2.dist-info → geoai_py-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: geoai-py
-Version: 0.2.2
+Version: 0.2.3
 Summary: A Python package for using Artificial Intelligence (AI) with geospatial data
 Author-email: Qiusheng Wu <giswqs@gmail.com>
 License: MIT License
@@ -18,11 +18,13 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: albumentations
+Requires-Dist: contextily
 Requires-Dist: geopandas
 Requires-Dist: huggingface_hub
 Requires-Dist: jupyter-server-proxy
 Requires-Dist: leafmap
 Requires-Dist: localtileserver
+Requires-Dist: mapclassify
 Requires-Dist: overturemaps
 Requires-Dist: planetary-computer
 Requires-Dist: pystac-client

geoai_py-0.2.3.dist-info/RECORD

@@ -0,0 +1,13 @@
+geoai/__init__.py,sha256=TyhISsNnMOVPLx0wyM79k-Dgfak4s7QhfKPEIh0rBg8,923
+geoai/common.py,sha256=stnGB-OiTdpb9hTSaaVn5jKAGweFNM760NFKP6suiv0,21735
+geoai/download.py,sha256=4GiDmLrp2wKslgfm507WeZrwOdYcMekgQXxWGbl5cBw,13094
+geoai/extract.py,sha256=wjo5KyaUMsci3oclnOGFqwPe1VIV4vlkFcbJlPWDOzI,31572
+geoai/geoai.py,sha256=r9mFviDJrs7xvbK8kN3kIzZp-yswqTAleUejQvrZD4U,91
+geoai/preprocess.py,sha256=2O3gaGN5imIpmTdudQdTbvCtrBqdmOb0AGNEz81MW2M,109762
+geoai/segmentation.py,sha256=Vcymnhwl_xikt4v9x8CYJq_vId9R1gB7-YzLfwg-F9M,11372
+geoai_py-0.2.3.dist-info/LICENSE,sha256=vN2L5U7cZ6ZkOHFmc8WiGlsogWsZc5dllMeNxnKVOZg,1070
+geoai_py-0.2.3.dist-info/METADATA,sha256=T7lSXz-PE_AUSStKbnE5HUJi7-q5w04VIyiI7TZ4Xrw,5754
+geoai_py-0.2.3.dist-info/WHEEL,sha256=rF4EZyR2XVS6irmOHQIJx2SUqXLZKRMUrjsg8UwN-XQ,109
+geoai_py-0.2.3.dist-info/entry_points.txt,sha256=uGp3Az3HURIsRHP9v-ys0hIbUuBBNUfXv6VbYHIXeg4,41
+geoai_py-0.2.3.dist-info/top_level.txt,sha256=1YkCUWu-ii-0qIex7kbwAvfei-gos9ycyDyUCJPNWHY,6
+geoai_py-0.2.3.dist-info/RECORD,,

geoai_py-0.2.2.dist-info/RECORD

@@ -1,13 +0,0 @@
-geoai/__init__.py,sha256=yEbFyHPNijxgK-75tatrRELZ9TUdZVYo2uPlxCeBFDA,923
-geoai/common.py,sha256=NdfkQKMPHkwr0B5sDpH5Q_7Nt2AmYt9Gw-KE88NsQ5s,15222
-geoai/download.py,sha256=4GiDmLrp2wKslgfm507WeZrwOdYcMekgQXxWGbl5cBw,13094
-geoai/extract.py,sha256=Fh29d5Fj60YiqhMs62lzkd9T_ONTp2UZ4j98We769sg,31563
-geoai/geoai.py,sha256=BCEtHil0P5cettJdMIhblg1pRaV-vHNQFaYmBrtYP3g,68
-geoai/preprocess.py,sha256=pYtf3-eZY76SKd17MvEZ1qNUvblYW5kzQLvZ-ZM4Wwg,106833
-geoai/segmentation.py,sha256=Vcymnhwl_xikt4v9x8CYJq_vId9R1gB7-YzLfwg-F9M,11372
-geoai_py-0.2.2.dist-info/LICENSE,sha256=vN2L5U7cZ6ZkOHFmc8WiGlsogWsZc5dllMeNxnKVOZg,1070
-geoai_py-0.2.2.dist-info/METADATA,sha256=baREpHpvCvfktqiMSWNI-FGOVme8NAj0UkaJhS6Bkm4,5701
-geoai_py-0.2.2.dist-info/WHEEL,sha256=rF4EZyR2XVS6irmOHQIJx2SUqXLZKRMUrjsg8UwN-XQ,109
-geoai_py-0.2.2.dist-info/entry_points.txt,sha256=uGp3Az3HURIsRHP9v-ys0hIbUuBBNUfXv6VbYHIXeg4,41
-geoai_py-0.2.2.dist-info/top_level.txt,sha256=1YkCUWu-ii-0qIex7kbwAvfei-gos9ycyDyUCJPNWHY,6
-geoai_py-0.2.2.dist-info/RECORD,,