vector2dggs 0.10.1__py3-none-any.whl → 0.11.0__py3-none-any.whl

vector2dggs/__init__.py

@@ -1 +1 @@
-__version__: str = "0.10.1"
+__version__: str = "0.11.0"

vector2dggs/common.py

@@ -18,7 +18,7 @@ from pathlib import Path, PurePath
 from urllib.parse import urlparse
 from tqdm import tqdm
 from tqdm.dask import TqdmCallback
-from multiprocessing.dummy import Pool
+from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor, as_completed
 from shapely.geometry import GeometryCollection
 
 import vector2dggs.constants as const
@@ -313,6 +313,47 @@ def polyfill(
 def polyfill_star(args) -> None:
     return polyfill(*args)
 
+def bisection_preparation(df: pd.DataFrame, dggs: str, parent_res: int, cut_crs: pyproj.CRS = None, cut_threshold: Union[None, float] = None) -> tuple[pd.DataFrame, pyproj.CRS, Union[None, float]]:
+    cut_threshold = float(cut_threshold) if cut_threshold != None else None
+    
+    if cut_threshold and cut_crs:
+        df = df.to_crs(cut_crs)
+    else:
+        cut_crs = df.crs
+
+    if cut_crs is None:
+        LOGGER.warning("Input has no defined CRS, and cut_crs is not specified")
+    elif cut_threshold != 0:
+        LOGGER.debug("Cutting with CRS: %s", df.crs)
+
+    if not cut_crs.is_projected and cut_threshold != 0:
+        LOGGER.warning(
+            f"CRS {cut_crs} is not a projected coordinate system. (units: {cut_crs.axis_info[0].unit_name}) Bisection will result in sections of varying area"
+        )
+    elif cut_threshold != 0:
+        LOGGER.debug(
+            f"Using CRS units for input polygon bisection: {cut_crs.axis_info[0].unit_name}"
+        )
+
+    if cut_threshold == None:
+        unit_name = cut_crs.axis_info[0].unit_name
+        cut_threshold_m2 = const.DEFAULT_AREA_THRESHOLD_M2(dggs, (int(parent_res)))
+        if unit_name == "metre":
+            cut_threshold = cut_threshold_m2
+        elif unit_name == "feet":
+            cut_threshold = cut_threshold_m2 * 3.28084
+        else:
+            cut_threshold = 100000000 if cut_crs.is_projected else 0.5
+            LOGGER.warning(
+                f'Unspecified cut_threshold for {"projected" if cut_crs.is_projected else "geographic"} CRS: {cut_crs}, with squared units: {unit_name}'
+            )
+        LOGGER.debug(f"Using default cut_threshold of {cut_threshold} ({unit_name}^2)")
+    
+    return df, cut_crs, cut_threshold
+
+def bisect_geometry(geometry, cut_threshold):
+    return GeometryCollection(katana.katana(geometry, cut_threshold))
+
 
 def index(
     dggs: str,
@@ -326,7 +367,7 @@ def index(
     keep_attributes: bool,
     chunksize: int,
     spatial_sorting: str,
-    cut_threshold: int,
+    cut_threshold: Union[None, float],
     processes: int,
     compression: str = "snappy",
     id_field: str = None,
@@ -356,9 +397,7 @@ def index(
         # Read file
         df = gpd.read_file(input_file, layer=layer)
 
-    if cut_crs:
-        df = df.to_crs(cut_crs)
-    LOGGER.debug("Cutting with CRS: %s", df.crs)
+    df, cut_crs, cut_threshold = bisection_preparation(df, dggs, parent_res, cut_crs, cut_threshold)
 
     if id_field:
         df = df.set_index(id_field)
@@ -370,13 +409,21 @@ def index(
         # Remove all attributes except the geometry
         df = df.loc[:, ["geometry"]]
 
-    LOGGER.debug("Cutting large geometries")
-    with tqdm(total=df.shape[0], desc="Splitting") as pbar:
-        for index, row in df.iterrows():
-            df.loc[index, "geometry"] = GeometryCollection(
-                katana.katana(row.geometry, cut_threshold)
-            )
-            pbar.update(1)
+    LOGGER.debug("Bisecting large geometries")
+
+    if cut_threshold is not None and cut_threshold > 0:
+        with ThreadPoolExecutor(max_workers=max(1, processes)) as executor:
+            futures = []
+            for index, row in df.iterrows():
+                future = executor.submit(bisect_geometry, row.geometry, cut_threshold)
+                futures.append((index, future))
+
+            with tqdm(total=len(futures), desc="Bisection") as pbar:
+                for index, future in futures:
+                    df.at[index, "geometry"] = future.result()
+                    pbar.update(1)
+    else:
+        LOGGER.debug("No bisection applied to input.")
 
     LOGGER.debug("Exploding geometry collections and multipolygons")
     df = (
@@ -427,28 +474,33 @@ def index(
             resolution,
         )
         with tempfile.TemporaryDirectory(suffix=".parquet") as tmpdir2:
-            with Pool(processes=processes) as pool:
-                args = [
-                    (
-                        dggs,
-                        dggsfunc,
-                        secondary_index_func,
-                        filepath,
-                        spatial_sort_col,
-                        resolution,
-                        parent_res,
-                        tmpdir2,
-                        compression,
-                    )
-                    for filepath in filepaths
-                ]
-                list(
-                    tqdm(
-                        pool.imap(polyfill_star, args),
-                        total=len(args),
-                        desc="DGGS indexing",
-                    )
+
+            args = [
+                (
+                    dggs,
+                    dggsfunc,
+                    secondary_index_func,
+                    filepath,
+                    spatial_sort_col,
+                    resolution,
+                    parent_res,
+                    tmpdir2,
+                    compression,
                 )
+                for filepath in filepaths
+            ]
+
+            with ProcessPoolExecutor(max_workers=processes) as executor:
+                futures = {executor.submit(polyfill_star, arg): arg for arg in args}
+
+                for future in tqdm(
+                    as_completed(futures), total=len(futures), desc="DGGS indexing"
+                ):
+                    try:
+                        future.result()
+                    except Exception as e:
+                        LOGGER.error(f"Task failed with {e}")
+                        raise (e)
 
             parent_partitioning(
                 dggs,

vector2dggs/constants.py

@@ -8,20 +8,6 @@ MIN_RHP, MAX_RHP = 0, 15
 MIN_S2, MAX_S2 = 0, 30
 MIN_GEOHASH, MAX_GEOHASH = 1, 12
 
-DEFAULTS = {
-    "id": None,
-    "k": False,
-    "ch": 50,
-    "s": "none",
-    "crs": None,
-    "c": 5000,
-    "t": (multiprocessing.cpu_count() - 1),
-    "cp": "snappy",
-    "lyr": None,
-    "g": "geom",
-    "tempdir": tempfile.tempdir,
-}
-
 SPATIAL_SORTING_METHODS = ["hilbert", "morton", "geohash", "none"]
 
 DEFAULT_DGGS_PARENT_RES = {
@@ -70,6 +56,86 @@ S2_CELLS_MAX_AREA_M2_BY_LEVEL = {
     30: 0.93 * 1e-4,
 }
 
+# https://h3geo.org/docs/core-library/restable/
+H3_CELLS_MAX_AREA_KM2_BY_LEVEL = {
+    0: 4977807.027442012,
+    1: 729486.875275344,
+    2: 104599.807218925,
+    3: 14950.773301379,
+    4: 2135.986983965,
+    5: 305.144308779,
+    6: 43.592111685,
+    7: 6.227445905,
+    8: 0.889635157,
+    9: 0.127090737,
+    10: 0.018155820,
+    11: 0.002593689,
+    12: 0.000370527,
+    13: 0.000052932,
+    14: 0.000007562,
+    15: 0.000001080,
+}
+
+RHP_CELLS_AREA_KM2_BY_LEVEL = {
+    0: 100151150.62856922,
+    1: 11127905.62539658,
+    2: 1236433.9583773974,
+    3: 137381.55093082195,
+    4: 15264.616770091328,
+    5: 1696.0685300101482,
+    6: 188.4520588900164,
+    7: 20.939117654446267,
+    8: 2.326568628271808,
+    9: 0.25850762536353417,
+    10: 0.02872306948483713,
+    11: 0.003191452164981904,
+    12: 0.0003546057961091004,
+    13: 3.940064401212227 * 1e-5,
+    14: 4.377849334680252 * 1e-6,
+    15: 4.864277038533613 * 1e-7,
+}
+
+# https://www.movable-type.co.uk/scripts/geohash.html
+GEOHASH_MAX_CELL_AREA_KM2_BY_LEVEL = {
+    1: 5000 * 5000,
+    2: 1250 * 625,
+    3: 156 * 156,
+    4: 39.1 * 19.5,
+    5: 4.89 * 4.89,
+    6: 1.22 * 0.61,
+    7: 153 * 153 / 1e6,
+    8: 38.2 * 19.1 / 1e6,
+    9: 4.77 * 4.77 / 1e6,
+    10: 1.19 * 0.596 / 1e6,
+    11: 149 * 149 / 1e9,
+    12: 37.2 * 18.6 / 1e9,
+}
+
+DGGS_CELL_AREA_M2_BY_RES = {
+    "s2": lambda res: S2_CELLS_MAX_AREA_M2_BY_LEVEL[res],
+    "h3": lambda res: H3_CELLS_MAX_AREA_KM2_BY_LEVEL[res] * 1e6,
+    "rhp": lambda res: RHP_CELLS_AREA_KM2_BY_LEVEL[res] * 1e6,
+    "geohash": lambda res: GEOHASH_MAX_CELL_AREA_KM2_BY_LEVEL[res] * 1e6,
+}
+
+DEFAULT_AREA_THRESHOLD_M2 = lambda dggs, parent_res: DGGS_CELL_AREA_M2_BY_RES[dggs](
+    parent_res
+)
+
+DEFAULTS = {
+    "id": None,
+    "k": False,
+    "ch": 50,
+    "s": "none",
+    "crs": None,
+    "c": None,
+    "t": (multiprocessing.cpu_count() - 1),
+    "cp": "snappy",
+    "lyr": None,
+    "g": "geom",
+    "tempdir": tempfile.tempdir,
+}
+
 
 warnings.filterwarnings(
     "ignore"

vector2dggs/geohash.py

@@ -217,10 +217,10 @@ def gh_compaction(
 @click.option(
     "-c",
     "--cut_threshold",
-    required=True,
+    required=False,
     default=const.DEFAULTS["c"],
-    type=int,
-    help="Cutting up large geometries into smaller geometries based on a target length. Units are assumed to match the input CRS units unless the `--cut_crs` is also given, in which case units match the units of the supplied CRS.",
+    type=float,
+    help="Cutting up large geometries into smaller geometries based on a target area. Units are assumed to match the input CRS units unless the `--cut_crs` is also given, in which case units match the units of the supplied CRS. If left unspecified, the threshold will be the maximum area of a cell at the parent resolution, in square metres or feet according to the CRS. A threshold of 0 will skip bissection entirely (effectively ignoring --cut_crs).",
     nargs=1,
 )
 @click.option(
@@ -333,5 +333,3 @@ def geohash(
         )
     except:
         raise
-    else:
-        sys.exit(0)

vector2dggs/h3.py

@@ -136,10 +136,10 @@ def h3compaction(
 @click.option(
     "-c",
     "--cut_threshold",
-    required=True,
+    required=False,
     default=const.DEFAULTS["c"],
-    type=int,
-    help="Cutting up large geometries into smaller geometries based on a target length. Units are assumed to match the input CRS units unless the `--cut_crs` is also given, in which case units match the units of the supplied CRS.",
+    type=float,
+    help="Cutting up large geometries into smaller geometries based on a target area. Units are assumed to match the input CRS units unless the `--cut_crs` is also given, in which case units match the units of the supplied CRS. If left unspecified, the threshold will be the maximum area of a cell at the parent resolution, in square metres or feet according to the CRS. A threshold of 0 will skip bissection entirely (effectively ignoring --cut_crs).",
     nargs=1,
 )
 @click.option(
@@ -253,5 +253,3 @@ def h3(
         )
     except:
         raise
-    else:
-        sys.exit(0)

vector2dggs/katana.py

@@ -30,14 +30,17 @@ def katana(
     geometry: Union[BaseGeometry, None],
     threshold: float,
     count: int = 0,
+    max_recursion_depth: int = 250,
     check_2D: bool = True,
 ) -> List[BaseGeometry]:
     """
     Recursively split a geometry into two parts across its shortest dimension.
     Invalid input `geometry` will silently be made valid (if possible).
     Any LinearRings will be converted to Polygons.
+    `threshold`: maximum acceptable area of the bounding box for any output geometry.
+    `count`: used to track recursion depth
     """
-    if geometry is None:
+    if (geometry is None) or (geometry.is_empty):
         return []
     if isinstance(geometry, LinearRing):
         geometry = Polygon(geometry)
@@ -52,9 +55,7 @@ def katana(
     bounds = geometry.bounds
     width = bounds[2] - bounds[0]
     height = bounds[3] - bounds[1]
-    if max(width, height) <= threshold or count == 250:
-        # either the polygon is smaller than the threshold, or the maximum
-        # number of recursions has been reached
+    if ((width * height) <= threshold) or (count >= max_recursion_depth):
         return [geometry]
     if height >= width:
         # split left to right
@@ -64,6 +65,8 @@ def katana(
         # split top to bottom
         a = box(bounds[0], bounds[1], bounds[0] + width / 2, bounds[3])
         b = box(bounds[0] + width / 2, bounds[1], bounds[2], bounds[3])
+    # Add additional vertices to help prevent indexing errors from use of EPSG:4386 later under the presence of long edges
+    a, b = map(lambda g: g.segmentize(min(width, height) / 4), [a, b])
     result = []
     for d in (
         a,

vector2dggs/rHP.py

@@ -153,17 +153,17 @@ def rhpcompaction(
 @click.option(
     "-c",
     "--cut_threshold",
-    required=True,
+    required=False,
     default=const.DEFAULTS["c"],
-    type=int,
-    help="Cutting up large geometries into smaller geometries based on a target length. Units are assumed to match the input CRS units unless the `--cut_crs` is also given, in which case units match the units of the supplied CRS.",
+    type=float,
+    help="Cutting up large geometries into smaller geometries based on a target area. Units are assumed to match the input CRS units unless the `--cut_crs` is also given, in which case units match the units of the supplied CRS. If left unspecified, the threshold will be the maximum area of a cell at the parent resolution, in square metres or feet according to the CRS. A threshold of 0 will skip bissection entirely (effectively ignoring --cut_crs).",
     nargs=1,
 )
 @click.option(
     "-t",
     "--threads",
     required=False,
-    default=const.DEFAULTS["t"],
+    default=1,
     type=int,
     help="Amount of threads used for operation",
     nargs=1,
@@ -270,5 +270,3 @@ def rhp(
         )
     except:
         raise
-    else:
-        sys.exit(0)

vector2dggs/s2.py

@@ -9,6 +9,7 @@ from s2geometry import pywraps2 as S2
 
 import pandas as pd
 import geopandas as gpd
+from shapely import force_2d
 from shapely.geometry import box, Polygon, LineString, Point
 from shapely.ops import transform
 from pyproj import CRS, Transformer
@@ -71,6 +72,7 @@ def s2_polyfill_polygons(df: gpd.GeoDataFrame, level: int) -> gpd.GeoDataFrame:
     def generate_s2_covering(
         geom: Polygon, level: int, centroid_inside: bool = True
     ) -> set[S2.S2CellId]:
+        geom = force_2d(geom)
         # Prepare loops: first the exterior loop, then the interior loops
         loops = []
         # Exterior ring
@@ -296,10 +298,10 @@ def s2_compaction(
 @click.option(
     "-c",
     "--cut_threshold",
-    required=True,
+    required=False,
     default=const.DEFAULTS["c"],
-    type=int,
-    help="Cutting up large geometries into smaller geometries based on a target length. Units are assumed to match the input CRS units unless the `--cut_crs` is also given, in which case units match the units of the supplied CRS.",
+    type=float,
+    help="Cutting up large geometries into smaller geometries based on a target area. Units are assumed to match the input CRS units unless the `--cut_crs` is also given, in which case units match the units of the supplied CRS. If left unspecified, the threshold will be the maximum area of a cell at the parent resolution, in square metres or feet according to the CRS. A threshold of 0 will skip bissection entirely (effectively ignoring --cut_crs).",
     nargs=1,
 )
 @click.option(
@@ -412,5 +414,3 @@ def s2(
         )
     except:
         raise
-    else:
-        sys.exit(0)

{vector2dggs-0.10.1.dist-info → vector2dggs-0.11.0.dist-info}/METADATA

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: vector2dggs
-Version: 0.10.1
+Version: 0.11.0
 Summary: CLI DGGS indexer for vector geospatial data
+Home-page: https://github.com/manaakiwhenua/vector2dggs
 License: LGPL-3.0-or-later
 Keywords: dggs,vector,h3,rHEALPix,cli
 Author: James Ardo
@@ -12,8 +13,6 @@ Requires-Python: >=3.11,<4.0
 Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: GIS
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
@@ -122,12 +121,17 @@ Options:
                                   used for cutting large geometries (see
                                   `--cut_threshold`). Defaults to the same CRS
                                   as the input. Should be a valid EPSG code.
-  -c, --cut_threshold INTEGER     Cutting up large geometries into smaller
-                                  geometries based on a target length. Units
-                                  are assumed to match the input CRS units
-                                  unless the `--cut_crs` is also given, in
-                                  which case units match the units of the
-                                  supplied CRS.  [default: 5000; required]
+  -c, --cut_threshold FLOAT       Cutting up large geometries into smaller
+                                  geometries based on a target area. Units are
+                                  assumed to match the input CRS units unless
+                                  the `--cut_crs` is also given, in which case
+                                  units match the units of the supplied CRS.
+                                  If left unspecified, the threshold will be
+                                  the maximum area of a cell at the parent
+                                  resolution, in square metres or feet
+                                  according to the CRS. A threshold of 0 will
+                                  skip bissection entirely (effectively
+                                  ignoring --cut_crs).
   -t, --threads INTEGER           Amount of threads used for operation
                                   [default: NUM_CPUS - 1]
   -cp, --compression TEXT         Compression method to use for the output
@@ -240,6 +244,17 @@ Alternatively, it is also possible to install using pip with `pip install -e .`,
 
 Please run `black .` before committing.
 
+#### Tests
+
+Tests are included. To run them, set up a poetry environment, then follow these instructons:
+
+```bash
+cd tests
+python ./test_vector2dggs.py
+```
+
+Test data are included at `tests/data/`.
+
 ## Example commands
 
 With a local GPKG:
@@ -262,14 +277,14 @@ vector2dggs h3 -v DEBUG -id ogc_fid -r 9 -p 5 -t 4 --overwrite -lyr topo50_lake
   title={{vector2dggs}},
   author={Ardo, James and Law, Richard},
   url={https://github.com/manaakiwhenua/vector2dggs},
-  version={0.10.1},
+  version={0.11.0},
   date={2023-04-20}
 }
 ```
 
 APA/Harvard
 
-> Ardo, J., & Law, R. (2023). vector2dggs (0.10.1) [Computer software]. https://github.com/manaakiwhenua/vector2dggs
+> Ardo, J., & Law, R. (2023). vector2dggs (0.11.0) [Computer software]. https://github.com/manaakiwhenua/vector2dggs
 
 [![manaakiwhenua-standards](https://github.com/manaakiwhenua/vector2dggs/workflows/manaakiwhenua-standards/badge.svg)](https://github.com/manaakiwhenua/manaakiwhenua-standards)
 

vector2dggs-0.11.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+vector2dggs/__init__.py,sha256=NhOfSRUl_Py_CNCpR3FsS3g_Mf4pHgA87tFPBLl3BQM,28
+vector2dggs/cli.py,sha256=d_4skD62k6pXUWgDdVHbDwpe4A4yo62ZFx8Cp_6GpBA,767
+vector2dggs/common.py,sha256=hHhO_BZVL8GLFpzwm9Jw5cSaIy1bNk_hs0snEcNNVjQ,16893
+vector2dggs/constants.py,sha256=UIQoS8IsfeFR1eoIkmByq9UgoJkkqI3pbUqSNCEfFmo,3476
+vector2dggs/geohash.py,sha256=Px4EcRJ1cFFVMHJB7zgZLZXKYXhLQObxvE_QqMYLEKw,10593
+vector2dggs/h3.py,sha256=UnCH0m0Z9zGc_kSg5igFEz565f7Nr3aVe5Vex01WKRw,7603
+vector2dggs/katana.py,sha256=xD8BJ5hRQZyioStIMRJ_Gt1D9x9RotqP-YrB3TKHCSM,3850
+vector2dggs/rHP.py,sha256=KILnXvAzSinied3mLw4IURLlcK78U7xcSnKQ5afPzn4,8286
+vector2dggs/s2.py,sha256=6i6ecnPykgGRG-ZiyUP7JjgQzPUUklMZwd-JYs4X8K8,13063
+vector2dggs-0.11.0.dist-info/COPYING,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+vector2dggs-0.11.0.dist-info/COPYING.LESSER,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+vector2dggs-0.11.0.dist-info/METADATA,sha256=hZhgdrp7LiRGfIPbWyC3nl1ri1RtOLN9BE85CgqyCQg,13170
+vector2dggs-0.11.0.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+vector2dggs-0.11.0.dist-info/entry_points.txt,sha256=5h8LB9L2oOE5u_N7FRGtu4JDwa553iPs4u0XhcLeLZU,52
+vector2dggs-0.11.0.dist-info/RECORD,,

{vector2dggs-0.10.1.dist-info → vector2dggs-0.11.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.3
+Generator: poetry-core 1.6.1
 Root-Is-Purelib: true
 Tag: py3-none-any

vector2dggs-0.10.1.dist-info/RECORD

@@ -1,15 +0,0 @@
-vector2dggs/__init__.py,sha256=zkryc4Uha10GTKJDVvFVRKEySO4-gejqb9sTlyYC-EE,28
-vector2dggs/cli.py,sha256=d_4skD62k6pXUWgDdVHbDwpe4A4yo62ZFx8Cp_6GpBA,767
-vector2dggs/common.py,sha256=rQL1_rFr1VTyILffOZgdwPzZS1JThn4TBPswfCkMjbM,14471
-vector2dggs/constants.py,sha256=KdmBQCP_GCygzvDLtS8AMQM9i6QqOkf-9YQkh_AzrKc,1779
-vector2dggs/geohash.py,sha256=PVLkaaSVLgzDZNfuL0y3Xioh4pyvom845HuyLIAsLUY,10398
-vector2dggs/h3.py,sha256=Juvc8g4QWfDIco9RQHaX8p9S9rkW5QvusxpyO-G7eSs,7408
-vector2dggs/katana.py,sha256=v4BRzVCsroC6RzIYdxLfrr9eFOdmXb5S9jXBMs5tgSo,3571
-vector2dggs/rHP.py,sha256=UoRdidkkVGhGP85wrfBE_5BNrx1Xg5skQQe1F5X0LZ8,8109
-vector2dggs/s2.py,sha256=SOXMHQQq86bM88MDgBBemGiXIbuEIbrhLSgPwLKceLY,12809
-vector2dggs-0.10.1.dist-info/COPYING,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-vector2dggs-0.10.1.dist-info/COPYING.LESSER,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
-vector2dggs-0.10.1.dist-info/METADATA,sha256=MNgUCPkWdxUte-n8iRQUgCFAdv_rOXp-GtPvK7vaTNU,12652
-vector2dggs-0.10.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-vector2dggs-0.10.1.dist-info/entry_points.txt,sha256=5h8LB9L2oOE5u_N7FRGtu4JDwa553iPs4u0XhcLeLZU,52
-vector2dggs-0.10.1.dist-info/RECORD,,