cave-utils 2.2.0b4__tar.gz → 2.2.1__tar.gz

{cave_utils-2.2.0b4/cave_utils.egg-info → cave_utils-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cave_utils
-Version: 2.2.0b4
+Version: 2.2.1
 Summary: Python wrapper for api use in the cave_app
 Author-email: Connor Makowski <conmak@mit.edu>
 Project-URL: Homepage, https://github.com/mit-cave/cave_utils

{cave_utils-2.2.0b4 → cave_utils-2.2.1}/cave_utils/__init__.py

@@ -5,7 +5,9 @@ On the left hand side, you will find all available submodules, and their associa
 
 Click on a submodule to see the documentation for that submodule.
 """
+
 from .log import LogObject, LogHelper
 from .socket import Socket
 from .api_utils.validator import Validator
 from .arguments import Arguments
+from .geo_utils import GeoUtils

{cave_utils-2.2.0b4 → cave_utils-2.2.1}/cave_utils/api/__init__.py

@@ -11,6 +11,7 @@ Submodules (and their classes) are used to define the api at each level. You can
 
 See the left hand side for all available submodules.
 """
+
 from cave_utils.api_utils.validator_utils import *
 from cave_utils.api.extraKwargs import extraKwargs
 from cave_utils.api.settings import settings
@@ -97,7 +98,7 @@ class Root(ApiValidator):
         )
         # Special logic to add timeLength to kwargs
         # This is used to validate timeValues across the app
-        kwargs["timeLength"] = pamda.path(["settings","time","timeLength"], self.data)
+        kwargs["timeLength"] = pamda.path(["settings", "time", "timeLength"], self.data)
         # Validate panes
         panes_data = self.data.get("panes")
         pane_validPaneIds = []

{cave_utils-2.2.0b4 → cave_utils-2.2.1}/cave_utils/api/appBar.py

@@ -12,6 +12,7 @@ simultaneously.
 [predefined]: #appBar_data_star.spec
 [custom]: #appBar_data_star.spec
 """
+
 from cave_utils.api_utils.validator_utils import ApiValidator, CustomKeyValidator
 import type_enforced
 

{cave_utils-2.2.0b4 → cave_utils-2.2.1}/cave_utils/api/extraKwargs.py

@@ -2,6 +2,7 @@
 Optionally, pass special arguments to adjust some options related to
 how the CAVE API server handles data.
 """
+
 from cave_utils.api_utils.validator_utils import ApiValidator
 import type_enforced
 

{cave_utils-2.2.0b4 → cave_utils-2.2.1}/cave_utils/api/globalOutputs.py

@@ -2,6 +2,7 @@
 
 These outputs should be general to the entire application and they can be compared across sessions.
 """
+
 from cave_utils.api_utils.validator_utils import ApiValidator, CustomKeyValidator
 from cave_utils.api_utils.general import props, values, layout
 import type_enforced

{cave_utils-2.2.0b4 → cave_utils-2.2.1}/cave_utils/api/groupedOutputs.py

@@ -1,6 +1,7 @@
 """
 Create grouped outputs for building generalized charts and tables.
 """
+
 from cave_utils.api_utils.validator_utils import ApiValidator, CustomKeyValidator
 import type_enforced
 from pamda import pamda
@@ -348,7 +349,14 @@ class groupedOutputs_groupings_star_levels_star(ApiValidator):
     """
 
     @staticmethod
-    def spec(name: str, parent: [str, None] = None, ordering: [list, None] = None, orderWithParent: bool = True, coloring: [dict, None] = None, **kwargs):
+    def spec(
+        name: str,
+        parent: [str, None] = None,
+        ordering: [list, None] = None,
+        orderWithParent: bool = True,
+        coloring: [dict, None] = None,
+        **kwargs,
+    ):
         """
         Arguments:
 
@@ -387,15 +395,21 @@ class groupedOutputs_groupings_star_levels_star(ApiValidator):
         ordering = self.data.get("ordering")
         if ordering is not None:
             self.__check_subset_valid__(
-                subset=ordering, valid_values=kwargs.get("acceptable_data_levels", {}).get(kwargs.get('CustomKeyValidatorFieldId'),[]), prepend_path=["ordering"]
+                subset=ordering,
+                valid_values=kwargs.get("acceptable_data_levels", {}).get(
+                    kwargs.get("CustomKeyValidatorFieldId"), []
+                ),
+                prepend_path=["ordering"],
             )
 
         coloring = self.data.get("coloring")
         if coloring is not None:
             self.__check_subset_valid__(
                 subset=list(coloring.keys()),
-                valid_values=kwargs.get("acceptable_data_levels", {}).get(kwargs.get('CustomKeyValidatorFieldId'),[]),
+                valid_values=kwargs.get("acceptable_data_levels", {}).get(
+                    kwargs.get("CustomKeyValidatorFieldId"), []
+                ),
                 prepend_path=["coloring"],
             )
             for key, value in coloring.items():
-                self.__check_rgba_string_valid__(rgba_string=value, prepend_path=['coloring', key])
+                self.__check_rgba_string_valid__(rgba_string=value, prepend_path=["coloring", key])

{cave_utils-2.2.0b4 → cave_utils-2.2.1}/cave_utils/api/mapFeatures.py

@@ -1,6 +1,7 @@
 """
 Create visualizations for your map, including `arc`s, `node`s, and `geo`s, and customize their appearance.
 """
+
 from cave_utils.api_utils.validator_utils import ApiValidator, CustomKeyValidator
 from cave_utils.api_utils.general import props, valueLists, layout
 import type_enforced
@@ -155,10 +156,8 @@ class mapFeatures_data_star_data(ApiValidator):
             **kwargs,
         )
         # Validate that all lengths are the same
-        lengths = [
-            len(v) for k, v in location_data.items() if k not in ['timeValues', 'order']
-        ] + [
-            len(v) for k, v in valueLists_data.items() if k not in ['timeValues', 'order']
+        lengths = [len(v) for k, v in location_data.items() if k not in ["timeValues", "order"]] + [
+            len(v) for k, v in valueLists_data.items() if k not in ["timeValues", "order"]
         ]
         if len(set(lengths)) > 1:
             self.__error__(msg=f"location and valueLists keys must have the same length.", path=[])
@@ -193,10 +192,26 @@ class mapFeatures_data_star_data_location(ApiValidator):
         elif layer_type == "arc":
             if layer_geoJson is not None:
                 required_keys = ["geoJsonValue"]
-                optional_keys += ["path", "startLatitude", "startLongitude", "endLatitude", "endLongitude","startAltitude", "endAltitude"]
+                optional_keys += [
+                    "path",
+                    "startLatitude",
+                    "startLongitude",
+                    "endLatitude",
+                    "endLongitude",
+                    "startAltitude",
+                    "endAltitude",
+                ]
             elif "path" in passed_keys:
                 required_keys = ["path"]
-                optional_keys += ["startLatitude", "startLongitude", "endLatitude", "endLongitude", "geoJsonValue","startAltitude", "endAltitude"]
+                optional_keys += [
+                    "startLatitude",
+                    "startLongitude",
+                    "endLatitude",
+                    "endLongitude",
+                    "geoJsonValue",
+                    "startAltitude",
+                    "endAltitude",
+                ]
             else:
                 required_keys = ["startLatitude", "startLongitude", "endLatitude", "endLongitude"]
                 optional_keys += ["startAltitude", "endAltitude", "geoJsonValue", "path"]
@@ -215,7 +230,7 @@ class mapFeatures_data_star_data_location(ApiValidator):
                 )
                 continue
             if key == "geoJsonValue":
-                if len(value_list)!=len(set(value_list)):
+                if len(value_list) != len(set(value_list)):
                     self.__warn__(
                         msg=f"`geoJsonValue` should be a list of unique values. Otherwise, the corresponding map feature may not render correctly.",
                         path=[key],

{cave_utils-2.2.0b4 → cave_utils-2.2.1}/cave_utils/api/maps.py

@@ -1,6 +1,7 @@
 """
 Configure the style and UI elements of your application's maps.
 """
+
 from cave_utils.api_utils.validator_utils import ApiValidator, CustomKeyValidator
 import type_enforced
 

{cave_utils-2.2.0b4 → cave_utils-2.2.1}/cave_utils/api/pages.py

@@ -1,6 +1,7 @@
 """
 Configure your application's pages.
 """
+
 from cave_utils.api_utils.validator_utils import ApiValidator, CustomKeyValidator
 import type_enforced
 
@@ -137,7 +138,7 @@ class pages_data_star_pageLayout(ApiValidator):
         * **`maximized`**: `[bool]` = `False` → Whether or not the layout should be maximized.
             * **Note**: If more than one chart belonging to the same page layout is set to `True`, the first one found in the list will take precedence.
         * **`defaultToZero`**: `[bool]` = `False` → Whether or not the chart should default missing values to zero.
-            
+
         [area chart]: https://en.wikipedia.org/wiki/Area_chart
         [bar chart]: https://en.wikipedia.org/wiki/Bar_chart
         [stacked bar chart]: https://en.wikipedia.org/wiki/Bar_chart

{cave_utils-2.2.0b4 → cave_utils-2.2.1}/cave_utils/api/panes.py

@@ -3,6 +3,7 @@ Panes serve as main containers for UI controls such as toggles, text
 and number fields, sliders, etc. They can also contain buttons that
 facilitate interaction with actionable data.
 """
+
 from cave_utils.api_utils.validator_utils import ApiValidator, CustomKeyValidator
 from cave_utils.api_utils.general import props, values, layout
 import type_enforced

{cave_utils-2.2.0b4 → cave_utils-2.2.1}/cave_utils/api/settings.py

@@ -1,6 +1,7 @@
 """
 Configure general settings for your application like the icons to use, how to sync data with the server, and more.
 """
+
 from cave_utils.api_utils.validator_utils import *
 import type_enforced
 
@@ -291,7 +292,7 @@ class settings_time(ApiValidator):
             * **Example**: `"Decade"`.
         """
         return {"kwargs": kwargs, "accepted_values": {}}
-    
+
     def __extend_spec__(self, **kwargs):
         timeLength = self.data.get("timeLength")
         if timeLength < 1:

{cave_utils-2.2.0b4 → cave_utils-2.2.1}/cave_utils/api_utils/general.py

@@ -1,10 +1,10 @@
 """
 General API Spec items that are found in multiple places. This is not a key that should be passed as part of your `session_data`.
 """
+
 from pamda import pamda
 import type_enforced
 from cave_utils.api_utils.validator_utils import ApiValidator, CustomKeyValidator
-from typing import Literal
 
 
 @type_enforced.Enforcer
@@ -323,13 +323,13 @@ class props(ApiValidator):
             if k not in required_fields + optional_fields:
                 kwargs[k] = v
         notationDisplay_options_dict = {
-            'compact': ['short', 'long'],
-            'scientific': ['e', 'e+', 'E', 'E+', 'x10^', 'x10^+'],
-            'engineering': ['e', 'e+', 'E', 'E+', 'x10^', 'x10^+'],
-            'standard': []
+            "compact": ["short", "long"],
+            "scientific": ["e", "e+", "E", "E+", "x10^", "x10^+"],
+            "engineering": ["e", "e+", "E", "E+", "x10^", "x10^+"],
+            "standard": [],
         }
-        notation = passed_values.get('notation', 'standard')
-        legendNotation = passed_values.get('legendNotation', 'standard')
+        notation = passed_values.get("notation", "standard")
+        legendNotation = passed_values.get("legendNotation", "standard")
         view_options_dict = {
             "date": ["year", "month", "day"],
             "time": ["hours", "minutes", "seconds"],
@@ -348,7 +348,7 @@ class props(ApiValidator):
                 "legendNotationDisplay": notationDisplay_options_dict.get(legendNotation, []),
                 "variant": {
                     "head": ["column", "row", "icon", "iconRow"],
-                    "text": ["textarea"],
+                    "text": ["single", "textarea"],
                     "num": ["field", "slider", "icon", "iconCompact"],
                     "selector": [
                         "dropdown",
@@ -377,6 +377,7 @@ class props(ApiValidator):
                 **kwargs,
             )
 
+
 @type_enforced.Enforcer
 class props_options(ApiValidator):
     @staticmethod

{cave_utils-2.2.0b4 → cave_utils-2.2.1}/cave_utils/api_utils/validator.py

@@ -1,6 +1,7 @@
 """
 This module contains the primary Validator class that is used to validate your session_data against the API spec.
 """
+
 from cave_utils.api_utils.validator_utils import LogObject
 from cave_utils.api import Root
 import type_enforced

{cave_utils-2.2.0b4 → cave_utils-2.2.1}/cave_utils/api_utils/validator_utils.py

@@ -1,6 +1,7 @@
 """
 Special utility functions to help in validating your data against the CAVE API. This is not a key that should be passed as part of your `session_data`.
 """
+
 from pamda import pamda
 import type_enforced
 import re, datetime
@@ -24,7 +25,7 @@ class ApiValidator:
             "accepted_values": {},
         }
 
-    def __validate__(self, data:dict, log: LogObject, prepend_path: list[str] = list(), **kwargs):
+    def __validate__(self, data: dict, log: LogObject, prepend_path: list[str] = list(), **kwargs):
         """
         Run the API validation process for the passed data.
         """
@@ -39,7 +40,7 @@ class ApiValidator:
             if extra_kwargs != {}:
                 self.__warn__(
                     msg=f"Unknown Fields: {str(list(extra_kwargs.keys()))}",
-                )            
+                )
 
         except Exception as e:
             self.__error__(
@@ -77,7 +78,7 @@ class ApiValidator:
 
     # Additional core validations for generic terms like `order` and `timeValues`
     def __genericKeyValidation__(self, **kwargs):
-        # Remove `timeValues` out prior to each level validation 
+        # Remove `timeValues` out prior to each level validation
         data_timeValues = self.data.pop("timeValues", None)
         # Remove `order` out prior to each level validation
         data_order = self.data.pop("order", None)
@@ -85,20 +86,22 @@ class ApiValidator:
             timeLength = kwargs.get("timeLength")
             if timeLength is None:
                 self.__error__(
-                    path=['timeValues'],
+                    path=["timeValues"],
                     msg="`settings.time.timeLength` must be specified to validate `timeValues`",
                 )
             else:
                 self.__timeValues_validation__(timeValues=data_timeValues, timeLength=timeLength)
         if data_order is not None:
             self.__order_validation__(order=data_order)
-            
+
     @type_enforced.Enforcer
-    def __order_validation__(self, order:dict[list[str,int]]):
+    def __order_validation__(self, order: dict[list[str, int]]):
         """
         Check that the ordering options are valid
         """
-        orderable_data_keys = {key: list(value.keys()) for key, value in self.data.items() if isinstance(value, dict)}
+        orderable_data_keys = {
+            key: list(value.keys()) for key, value in self.data.items() if isinstance(value, dict)
+        }
         if self.__check_subset_valid__(
             subset=list(order.keys()),
             valid_values=list(orderable_data_keys.keys()),
@@ -110,15 +113,15 @@ class ApiValidator:
                     valid_values=orderable_data_keys[order_key],
                     prepend_path=["order", order_key],
                 )
-    
+
     @type_enforced.Enforcer
-    def __timeValues_validation__(self, timeValues: [dict[dict],list[dict]], timeLength:int):
+    def __timeValues_validation__(self, timeValues: [dict[dict], list[dict]], timeLength: int):
         if len(timeValues) == 0:
             return
         if isinstance(timeValues, list):
             if len(timeValues) != timeLength:
                 self.__error__(
-                    path=['timeValues'],
+                    path=["timeValues"],
                     msg=f"The length of `timeValues` (as a list) must be equal to `settings.time.timeLength` ({timeLength})",
                 )
                 return
@@ -126,22 +129,22 @@ class ApiValidator:
             keys = list(timeValues.keys())
             if not all(isinstance(key, int) for key in keys):
                 self.__error__(
-                    path=['timeValues'],
+                    path=["timeValues"],
                     msg="`timeValues` (as a dict) keys must be integers",
                 )
                 return
-            if not all(key >= 0 and key<timeLength for key in keys):
+            if not all(key >= 0 and key < timeLength for key in keys):
                 self.__error__(
-                    path=['timeValues'],
+                    path=["timeValues"],
                     msg=f"`timeValues` (as a dict) keys must be integers between 0 and {timeLength-1} inclusive (1 minus the value at `settings.time.timeLength`)",
                 )
                 return
             timeValues = list(timeValues.values())
-        timeValueTypes = {k:type(v) for k,v in timeValues[0].items()}
+        timeValueTypes = {k: type(v) for k, v in timeValues[0].items()}
         for timeValue in timeValues:
-            if timeValueTypes != {k:type(v) for k,v in timeValue.items()}:
+            if timeValueTypes != {k: type(v) for k, v in timeValue.items()}:
                 self.__error__(
-                    path=['timeValues'],
+                    path=["timeValues"],
                     msg="All timeValues must have the same keys and each key must have the same type",
                 )
                 return
@@ -285,7 +288,9 @@ class ApiValidator:
             return False
         return True
 
-    def __check_coord_path_valid__(self, coord_path: list[list[int,float]], prepend_path: list[str] = list()):
+    def __check_coord_path_valid__(
+        self, coord_path: list[list[int, float]], prepend_path: list[str] = list()
+    ):
         """
         Validate a coordinate path and if an issue is present, log an error
         """

cave_utils-2.2.1/cave_utils/geo_utils.py

@@ -0,0 +1,115 @@
+from pamda import pamda
+import type_enforced
+
+
+class GeoUtils:
+    @type_enforced.Enforcer
+    @staticmethod
+    def create_shortest_paths_geojson(
+        geoGraph,
+        ids: list[int, str],
+        origin_latitudes: list[int, float],
+        origin_longitudes: list[int, float],
+        destination_latitudes: list[int, float],
+        destination_longitudes: list[int, float],
+        additional_properties: [list[dict], None] = None,
+        show_progress: bool = False,
+        filename: [str, None] = None,
+        **kwargs,
+    ):
+        """
+        Creates a geoJson output with the shortest paths between a list of
+        origin and destination points.
+
+        Arguments:
+
+        * **`geoGraph`**: `[geoGraph]` → A geoGraph object from scgraph.
+        * **`ids`**: `[list[int, str]]` → A list of identifiers for each path.
+            * Note: These are imputed into the output GeoJSON as an id property.
+        * **`origin_latitudes`**: `[list[int, float]]` →
+            * A list of latitudes for the origin points.
+        * **`origin_longitudes`**: `[list[int, float]]` →
+            * A list of longitudes for the origin points.
+        * **`destination_latitudes`**: `[list[int, float]]` →
+            * A list of latitudes for the destination points.
+        * **`destination_longitudes`**: `[list[int, float]]` →
+            * A list of longitudes for the destination points.
+        * **`additional_properties`**: `[list[dict], None]` →
+            * A list of dictionaries with additional properties for each path.
+            * Note: The dictionaries must have the same length as the input lists.
+            * Note: The dictionaries are imputed into the output GeoJSON as properties.
+
+        Optional Arguments:
+
+        * **`show_progress`**: `[bool]` →
+            * If True, shows the progress of the calculations.
+            * Default: False
+        * **`filename`**: `[str, None]` →
+            * If provided, saves the output GeoJSON to the specified filename.
+            * Default: None
+
+        Returns:
+
+        * **`output`**: `[dict]` → A GeoJSON dictionary with the shortest paths given the input data.
+
+        """
+        if not hasattr(geoGraph, "get_shortest_path"):
+            raise ValueError("`geoGraph` must be a geoGraph object from scgraph")
+        len_items = len(ids)
+        if additional_properties is None:
+            additional_properties = [{} for i in range(len_items)]
+        data = {
+            "ids": ids,
+            "origin_latitudes": origin_latitudes,
+            "origin_longitudes": origin_longitudes,
+            "destination_latitudes": destination_latitudes,
+            "destination_longitudes": destination_longitudes,
+            "additional_properties": additional_properties,
+        }
+        # Check that all the lists have at least one element
+        if len_items == 0:
+            raise ValueError("All input lists must have at least one element")
+        # Check that all the lists have the same length
+        if len(set(map(len, data.values()))) != 1:
+            raise ValueError("All input lists must have the same length")
+        features = []
+        # Iterate over the data and calculate the shortest path for
+        # each origin and destination pair
+        for idx, item in enumerate(pamda.pivot(data)):
+            item = dict(item)
+            shortest_path_output = geoGraph.get_shortest_path(
+                origin_node={
+                    "latitude": item["origin_latitudes"],
+                    "longitude": item["origin_longitudes"],
+                },
+                destination_node={
+                    "latitude": item["destination_latitudes"],
+                    "longitude": item["destination_longitudes"],
+                },
+                output_coordinate_path="list_of_lists_long_first",
+                **kwargs,
+            )
+            # Append the calculated path to the features list in GeoJSON format
+            features.append(
+                {
+                    "type": "Feature",
+                    "geometry": {
+                        "type": "LineString",
+                        "coordinates": shortest_path_output["coordinate_path"],
+                    },
+                    "properties": {
+                        "id": item["ids"],
+                        "length": shortest_path_output["length"],
+                        **item["additional_properties"],
+                    },
+                }
+            )
+            if show_progress:
+                print(f"Paths Calculated: {idx}/{len_items}", end="\r")
+        if show_progress:
+            print(f"Paths Calculated: {len_items}/{len_items}")
+        # Create the GeoJSON output
+        output = {"type": "FeatureCollection", "features": features}
+        if filename is not None:
+            pamda.write_json(data=output, filename=filename)
+        return output

{cave_utils-2.2.0b4 → cave_utils-2.2.1}/cave_utils/socket.py

@@ -1,7 +1,6 @@
 class Socket:
     def __init__(self, silent=False):
         self.silent = silent
-        pass
 
     def broadcast(self, *args, **kwargs):
         if not self.silent:

{cave_utils-2.2.0b4 → cave_utils-2.2.1/cave_utils.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cave_utils
-Version: 2.2.0b4
+Version: 2.2.1
 Summary: Python wrapper for api use in the cave_app
 Author-email: Connor Makowski <conmak@mit.edu>
 Project-URL: Homepage, https://github.com/mit-cave/cave_utils

{cave_utils-2.2.0b4 → cave_utils-2.2.1}/cave_utils.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ pyproject.toml
 setup.cfg
 cave_utils/__init__.py
 cave_utils/arguments.py
+cave_utils/geo_utils.py
 cave_utils/log.py
 cave_utils/socket.py
 cave_utils.egg-info/PKG-INFO
@@ -30,6 +31,7 @@ cave_utils/builders/__init__.py
 cave_utils/builders/groups.py
 test/test_arguments.py
 test/test_builders_groups.py
+test/test_geo_utils.py
 test/test_import.py
 test/test_log.py
 test/test_validator.py

{cave_utils-2.2.0b4 → cave_utils-2.2.1}/pyproject.toml

@@ -12,7 +12,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cave_utils"
-version = "2.2.0b4"
+version = "2.2.1"
 description = "Python wrapper for api use in the cave_app"
 authors = [
     {name="Connor Makowski", email="conmak@mit.edu"}

{cave_utils-2.2.0b4 → cave_utils-2.2.1}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = cave_utils
-version = 2.2.0b4
+version = 2.2.1
 description_file = README.md
 
 [options]

cave_utils-2.2.1/test/test_geo_utils.py

@@ -0,0 +1,17 @@
+from scgraph.geographs.marnet import marnet_geograph
+
+from cave_utils import GeoUtils
+
+count = 100
+print("Creating 100 shortest paths geojson...")
+out = GeoUtils.create_shortest_paths_geojson(
+    geoGraph=marnet_geograph,
+    ids=[str(i) for i in range(count)],
+    origin_latitudes=[0 + i / 4 for i in range(count)],
+    origin_longitudes=[0 + i / 4 for i in range(count)],
+    destination_latitudes=[0 - i / 4 for i in range(count)],
+    destination_longitudes=[0 - i / 4 for i in range(count)],
+    show_progress=True,
+    # filename="test.geojson"
+)
+print("Done!")