geoai-py 0.1.5__py2.py3-none-any.whl → 0.1.7__py2.py3-none-any.whl

geoai/__init__.py

@@ -2,4 +2,7 @@
 
 __author__ = """Qiusheng Wu"""
 __email__ = "giswqs@gmail.com"
-__version__ = "0.1.5"
+__version__ = "0.1.7"
+
+
+from .geoai import *

geoai/common.py

@@ -1,6 +1,279 @@
 """The common module contains common functions and classes used by the other modules."""
 
+import os
+from collections.abc import Iterable
+from typing import Any, Dict, List, Optional, Tuple, Type, Union, Callable
+import matplotlib.pyplot as plt
 
-def hello_world():
-    """Prints "Hello World!" to the console."""
-    print("Hello World!")
+import torch
+import numpy as np
+from torch.utils.data import DataLoader
+from torchgeo.datasets import RasterDataset, stack_samples, unbind_samples, utils
+from torchgeo.samplers import RandomGeoSampler, Units
+from torchgeo.transforms import indices
+
+
+def viz_raster(
+    source: str,
+    indexes: Optional[int] = None,
+    colormap: Optional[str] = None,
+    vmin: Optional[float] = None,
+    vmax: Optional[float] = None,
+    nodata: Optional[float] = None,
+    attribution: Optional[str] = None,
+    layer_name: Optional[str] = "Raster",
+    layer_index: Optional[int] = None,
+    zoom_to_layer: Optional[bool] = True,
+    visible: Optional[bool] = True,
+    opacity: Optional[float] = 1.0,
+    array_args: Optional[Dict] = {},
+    client_args: Optional[Dict] = {"cors_all": False},
+    basemap: Optional[str] = "OpenStreetMap",
+    **kwargs,
+):
+    """
+    Visualize a raster using leafmap.
+
+    Args:
+        source (str): The source of the raster.
+        indexes (Optional[int], optional): The band indexes to visualize. Defaults to None.
+        colormap (Optional[str], optional): The colormap to apply. Defaults to None.
+        vmin (Optional[float], optional): The minimum value for colormap scaling. Defaults to None.
+        vmax (Optional[float], optional): The maximum value for colormap scaling. Defaults to None.
+        nodata (Optional[float], optional): The nodata value. Defaults to None.
+        attribution (Optional[str], optional): The attribution for the raster. Defaults to None.
+        layer_name (Optional[str], optional): The name of the layer. Defaults to "Raster".
+        layer_index (Optional[int], optional): The index of the layer. Defaults to None.
+        zoom_to_layer (Optional[bool], optional): Whether to zoom to the layer. Defaults to True.
+        visible (Optional[bool], optional): Whether the layer is visible. Defaults to True.
+        opacity (Optional[float], optional): The opacity of the layer. Defaults to 1.0.
+        array_args (Optional[Dict], optional): Additional arguments for array processing. Defaults to {}.
+        client_args (Optional[Dict], optional): Additional arguments for the client. Defaults to {"cors_all": False}.
+        basemap (Optional[str], optional): The basemap to use. Defaults to "OpenStreetMap".
+        **kwargs (Any): Additional keyword arguments.
+
+    Returns:
+        leafmap.Map: The map object with the raster layer added.
+    """
+    import leafmap
+
+    m = leafmap.Map(basemap=basemap)
+
+    m.add_raster(
+        source=source,
+        indexes=indexes,
+        colormap=colormap,
+        vmin=vmin,
+        vmax=vmax,
+        nodata=nodata,
+        attribution=attribution,
+        layer_name=layer_name,
+        layer_index=layer_index,
+        zoom_to_layer=zoom_to_layer,
+        visible=visible,
+        opacity=opacity,
+        array_args=array_args,
+        client_args=client_args,
+        **kwargs,
+    )
+    return m
+
+
+def viz_image(
+    image: Union[np.ndarray, torch.Tensor],
+    transpose: bool = False,
+    bdx: Optional[int] = None,
+    scale_factor: float = 1.0,
+    figsize: Tuple[int, int] = (10, 5),
+    axis_off: bool = True,
+    **kwargs: Any,
+) -> None:
+    """
+    Visualize an image using matplotlib.
+
+    Args:
+        image (Union[np.ndarray, torch.Tensor]): The image to visualize.
+        transpose (bool, optional): Whether to transpose the image. Defaults to False.
+        bdx (Optional[int], optional): The band index to visualize. Defaults to None.
+        scale_factor (float, optional): The scale factor to apply to the image. Defaults to 1.0.
+        figsize (Tuple[int, int], optional): The size of the figure. Defaults to (10, 5).
+        axis_off (bool, optional): Whether to turn off the axis. Defaults to True.
+        **kwargs (Any): Additional keyword arguments for plt.imshow().
+
+    Returns:
+        None
+    """
+
+    if isinstance(image, torch.Tensor):
+        image = image.cpu().numpy()
+
+    plt.figure(figsize=figsize)
+
+    if transpose:
+        image = image.transpose(1, 2, 0)
+
+    if bdx is not None:
+        image = image[:, :, bdx]
+
+    if len(image.shape) > 2 and image.shape[2] > 3:
+        image = image[:, :, 0:3]
+
+    if scale_factor != 1.0:
+        image = np.clip(image * scale_factor, 0, 1)
+
+    plt.imshow(image, **kwargs)
+    if axis_off:
+        plt.axis("off")
+    plt.show()
+    plt.close()
+
+
+def plot_images(
+    images: Iterable[torch.Tensor],
+    axs: Iterable[plt.Axes],
+    chnls: List[int] = [2, 1, 0],
+    bright: float = 1.0,
+) -> None:
+    """
+    Plot a list of images.
+
+    Args:
+        images (Iterable[torch.Tensor]): The images to plot.
+        axs (Iterable[plt.Axes]): The axes to plot the images on.
+        chnls (List[int], optional): The channels to use for RGB. Defaults to [2, 1, 0].
+        bright (float, optional): The brightness factor. Defaults to 1.0.
+
+    Returns:
+        None
+    """
+    for img, ax in zip(images, axs):
+        arr = torch.clamp(bright * img, min=0, max=1).numpy()
+        rgb = arr.transpose(1, 2, 0)[:, :, chnls]
+        ax.imshow(rgb)
+        ax.axis("off")
+
+
+def plot_masks(
+    masks: Iterable[torch.Tensor], axs: Iterable[plt.Axes], cmap: str = "Blues"
+) -> None:
+    """
+    Plot a list of masks.
+
+    Args:
+        masks (Iterable[torch.Tensor]): The masks to plot.
+        axs (Iterable[plt.Axes]): The axes to plot the masks on.
+        cmap (str, optional): The colormap to use. Defaults to "Blues".
+
+    Returns:
+        None
+    """
+    for mask, ax in zip(masks, axs):
+        ax.imshow(mask.squeeze().numpy(), cmap=cmap)
+        ax.axis("off")
+
+
+def plot_batch(
+    batch: Dict[str, Any],
+    bright: float = 1.0,
+    cols: int = 4,
+    width: int = 5,
+    chnls: List[int] = [2, 1, 0],
+    cmap: str = "Blues",
+) -> None:
+    """
+    Plot a batch of images and masks. This function is adapted from the plot_batch()
+    function in the torchgeo library at
+    https://torchgeo.readthedocs.io/en/stable/tutorials/earth_surface_water.html
+    Credit to the torchgeo developers for the original implementation.
+
+    Args:
+        batch (Dict[str, Any]): The batch containing images and masks.
+        bright (float, optional): The brightness factor. Defaults to 1.0.
+        cols (int, optional): The number of columns in the plot grid. Defaults to 4.
+        width (int, optional): The width of each plot. Defaults to 5.
+        chnls (List[int], optional): The channels to use for RGB. Defaults to [2, 1, 0].
+        cmap (str, optional): The colormap to use for masks. Defaults to "Blues".
+
+    Returns:
+        None
+    """
+    # Get the samples and the number of items in the batch
+    samples = unbind_samples(batch.copy())
+
+    # if batch contains images and masks, the number of images will be doubled
+    n = 2 * len(samples) if ("image" in batch) and ("mask" in batch) else len(samples)
+
+    # calculate the number of rows in the grid
+    rows = n // cols + (1 if n % cols != 0 else 0)
+
+    # create a grid
+    _, axs = plt.subplots(rows, cols, figsize=(cols * width, rows * width))
+
+    if ("image" in batch) and ("mask" in batch):
+        # plot the images on the even axis
+        plot_images(
+            images=map(lambda x: x["image"], samples),
+            axs=axs.reshape(-1)[::2],
+            chnls=chnls,
+            bright=bright,
+        )
+
+        # plot the masks on the odd axis
+        plot_masks(masks=map(lambda x: x["mask"], samples), axs=axs.reshape(-1)[1::2])
+
+    else:
+        if "image" in batch:
+            plot_images(
+                images=map(lambda x: x["image"], samples),
+                axs=axs.reshape(-1),
+                chnls=chnls,
+                bright=bright,
+            )
+
+        elif "mask" in batch:
+            plot_masks(
+                masks=map(lambda x: x["mask"], samples), axs=axs.reshape(-1), cmap=cmap
+            )
+
+
+def calc_stats(
+    dataset: RasterDataset, divide_by: float = 1.0
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Calculate the statistics (mean and std) for the entire dataset.
+
+    This function is adapted from the plot_batch() function in the torchgeo library at
+    https://torchgeo.readthedocs.io/en/stable/tutorials/earth_surface_water.html.
+    Credit to the torchgeo developers for the original implementation.
+
+    Warning: This is an approximation. The correct value should take into account the
+    mean for the whole dataset for computing individual stds.
+
+    Args:
+        dataset (RasterDataset): The dataset to calculate statistics for.
+        divide_by (float, optional): The value to divide the image data by. Defaults to 1.0.
+
+    Returns:
+        Tuple[np.ndarray, np.ndarray]: The mean and standard deviation for each band.
+    """
+    import rasterio as rio
+
+    # To avoid loading the entire dataset in memory, we will loop through each img
+    # The filenames will be retrieved from the dataset's rtree index
+    files = [
+        item.object
+        for item in dataset.index.intersection(dataset.index.bounds, objects=True)
+    ]
+
+    # Resetting statistics
+    accum_mean = 0
+    accum_std = 0
+
+    for file in files:
+        img = rio.open(file).read() / divide_by  # type: ignore
+        accum_mean += img.reshape((img.shape[0], -1)).mean(axis=1)
+        accum_std += img.reshape((img.shape[0], -1)).std(axis=1)
+
+    # at the end, we shall have 2 vectors with length n=chnls
+    # we will average them considering the number of images
+    return accum_mean / len(files), accum_std / len(files)

geoai/download.py

@@ -0,0 +1,386 @@
+"""This module provides functions to download data, including NAIP imagery and building data from Overture Maps."""
+
+import os
+from typing import List, Tuple, Optional, Dict, Any
+import rioxarray
+import numpy as np
+import matplotlib.pyplot as plt
+from pystac_client import Client
+import planetary_computer as pc
+import geopandas as gpd
+from shapely.geometry import box
+from tqdm import tqdm
+import requests
+import subprocess
+import logging
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+
+def download_naip(
+    bbox: Tuple[float, float, float, float],
+    output_dir: str,
+    year: Optional[int] = None,
+    max_items: int = 10,
+    preview: bool = False,
+    **kwargs: Any,
+) -> List[str]:
+    """Download NAIP imagery from Planetary Computer based on a bounding box.
+
+    This function searches for NAIP (National Agriculture Imagery Program) imagery
+    from Microsoft's Planetary Computer that intersects with the specified bounding box.
+    It downloads the imagery and saves it as GeoTIFF files.
+
+    Args:
+        bbox: Bounding box in the format (min_lon, min_lat, max_lon, max_lat) in WGS84 coordinates.
+        output_dir: Directory to save the downloaded imagery.
+        year: Specific year of NAIP imagery to download (e.g., 2020). If None, returns imagery from all available years.
+        max_items: Maximum number of items to download.
+        preview: If True, display a preview of the downloaded imagery.
+
+    Returns:
+        List of downloaded file paths.
+
+    Raises:
+        Exception: If there is an error downloading or saving the imagery.
+    """
+    # Create output directory if it doesn't exist
+    os.makedirs(output_dir, exist_ok=True)
+
+    # Create a geometry from the bounding box
+    geometry = box(*bbox)
+
+    # Connect to Planetary Computer STAC API
+    catalog = Client.open("https://planetarycomputer.microsoft.com/api/stac/v1")
+
+    # Build query for NAIP data
+    search_params = {
+        "collections": ["naip"],
+        "intersects": geometry,
+        "limit": max_items,
+    }
+
+    # Add year filter if specified
+    if year:
+        search_params["query"] = {"naip:year": {"eq": year}}
+
+    for key, value in kwargs.items():
+        search_params[key] = value
+
+    # Search for NAIP imagery
+    search_results = catalog.search(**search_params)
+    items = list(search_results.items())
+
+    if not items:
+        print("No NAIP imagery found for the specified region and parameters.")
+        return []
+
+    print(f"Found {len(items)} NAIP items.")
+
+    # Download and save each item
+    downloaded_files = []
+    for i, item in enumerate(items):
+        # Sign the assets (required for Planetary Computer)
+        signed_item = pc.sign(item)
+
+        # Get the RGB asset URL
+        rgb_asset = signed_item.assets.get("image")
+        if not rgb_asset:
+            print(f"No RGB asset found for item {i+1}")
+            continue
+
+        # Use the original filename from the asset
+        original_filename = os.path.basename(
+            rgb_asset.href.split("?")[0]
+        )  # Remove query parameters
+        output_path = os.path.join(output_dir, original_filename)
+
+        print(f"Downloading item {i+1}/{len(items)}: {original_filename}")
+
+        try:
+            # Open and save the data with progress bar
+            # For direct file download with progress bar
+            if rgb_asset.href.startswith("http"):
+                download_with_progress(rgb_asset.href, output_path)
+                #
+            else:
+                # Fallback to direct rioxarray opening (less common case)
+                data = rioxarray.open_rasterio(rgb_asset.href)
+                data.rio.to_raster(output_path)
+
+            downloaded_files.append(output_path)
+            print(f"Successfully saved to {output_path}")
+
+            # Optional: Display a preview (uncomment if needed)
+            if preview:
+                data = rioxarray.open_rasterio(output_path)
+                preview_raster(data)
+
+        except Exception as e:
+            print(f"Error downloading item {i+1}: {str(e)}")
+
+    return downloaded_files
+
+
+def download_with_progress(url: str, output_path: str) -> None:
+    """Download a file with a progress bar.
+
+    Args:
+        url: URL of the file to download.
+        output_path: Path where the file will be saved.
+    """
+    response = requests.get(url, stream=True)
+    total_size = int(response.headers.get("content-length", 0))
+    block_size = 1024  # 1 Kibibyte
+
+    with (
+        open(output_path, "wb") as file,
+        tqdm(
+            desc=os.path.basename(output_path),
+            total=total_size,
+            unit="iB",
+            unit_scale=True,
+            unit_divisor=1024,
+        ) as bar,
+    ):
+        for data in response.iter_content(block_size):
+            size = file.write(data)
+            bar.update(size)
+
+
+def preview_raster(data: Any, title: str = None) -> None:
+    """Display a preview of the downloaded imagery.
+
+    This function creates a visualization of the downloaded NAIP imagery
+    by converting it to an RGB array and displaying it with matplotlib.
+
+    Args:
+        data: The raster data as a rioxarray object.
+        title: The title for the preview plot.
+    """
+    # Convert to 8-bit RGB for display
+    rgb_data = data.transpose("y", "x", "band").values[:, :, 0:3]
+    rgb_data = np.where(rgb_data > 255, 255, rgb_data).astype(np.uint8)
+
+    plt.figure(figsize=(10, 10))
+    plt.imshow(rgb_data)
+    if title is not None:
+        plt.title(title)
+    plt.axis("off")
+    plt.show()
+
+
+# Helper function to convert NumPy types to native Python types for JSON serialization
+def json_serializable(obj: Any) -> Any:
+    """Convert NumPy types to native Python types for JSON serialization.
+
+    Args:
+        obj: Any object to convert.
+
+    Returns:
+        JSON serializable version of the object.
+    """
+    if isinstance(obj, np.integer):
+        return int(obj)
+    elif isinstance(obj, np.floating):
+        return float(obj)
+    elif isinstance(obj, np.ndarray):
+        return obj.tolist()
+    else:
+        return obj
+
+
+def download_overture_buildings(
+    bbox: Tuple[float, float, float, float],
+    output_file: str,
+    output_format: str = "geojson",
+    data_type: str = "building",
+    verbose: bool = True,
+) -> str:
+    """Download building data from Overture Maps for a given bounding box using the overturemaps CLI tool.
+
+    Args:
+        bbox: Bounding box in the format (min_lon, min_lat, max_lon, max_lat) in WGS84 coordinates.
+        output_file: Path to save the output file.
+        output_format: Format to save the output, one of "geojson", "geojsonseq", or "geoparquet".
+        data_type: The Overture Maps data type to download (building, place, etc.).
+        verbose: Whether to print verbose output.
+
+    Returns:
+        Path to the output file.
+    """
+    # Create output directory if needed
+    output_dir = os.path.dirname(output_file)
+    if output_dir and not os.path.exists(output_dir):
+        os.makedirs(output_dir, exist_ok=True)
+
+    # Format the bounding box string for the command
+    west, south, east, north = bbox
+    bbox_str = f"{west},{south},{east},{north}"
+
+    # Build the command
+    cmd = [
+        "overturemaps",
+        "download",
+        "--bbox",
+        bbox_str,
+        "-f",
+        output_format,
+        "--type",
+        data_type,
+        "--output",
+        output_file,
+    ]
+
+    if verbose:
+        logger.info(f"Running command: {' '.join(cmd)}")
+        logger.info("Downloading %s data for area: %s", data_type, bbox_str)
+
+    try:
+        # Run the command
+        result = subprocess.run(
+            cmd,
+            check=True,
+            stdout=subprocess.PIPE if not verbose else None,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+
+        # Check if the file was created
+        if os.path.exists(output_file):
+            file_size = os.path.getsize(output_file) / (1024 * 1024)  # Size in MB
+            logger.info(
+                f"Successfully downloaded data to {output_file} ({file_size:.2f} MB)"
+            )
+
+            # Optionally show some stats about the downloaded data
+            if output_format == "geojson" and os.path.getsize(output_file) > 0:
+                try:
+                    gdf = gpd.read_file(output_file)
+                    logger.info(f"Downloaded {len(gdf)} features")
+
+                    if len(gdf) > 0 and verbose:
+                        # Show a sample of the attribute names
+                        attrs = list(gdf.columns)
+                        attrs.remove("geometry")
+                        logger.info(f"Available attributes: {', '.join(attrs[:10])}...")
+                except Exception as e:
+                    logger.warning(f"Could not read the GeoJSON file: {str(e)}")
+
+            return output_file
+        else:
+            logger.error(f"Command completed but file {output_file} was not created")
+            if result.stderr:
+                logger.error(f"Command error output: {result.stderr}")
+            return None
+
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Error running overturemaps command: {str(e)}")
+        if e.stderr:
+            logger.error(f"Command error output: {e.stderr}")
+        raise RuntimeError(f"Failed to download Overture Maps data: {str(e)}")
+    except Exception as e:
+        logger.error(f"Unexpected error: {str(e)}")
+        raise
+
+
+def convert_vector_format(
+    input_file: str,
+    output_format: str = "geojson",
+    filter_expression: Optional[str] = None,
+) -> str:
+    """Convert the downloaded data to a different format or filter it.
+
+    Args:
+        input_file: Path to the input file.
+        output_format: Format to convert to, one of "geojson", "parquet", "shapefile", "csv".
+        filter_expression: Optional GeoDataFrame query expression to filter the data.
+
+    Returns:
+        Path to the converted file.
+    """
+    try:
+        # Read the input file
+        logger.info(f"Reading {input_file}")
+        gdf = gpd.read_file(input_file)
+
+        # Apply filter if specified
+        if filter_expression:
+            logger.info(f"Filtering data using expression: {filter_expression}")
+            gdf = gdf.query(filter_expression)
+            logger.info(f"After filtering: {len(gdf)} features")
+
+        # Define output file path
+        base_path = os.path.splitext(input_file)[0]
+
+        if output_format == "geojson":
+            output_file = f"{base_path}.geojson"
+            logger.info(f"Converting to GeoJSON: {output_file}")
+            gdf.to_file(output_file, driver="GeoJSON")
+        elif output_format == "parquet":
+            output_file = f"{base_path}.parquet"
+            logger.info(f"Converting to Parquet: {output_file}")
+            gdf.to_parquet(output_file)
+        elif output_format == "shapefile":
+            output_file = f"{base_path}.shp"
+            logger.info(f"Converting to Shapefile: {output_file}")
+            gdf.to_file(output_file)
+        elif output_format == "csv":
+            output_file = f"{base_path}.csv"
+            logger.info(f"Converting to CSV: {output_file}")
+
+            # For CSV, we need to convert geometry to WKT
+            gdf["geometry_wkt"] = gdf.geometry.apply(lambda g: g.wkt)
+
+            # Save to CSV with geometry as WKT
+            gdf.drop(columns=["geometry"]).to_csv(output_file, index=False)
+        else:
+            raise ValueError(f"Unsupported output format: {output_format}")
+
+        return output_file
+
+    except Exception as e:
+        logger.error(f"Error converting data: {str(e)}")
+        raise
+
+
+def extract_building_stats(geojson_file: str) -> Dict[str, Any]:
+    """Extract statistics from the building data.
+
+    Args:
+        geojson_file: Path to the GeoJSON file.
+
+    Returns:
+        Dictionary with statistics.
+    """
+    try:
+        # Read the GeoJSON file
+        gdf = gpd.read_file(geojson_file)
+
+        # Calculate statistics
+        bbox = gdf.total_bounds.tolist()
+        # Convert numpy values to Python native types
+        bbox = [float(x) for x in bbox]
+
+        stats = {
+            "total_buildings": int(len(gdf)),
+            "has_height": (
+                int(gdf["height"].notna().sum()) if "height" in gdf.columns else 0
+            ),
+            "has_name": (
+                int(gdf["names.common.value"].notna().sum())
+                if "names.common.value" in gdf.columns
+                else 0
+            ),
+            "bbox": bbox,
+        }
+
+        return stats
+
+    except Exception as e:
+        logger.error(f"Error extracting statistics: {str(e)}")
+        return {"error": str(e)}

geoai/geoai.py

@@ -1 +1,3 @@
 """Main module."""
+
+from .common import viz_raster, viz_image, plot_batch, calc_stats

{geoai_py-0.1.5.dist-info → geoai_py-0.1.7.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.2
 Name: geoai-py
-Version: 0.1.5
+Version: 0.1.7
 Summary: A Python package for using Artificial Intelligence (AI) with geospatial data
 Author-email: Qiusheng Wu <giswqs@gmail.com>
 License: MIT License
-Project-URL: Homepage, https://github.com/giswqs/geoai
+Project-URL: Homepage, https://github.com/opengeos/geoai
 Keywords: geoai
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -18,14 +18,21 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: albumentations
+Requires-Dist: jupyter-server-proxy
+Requires-Dist: leafmap
+Requires-Dist: localtileserver
 Requires-Dist: scikit-learn
 Requires-Dist: segment-geospatial
 Requires-Dist: torch
+Requires-Dist: torchgeo
 Requires-Dist: transformers
+Provides-Extra: download
+Requires-Dist: pystac_client; extra == "download"
+Requires-Dist: planetary_computer; extra == "download"
+Requires-Dist: tqdm; extra == "download"
+Requires-Dist: overturemaps; extra == "download"
 Provides-Extra: all
-Requires-Dist: geoai[extra]; extra == "all"
-Provides-Extra: extra
-Requires-Dist: pandas; extra == "extra"
+Requires-Dist: geoai[download]; extra == "all"
 
 # geoai
 

geoai_py-0.1.7.dist-info/RECORD

@@ -0,0 +1,11 @@
+geoai/__init__.py,sha256=pHMpntXI_R7c_vTJ6VbyS8iAx1uVyDP5HwYauOonZ3s,143
+geoai/common.py,sha256=6h6mtUBO428P3IZppWyCVo04Ohzc3VhmnH0tvVh479g,9675
+geoai/download.py,sha256=wzmLvrbrX9tTAkLYZInFnW-Yextr3Appcg0DPhQWHYU,12738
+geoai/geoai.py,sha256=TmR7x1uL51G5oAjw0AQWnC5VQtLWDygyFLrDIj46xNc,86
+geoai/segmentation.py,sha256=Vcymnhwl_xikt4v9x8CYJq_vId9R1gB7-YzLfwg-F9M,11372
+geoai_py-0.1.7.dist-info/LICENSE,sha256=vN2L5U7cZ6ZkOHFmc8WiGlsogWsZc5dllMeNxnKVOZg,1070
+geoai_py-0.1.7.dist-info/METADATA,sha256=I3hYR-8dPERNmz_FsLLUeVVFXsPzAHK09HNZMRxss0A,1886
+geoai_py-0.1.7.dist-info/WHEEL,sha256=rF4EZyR2XVS6irmOHQIJx2SUqXLZKRMUrjsg8UwN-XQ,109
+geoai_py-0.1.7.dist-info/entry_points.txt,sha256=uGp3Az3HURIsRHP9v-ys0hIbUuBBNUfXv6VbYHIXeg4,41
+geoai_py-0.1.7.dist-info/top_level.txt,sha256=1YkCUWu-ii-0qIex7kbwAvfei-gos9ycyDyUCJPNWHY,6
+geoai_py-0.1.7.dist-info/RECORD,,

{geoai_py-0.1.5.dist-info → geoai_py-0.1.7.dist-info}/WHEEL

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

geoai_py-0.1.5.dist-info/RECORD

@@ -1,10 +0,0 @@
-geoai/__init__.py,sha256=xkyHrnU3iebQB2V0bl1Xd9s8YKI5-UTS-tMbjgnJXNY,120
-geoai/common.py,sha256=Rw6d9qmZDu3dUGTyJto1Y97S7-QA-m2p-pbCNvMDrm4,184
-geoai/geoai.py,sha256=h0hwdogXGFqerm-5ZPeT-irPn91pCcQRjiHThXsRzEk,19
-geoai/segmentation.py,sha256=Vcymnhwl_xikt4v9x8CYJq_vId9R1gB7-YzLfwg-F9M,11372
-geoai_py-0.1.5.dist-info/LICENSE,sha256=vN2L5U7cZ6ZkOHFmc8WiGlsogWsZc5dllMeNxnKVOZg,1070
-geoai_py-0.1.5.dist-info/METADATA,sha256=oQrREZxyg5_OgaVK4Pkn9txkaqUYcUtvigo13MfFNo0,1609
-geoai_py-0.1.5.dist-info/WHEEL,sha256=9Hm2OB-j1QcCUq9Jguht7ayGIIZBRTdOXD1qg9cCgPM,109
-geoai_py-0.1.5.dist-info/entry_points.txt,sha256=uGp3Az3HURIsRHP9v-ys0hIbUuBBNUfXv6VbYHIXeg4,41
-geoai_py-0.1.5.dist-info/top_level.txt,sha256=1YkCUWu-ii-0qIex7kbwAvfei-gos9ycyDyUCJPNWHY,6
-geoai_py-0.1.5.dist-info/RECORD,,