libadalina-core 1.0__py3-none-any.whl

libadalina_core/examples/example_hospitals_in_provinces.py

@@ -0,0 +1,46 @@
+from libadalina_core.readers.readers import geopackage_to_dataframe
+import pathlib
+import pandas as pd
+
+from libadalina_core.spatial_join.query_builder import spatial_join, JoinType, spatial_aggregation, AggregationType, \
+    AggregationFunction
+
+if __name__ == "__main__":
+    """Example of how to use libadalina to find hospitals in specific provinces in Italy and aggregate their data."""
+
+    # Set pandas display options
+    pd.set_option('display.max_columns', None)
+    pd.set_option('display.width', None)
+    pd.set_option('display.max_colwidth', 100)
+
+    hospitals = geopackage_to_dataframe(
+        str(pathlib.Path(__file__).parent.parent.parent / "tests" / "samples" / "healthcare" / "EU_healthcare.gpkg"),
+        "EU"
+    )[["hospital_name", "geometry", "city", "cap_beds"]]
+
+    regions = geopackage_to_dataframe(
+        str(pathlib.Path(__file__).parent.parent.parent / "tests" / "samples" / "regions" / "NUTS_RG_20M_2024_4326.gpkg"),
+        "NUTS_RG_20M_2024_4326.gpkg"
+    )[["LEVL_CODE", "NUTS_NAME", "CNTR_CODE", "geometry"]]
+
+    # select province of Milan and Cremona
+    filtered_regions = regions[
+        (regions['LEVL_CODE'] == 3) &
+        (regions['CNTR_CODE'] == "IT") &
+        (regions['NUTS_NAME'].str.contains('Milano|Cremona', case=False))
+    ]
+
+    # join with hospitals table to get hospitals in these provinces
+    result = (spatial_join(filtered_regions, hospitals, join_type=JoinType.LEFT)
+              # join operator renames the geometries adding suffixes _left and _right to avoid conflicts
+              .withColumnRenamed('geometry_left', 'geometry'))
+    result.show(truncate=False)
+
+    # get the number of hospitals in each province along with the total and average number of beds
+    result = spatial_aggregation(result, aggregate_functions=[
+        AggregationFunction("hospital_name", AggregationType.COUNT, 'hospitals'),
+        AggregationFunction("cap_beds", AggregationType.SUM, 'total_beds'),
+        AggregationFunction("cap_beds", AggregationType.AVG, 'average_beds'),
+    ])
+    result.show(truncate=False)
+

libadalina_core/examples/example_population_in_provinces.py

@@ -0,0 +1,42 @@
+from libadalina_core.readers.readers import geopackage_to_dataframe
+import pathlib
+import pandas as pd
+
+from libadalina_core.spatial_join.query_builder import spatial_join, JoinType, spatial_aggregation, AggregationType, \
+    AggregationFunction
+
+if __name__ == "__main__":
+    """Example of how to use libadalina to find the total amount of the population living in specific provinces in Italy."""
+
+    # Set pandas display options
+    pd.set_option('display.max_columns', None)
+    pd.set_option('display.width', None)
+    pd.set_option('display.max_colwidth', 100)
+
+    population = geopackage_to_dataframe(
+        str(pathlib.Path(__file__).parent.parent.parent / "tests" / "samples" / "population-north-italy" / "nord-italia.gpkg"),
+        "census2021"
+    )[['T', 'geometry']]
+
+    regions = geopackage_to_dataframe(
+        str(pathlib.Path(__file__).parent.parent.parent / "tests" / "samples" / "regions" / "NUTS_RG_20M_2024_4326.gpkg"),
+        "NUTS_RG_20M_2024_4326.gpkg"
+    )[["LEVL_CODE", "NUTS_NAME", "CNTR_CODE", "geometry"]]
+
+    # select province of Milan and Cremona
+    filtered_regions = regions[
+        (regions['LEVL_CODE'] == 3) &
+        (regions['CNTR_CODE'] == "IT") &
+        (regions['NUTS_NAME'].str.contains('Milano|Cremona', case=False))
+    ]
+
+    # join with population table to get the population of these provinces
+    result = spatial_aggregation(
+        spatial_join(filtered_regions, population, join_type=JoinType.LEFT)
+              # join operator renames the geometries adding suffixes _left and _right to avoid conflicts
+              .withColumnRenamed('geometry_left', 'geometry'),
+        aggregate_functions=[
+            AggregationFunction("T", AggregationType.SUM, 'population', proportional='geometry_right'),
+    ])
+    result.show(truncate=False)
+

libadalina_core/examples/example_population_served_by_hospitals.py

@@ -0,0 +1,59 @@
+from libadalina_core.readers.readers import geopackage_to_dataframe
+import pathlib
+import pandas as pd
+
+from libadalina_core.spatial_join.query_builder import spatial_join, JoinType, spatial_aggregation, AggregationType, \
+    AggregationFunction, polygonize
+
+if __name__ == "__main__":
+    """Example of how to use libadalina to find the amount of population living within 1km from each hospital of a specific province in Italy."""
+
+    # Set pandas display options
+    pd.set_option('display.max_columns', None)
+    pd.set_option('display.width', None)
+    pd.set_option('display.max_colwidth', 100)
+
+    population = geopackage_to_dataframe(
+        str(pathlib.Path(
+            __file__).parent.parent.parent / "tests" / "samples" / "population-north-italy" / "nord-italia.gpkg"),
+        "census2021"
+    )[['T', 'geometry']]
+
+    hospitals = geopackage_to_dataframe(
+        str(pathlib.Path(__file__).parent.parent.parent / "tests" / "samples" / "healthcare" / "EU_healthcare.gpkg"),
+        "EU"
+    )[["hospital_name", "geometry", "city", "cap_beds"]]
+
+    regions = geopackage_to_dataframe(
+        str(pathlib.Path(__file__).parent.parent.parent / "tests" / "samples" / "regions" / "NUTS_RG_20M_2024_4326.gpkg"),
+        "NUTS_RG_20M_2024_4326.gpkg"
+    )[["LEVL_CODE", "NUTS_NAME", "CNTR_CODE", "geometry"]]
+
+    # select province of Cremona
+    filtered_regions = regions[
+        (regions['LEVL_CODE'] == 3) &
+        (regions['CNTR_CODE'] == "IT") &
+        (regions['NUTS_NAME'].str.contains('Cremona', case=False))
+    ]
+
+    # join with hospitals table to get hospitals in these provinces
+    result = (spatial_join(filtered_regions, hospitals, join_type=JoinType.LEFT)
+              # join operator renames the geometries adding suffixes _left and _right to avoid conflicts
+              .withColumnRenamed('geometry_left', 'geometry_provinces')
+              .withColumnRenamed('geometry_right', 'geometry'))
+    result.show(truncate=False)
+
+    # transform the points representing the hospitals on the map to circle-like shaped polygons with a radius of 1000 meters
+    result = (polygonize(result, 1000)
+              .withColumnRenamed('geometry', 'original_geometry')
+              .withColumnRenamed('polygonized_geometry', 'geometry'))
+
+
+    result = spatial_aggregation(spatial_join(result, population, join_type=JoinType.INNER)
+              # join operator renames the geometries adding suffixes _left and _right to avoid conflicts
+              .withColumnRenamed('geometry_left', 'geometry'),
+                                 aggregate_functions=[
+                                     AggregationFunction("T", AggregationType.SUM, 'population',
+                                                         proportional='geometry_right'),
+                                 ])
+    result.show(truncate=False)

libadalina_core/readers/readers.py

@@ -0,0 +1,18 @@
+import geopandas as gpd
+
+from libadalina_core.sedona_utils.coordinate_formats import DEFAULT_EPSG
+
+
+def geopackage_to_dataframe(path: str, layer: str) -> gpd.GeoDataFrame:
+    """
+    Read a GeoPackage file into a GeoDataFrame.
+
+    Geometry is automatically converted in libadalina default EPSG `DEFAULT_EPSG`.
+
+    :param path: The path to the GeoPackage file.
+    :param layer: The layer name of the GeoPackage.
+    :return: A GeoDataFrame containing the data from the specified layer.
+    """
+    gdf = gpd.read_file(path, layer=layer)
+    gdf.to_crs(epsg=DEFAULT_EPSG.value, inplace=True)
+    return gdf

libadalina_core/sedona_configuration/jdk_installer.py

@@ -0,0 +1,22 @@
+import logging
+import os
+import jdk
+
+def install_jdk_if_needed():
+    """
+    Install a compatible JDK if `JAVA_HOME` environment variable is not found.
+    """
+    if 'JAVA_HOME' not in os.environ:
+        version = '17'
+        jre_path = os.path.join(jdk._JRE_DIR, version)
+
+        if os.path.exists(jre_path):
+            logging.info(f'JAVA_HOME not set but JRE already downloaded')
+            os.environ['JAVA_HOME'] = jre_path
+        else:
+            logging.info('JAVA_HOME not set, installing JRE...')
+            java_home = jdk.install(version, jre=True)
+            os.environ['JAVA_HOME'] = java_home
+            os.symlink(java_home, jre_path)
+
+    logging.info(f'JAVA_HOME set to {os.environ.get("JAVA_HOME")}')

libadalina_core/sedona_configuration/sedona_configuration.py

@@ -0,0 +1,104 @@
+from pyspark.sql import SparkSession
+from sedona.spark import SedonaContext
+import pandas as pd
+from libadalina_core.sedona_configuration.jdk_installer import install_jdk_if_needed
+
+# compatibility with Pandas
+pd.DataFrame.iteritems = pd.DataFrame.items
+
+def _get_sedona_master_configuration(master_host: str) -> SparkSession:
+    spark = (SparkSession.builder
+            .appName("Adalina")
+            .master(master_host)
+            .config(
+                "spark.jars.packages",
+                "org.apache.sedona:sedona-spark-3.3_2.12:1.7.1,"
+                "org.datasyslab:geotools-wrapper:1.7.1-28.5",
+            )
+            .config(
+                "spark.jars.repositories",
+                "https://artifacts.unidata.ucar.edu/repository/unidata-all"
+            )
+            .config("spark.executor.instances", 1)
+            .config("spark.executor.cores", "1")
+            .config("spark.executor.memory", "2G")
+            .getOrCreate())
+    return SedonaContext.create(spark)
+
+def _sedona_configuration() -> SparkSession:
+    config = (
+        SedonaContext.builder()
+             .appName("Adalina")
+             .config(
+                "spark.jars.packages",
+                "org.apache.sedona:sedona-spark-3.3_2.12:1.7.1,"
+                "org.datasyslab:geotools-wrapper:1.7.1-28.5",
+            )
+            .config("spark.driver.memory", "20g")
+            .config(
+                "spark.jars.repositories",
+                "https://artifacts.unidata.ucar.edu/repository/unidata-all"
+            )
+            .getOrCreate()
+    )
+    return SedonaContext.create(config)
+
+_sedona_context: SparkSession | None = None
+
+def init_sedona_context(
+        spark_master: str | None = None,
+        spark: SparkSession | None = None
+):
+    """
+    Initialize the Sedona context for spatial data processing.
+
+    This function can either:
+
+    1. Create a new Sedona context with a specified Spark master,
+    2. Use an existing SparkSession, or
+    3. Create a default Sedona context with the default Spark configuration.
+
+    If no parameters are provided, it will create a default Sedona context (option 3).
+
+    If a `JAVA_HOME` environment variable is not set, it will attempt to install a compatible JDK.
+
+    :param spark_master: The Spark master URL to connect to. If provided, a new Sedona context will be created with this master.
+    :param spark: An existing SparkSession to use. If provided, it will be used to create the Sedona context.
+
+    Example:
+        # Initialize with default configuration
+        init_sedona_context()
+
+        # Initialize with specific Spark master
+        init_sedona_context(spark_master="spark://localhost:7077")
+
+        # Initialize with existing SparkSession
+        spark = SparkSession.builder.getOrCreate()
+        init_sedona_context(spark=spark)
+    """
+    global _sedona_context
+
+    install_jdk_if_needed()
+
+    if spark_master is not None:
+        _sedona_context = _get_sedona_master_configuration(spark_master)
+    elif isinstance(spark, SparkSession):
+        _sedona_context = SedonaContext.create(spark)
+    else:
+        _sedona_context = _sedona_configuration()
+
+def get_sedona_context() -> SparkSession:
+    """
+    Get the Sedona context for spatial data processing.
+    This context is the one used for all spatial operations in libadalina.
+
+    If the Sedona context has not been initialized yet with `init_sedona_context`,
+    the function `init_sedona_context` will be called to initialize it with the default configuration.
+
+    :return: The Sedona context as a SparkSession.
+    """
+    global _sedona_context
+
+    if _sedona_context is None:
+        init_sedona_context()
+    return _sedona_context

libadalina_core/sedona_utils/coordinate_formats.py

@@ -0,0 +1,22 @@
+from enum import Enum
+
+class EPSGFormats(Enum):
+    """
+    Enum representing common EPSG formats used in geospatial data.
+    """
+    EPSG4326 = 4326  # WGS84
+    EPSG32632 = 32632  # UTM zone 32N
+
+    @staticmethod
+    def from_code(code: int) -> 'EPSGFormats':
+        for f in EPSGFormats:
+            if f.value == code:
+                return f
+        raise ValueError(f"No EPSG format found for code {code}")
+
+"""
+Default EPSG format used in libadalina.
+
+All DataFrame are converted upon reading and writing to this format.
+"""
+DEFAULT_EPSG = EPSGFormats.EPSG4326

libadalina_core/sedona_utils/utils.py

@@ -0,0 +1,27 @@
+import pandas as pd
+import geopandas as gpd
+import pyspark.sql as ps
+
+from libadalina_core.sedona_configuration.sedona_configuration import get_sedona_context
+
+def to_spark_dataframe(df: pd.DataFrame | gpd.GeoDataFrame | ps.DataFrame) -> ps.DataFrame:
+    """
+    Covert a pandas DataFrame or a GeoPandas GeoDataFrame to a Spark DataFrame.
+    If the input is already a Spark DataFrame, it will be returned as is.
+
+    This function is useful for converting data to a format suitable for processing with Apache Sedona,
+    however, each function of libadalina already converts the input DataFrame to a Spark DataFrame before processing.
+
+    :param df: The DataFrame to convert, which can be a pandas DataFrame, a GeoPandas GeoDataFrame, or a Spark DataFrame.
+    :return: A Spark DataFrame.
+    """
+    if isinstance(df, ps.DataFrame):
+        return df
+    sedona = get_sedona_context()
+    if isinstance(df, gpd.GeoDataFrame):
+        return sedona.createDataFrame(df)
+    if isinstance(df, pd.DataFrame):
+        return sedona.createDataFrame(df)
+    if isinstance(df, ps.DataFrame):
+        return df # nothing to do here
+    raise TypeError(f"Unsupported type {type(df)}. Expected pandas, geopandas, or spark DataFrame.")

libadalina_core/spatial_join/query_builder.py

@@ -0,0 +1,147 @@
+import dataclasses
+from enum import Enum
+
+import pandas as pd
+import geopandas as gpd
+import pyspark.sql as ps
+import pyspark.sql.functions as func
+
+from libadalina_core.sedona_utils.utils import to_spark_dataframe
+from sedona.sql import ST_Intersects, ST_Area, ST_Intersection, ST_Union, ST_Buffer, ST_GeometryType, ST_Dump
+
+DataFrame = pd.DataFrame | gpd.GeoDataFrame | ps.DataFrame
+
+def polygonize(df: DataFrame, radius_meters: float) -> ps.DataFrame:
+    table = to_spark_dataframe(df)
+
+    return table.select("*", func
+                        .when(df.geometry.isNull(), None)
+                        .when(ST_GeometryType(df.geometry).like('%Point%'),
+                              ST_Buffer(func.col('geometry'), radius_meters, func.lit(True)))
+                        .when(ST_GeometryType(func.col('geometry')).like('%LineString%'),
+                              ST_Union(
+                                  ST_Buffer(func.col('geometry'), radius_meters, func.lit(True),
+                                            parameters=func.lit('endcap=flat side=left')),
+                                  ST_Buffer(func.col('geometry'), radius_meters, func.lit(True),
+                                            parameters=func.lit('endcap=flat side=right'))
+                              ))
+                        .otherwise(df.geometry)
+                        .alias('polygonized_geometry')
+                        )
+
+
+def explode_multi_geometry(df: DataFrame) -> ps.DataFrame:
+    table = to_spark_dataframe(df)
+
+    return table.select("*", func
+                        .when(df.geometry.isNull(), func.array())
+                        .when(ST_GeometryType(df.geometry).like('%Multi%'),
+                              func.explode(ST_Dump(df.geometry)))
+                        .otherwise(df.geometry)
+                        )
+
+class AggregationType(Enum):
+    COUNT = 'count'
+    SUM = 'sum'
+    AVG = 'avg'
+    MIN = 'min'
+    MAX = 'max'
+
+    def to_spark_func(self):
+        if self == AggregationType.COUNT:
+            return func.count
+        elif self == AggregationType.SUM:
+            return func.sum
+        elif self == AggregationType.AVG:
+            return func.avg
+        elif self == AggregationType.MIN:
+            return func.min
+        elif self == AggregationType.MAX:
+            return func.max
+        return func.count  # Default to count if none matched
+
+    def __str__(self):
+        return self.value
+
+    def __repr__(self):
+        return self.value
+
+@dataclasses.dataclass
+class AggregationFunction:
+    column: str
+    aggregation_type: AggregationType
+    alias: str | None = None
+    proportional: str | None = None
+
+def spatial_aggregation(table: DataFrame, aggregate_functions: list[AggregationFunction]) -> ps.DataFrame:
+    table = to_spark_dataframe(table)
+
+    columns_to_aggregate = [c.column for c in aggregate_functions]
+    projection_of_not_aggregated_columns = (
+        func.first(c).alias(c) for c in table.columns if c != 'geometry' and c not in columns_to_aggregate
+    )
+
+    columns_with_no_proportional_aggregation = [c for c in aggregate_functions if c.proportional is None]
+    columns_with_proportional_aggregation = [c for c in aggregate_functions if c.proportional is not None]
+
+    projection_of_aggregated_columns = (
+        agg_func.aggregation_type.to_spark_func()(func.col(agg_func.column)).alias(
+            f"{agg_func.aggregation_type.value}({agg_func.column})" if agg_func.alias is None else agg_func.alias
+        ) for agg_func in columns_with_no_proportional_aggregation if agg_func.column in table.columns
+    )
+
+    projection_of_proportional_aggregated_columns = (
+        agg_func.aggregation_type.to_spark_func()(func.col(agg_func.column) * ST_Area(ST_Intersection(func.col('geometry'), func.col(agg_func.proportional))) / ST_Area(func.col(agg_func.proportional))).alias(
+            f"{agg_func.aggregation_type.value}({agg_func.column})" if agg_func.alias is None else agg_func.alias
+        ) for agg_func in columns_with_proportional_aggregation if agg_func.column in table.columns
+    )
+
+    # Group by geometry and aggregate other columns
+    aggregated = (table
+                  .groupby(table.geometry)
+                    .agg(
+                        # from the columns for which is not specified an aggregation function, take the first value
+                        *projection_of_not_aggregated_columns,
+                        # apply the aggregation functions to the other columns
+                        *projection_of_aggregated_columns,
+                        *projection_of_proportional_aggregated_columns
+                    ))
+
+    return aggregated
+
+class JoinType(Enum):
+    INNER = 'inner'
+    LEFT = 'left'
+    RIGHT = 'right'
+    FULL = 'full'
+
+    def __str__(self):
+        return self.value
+
+    def __repr__(self):
+        return self.value
+
+def spatial_join(
+        left_table: DataFrame,
+        right_table: DataFrame,
+        join_type: JoinType = JoinType.INNER,
+        aggregate: bool = False,
+        aggregate_functions: list[AggregationFunction] | None = None
+    ) -> ps.DataFrame:
+
+    left_table = to_spark_dataframe(left_table)
+    right_table = to_spark_dataframe(right_table)
+
+    result = (left_table
+              .withColumnRenamed('geometry', 'geometry_left')
+              .join(right_table.withColumnRenamed('geometry', 'geometry_right'),
+                    on=ST_Intersects(func.col('geometry_left'), func.col('geometry_right')), how=join_type.value)
+              )
+
+    if aggregate:
+        if aggregate_functions is None:
+            raise ValueError("aggregate_functions must be provided when aggregate is True")
+        result = spatial_aggregation(result, aggregate_functions)
+
+    return result
+

libadalina_core/writers/writers.py

@@ -0,0 +1,22 @@
+import pandas as pd
+import geopandas as gpd
+import pyspark.sql as ps
+from libadalina_core.sedona_utils.coordinate_formats import DEFAULT_EPSG
+
+def dataframe_to_geopackage(df: pd.DataFrame | gpd.GeoDataFrame | ps.DataFrame, path: str):
+    """
+    Write a DataFrame to a GeoPackage file.
+    DataFrame geometry is assumed to be in libadalina default EPSG `DEFAULT_EPSG`
+
+    :param df: The DataFrame to write, which can be a pandas DataFrame, a GeoPandas GeoDataFrame, or a Spark DataFrame.
+    :param path: The path to the GeoPackage file where the DataFrame will be saved.
+    """
+    if isinstance(df, ps.DataFrame):
+        df = gpd.GeoDataFrame(df.toPandas(), geometry = 'geometry', crs = DEFAULT_EPSG.value)
+    elif isinstance(df,  pd.DataFrame):
+        df = gpd.GeoDataFrame(df, geometry='geometry', crs=DEFAULT_EPSG.value)
+    elif isinstance(df, gpd.GeoDataFrame):
+        pass # already a GeoDataFrame
+    else:
+        raise TypeError(f"Unsupported type {type(df)}. Expected pandas DataFrame, geopandas GeoDataFrame, or spark DataFrame.")
+    df.to_file(path, layer='dataframe', driver="GPKG")

libadalina_core-1.0.dist-info/METADATA

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: libadalina-core
+Version: 1.0
+Summary: A library for spatial joins of geographic data
+Author-email: Marco Casazza <d.marcocasazza@gmail.com>, Alberto Ceselli <alberto.ceselli@unimi.it>, Marco Premoli <marco.premoli@unimi.it>
+License-Expression: MIT
+Project-URL: Homepage, https://gitlab.com/amelia_unimi/libadalina
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: ~=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: apache-sedona[spark]==1.7.1
+Requires-Dist: pyspark==3.3.2
+Requires-Dist: pandas==2.2.3
+Requires-Dist: geopandas==1.0.1
+Requires-Dist: shapely==2.1.1
+Requires-Dist: install-jdk==1.1.0
+Provides-Extra: dev
+Requires-Dist: pytest==8.4.1; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: sphinx; extra == "dev"
+Requires-Dist: pydata-sphinx-theme; extra == "dev"
+Dynamic: license-file
+
+# libadalina-core
+
+A Python library for spatial data processing.
+It makes it easier to work with geospatial data in Python by providing a high-level interface
+to Apache Sedona, a powerful geospatial processing engine, and integrates nicely with other well-known libraries
+such as *geopandas* and *pandas*.
+
+## Installation
+
+liabadalina-core can be installed using pip:
+```
+pip install libadalina-core
+```
+
+If `JAVA_HOME` environment variable is not set a suitable JDK will be downloaded in `$HOME/.jre` and used automatically.
+Not all JRE are supported, so if you encounter issues, you can try the automatically installed version.
+
+## Usage
+
+You can find the documentation and example at [libadalina-core documentation](https://libadalinacore-6b2a95.gitlab.io/).
+
+## Features
+
+
+* Reading and writing geospatial data from various formats
+* Spatial joins between datasets
+* Spatial aggregations
+* Utilities for working with Apache Sedona
+* Configuration helpers for setting up Apache Sedona
+
+## Requirements
+
+- Python 3.10
+- Dependencies:
+  - apache-sedona[spark]
+  - pyspark
+  - pandas
+  - geopandas
+  - install-jdk

libadalina_core-1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+libadalina_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+libadalina_core/examples/example_hospitals_in_provinces.py,sha256=ytDOWOG6Tp0Tmu6jst-9QUmaEeYaxQfAxnm6DtSoVyM,2075
+libadalina_core/examples/example_population_in_provinces.py,sha256=ost2ymqSPZYgMgjnh7f2bvlla8n9b2FmLtjrVU63Vq8,1807
+libadalina_core/examples/example_population_served_by_hospitals.py,sha256=3M1F0GpQ2i6tR4ZjQ2dkm1vBq02OjvwAqZ3FQje7hP0,2833
+libadalina_core/readers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+libadalina_core/readers/readers.py,sha256=PbUThxwu_kBSJMlpjjixvIG46G8i8hPpJIb6HoFOQoU,608
+libadalina_core/sedona_configuration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+libadalina_core/sedona_configuration/jdk_installer.py,sha256=i59G9YiNJ9H0BGpbeGmlTiFT0vP_SfjlIFAJylknR3I,730
+libadalina_core/sedona_configuration/sedona_configuration.py,sha256=qhHqL74CBEXDdol3YP-lklsCkZvuvzPXHgezfyhSiiw,3697
+libadalina_core/sedona_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+libadalina_core/sedona_utils/coordinate_formats.py,sha256=Ye1npHwJT7fLST1zkwyE8867mwXK-77ZsqaSEIL8RQs,571
+libadalina_core/sedona_utils/utils.py,sha256=IYBc3XSpXDxmSdndLj08Nv1SkZEh8nGKg99xWEmgv7I,1227
+libadalina_core/spatial_join/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+libadalina_core/spatial_join/query_builder.py,sha256=G12nXQid0ZQbeLvytFNY78ynLmk5iKIp08kGSJ8Tk5o,5750
+libadalina_core/writers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+libadalina_core/writers/writers.py,sha256=kFD-oZbEiirmlNMeccZ5DaYvtXd3LeBafCpGKuXFlwQ,1105
+libadalina_core-1.0.dist-info/licenses/LICENSE,sha256=U4yJabEzK3cseBN2UTwArB1I1p0ExZhl2eLUcCz_pl8,1075
+libadalina_core-1.0.dist-info/METADATA,sha256=afDUocHENbBj2qHhunRdtocaJe-4Q2H_twIKTdoxaJU,2179
+libadalina_core-1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+libadalina_core-1.0.dist-info/entry_points.txt,sha256=tsKAZ3w781QnK-TreW6KdA0H0655k5dW2ayYMjsTxPk,56
+libadalina_core-1.0.dist-info/top_level.txt,sha256=DspVcM_AHdB9K-Za5D4H_LHHHOB918nTuOLCtOpo-xA,16
+libadalina_core-1.0.dist-info/RECORD,,

libadalina_core-1.0.dist-info/WHEEL

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

libadalina_core-1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+libadalina = libadalina.__main__:main

libadalina_core-1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 University of Milan
+
+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.

libadalina_core-1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+libadalina_core