cave-utils 2.2.0b2__tar.gz → 2.2.0b4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cave_utils
-Version: 2.2.0b2
+Version: 2.2.0b4
 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.0b2 → cave_utils-2.2.0b4}/cave_utils/api/__init__.py

@@ -95,6 +95,9 @@ class Root(ApiValidator):
             root_data=self.data,
             **kwargs,
         )
+        # 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)
         # Validate panes
         panes_data = self.data.get("panes")
         pane_validPaneIds = []

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

@@ -52,9 +52,8 @@ class appBar_data_star(ApiValidator):
         bar: str,
         variant: [str, None] = None,
         color: [str, None] = None,
-        order: [dict, None] = None,
         apiCommand: [str, None] = None,
-        apiCommandKeys: [list, None] = None,
+        apiCommandKeys: [list[str], None] = None,
         **kwargs,
     ):
         """
@@ -88,7 +87,7 @@ class appBar_data_star(ApiValidator):
             * **Note**: It must be a valid RGBA string.
             * **Example**: `"rgba(255, 255, 255, 1)"`.
         * **`apiCommand`**: `[str]` = `None` → The name of the [API command][] to trigger.
-        * **`apiCommandKeys`**: `[list]` = `None` →
+        * **`apiCommandKeys`**: `[list[str]]` = `None` →
             * The root API keys to pass to your `execute_command` function if an
             `apiCommand` is provided. If omitted, all API keys are
             passed to `execute_command`.

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

@@ -279,13 +279,13 @@ class groupedOutputs_groupings_star(ApiValidator):
         levels_data = self.data.get("levels", {})
         levels_data_keys = list(levels_data.keys())
         data_data = self.data.get("data", {})
-
         CustomKeyValidator(
             data=levels_data,
             log=self.log,
             prepend_path=["levels"],
             validator=groupedOutputs_groupings_star_levels_star,
             acceptable_parents=levels_data_keys,
+            acceptable_data_levels=data_data,
             **kwargs,
         )
         groupedOutputs_groupings_star_data(
@@ -348,7 +348,7 @@ class groupedOutputs_groupings_star_levels_star(ApiValidator):
     """
 
     @staticmethod
-    def spec(name: str, parent: [str, None] = None, ordering: [list, None] = None, **kwargs):
+    def spec(name: str, parent: [str, None] = None, ordering: [list, None] = None, orderWithParent: bool = True, coloring: [dict, None] = None, **kwargs):
         """
         Arguments:
 
@@ -358,16 +358,22 @@ class groupedOutputs_groupings_star_levels_star(ApiValidator):
             * **Notes**:
                 * The parent level key must be defined in `groupedOutputs.groupings.*.levels.*`
                 * If `None`, this will be considered to be the root of the hierarchy.
+        * **`ordering`**: `[list]` →
+            * The ordering of individual values for this level in charts and tables.
+            * **Note**: If none, the ordering will be alphabetical.
+            * **Note**: If a partial ordering is provided, the provided values will be placed first in order.
+            * **Note**: If a partial ordering is provided, the remaining values will be placed in alphabetical order.
+            * **Note**: All items in this list must be defined in `groupedOutputs.groupings.*.levels.*.values.*`
+        * **`orderWithParent`**: `[bool]`=True →
+            * Weather or not to order this level based on the parent level.
+            * If `True`, the ordering of this level will also be based on the parent level.
+            * If `False`, the ordering will be based on the ordering of this level only.
+        * **`coloring`**: `[dict]` →
+            * A dictionary of colors to be used for the level.
+            * Each key in this dictionary is a value in the level.
+            * Each value in this dictionary is an rgba string.
+            * **See**: `cave_utils.api.groupedOutputs.groupedOutputs_groupings_star_levels_star_coloring`
         """
-        # TODO: Figure out new way for ordering
-        # - `ordering`:
-        #     - Type: list
-        #     - What: The ordering of individual values for this level in charts and tables.
-        #     - Note: If none, the ordering will be alphabetical.
-        #     - Note: If a partial ordering is provided, the provided values will be placed first in order.
-        #     - Note: If a partial ordering is provided, the remaining values will be placed in alphabetical order.
-        #     - Note: All items in this list must be defined in `groupedOutputs.groupings.*.levels.*.values.*`
-        # """
         return {"kwargs": kwargs, "accepted_values": {}}
 
     def __extend_spec__(self, **kwargs):
@@ -378,9 +384,18 @@ class groupedOutputs_groupings_star_levels_star(ApiValidator):
                 valid_values=kwargs.get("acceptable_parents", []),
                 prepend_path=["parent"],
             )
-        # ordering = self.data.get("ordering")
-        # if ordering is not None:
-        #     print(ordering, kwargs.get("acceptable_data_keys", []))
-        #     self.__check_subset_valid__(
-        #         subset=ordering, valid_values=kwargs.get("acceptable_data_keys", []), prepend_path=["ordering"]
-        #     )
+        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"]
+            )
+
+        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'),[]),
+                prepend_path=["coloring"],
+            )
+            for key, value in coloring.items():
+                self.__check_rgba_string_valid__(rgba_string=value, prepend_path=['coloring', key])

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

@@ -155,8 +155,10 @@ 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 ["order", "timeValues"]] + [
-            len(v) for k, v in valueLists_data.items() if k not in ["order", "timeValues"]
+        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=[])
@@ -185,16 +187,19 @@ class mapFeatures_data_star_data_location(ApiValidator):
         layer_type = kwargs.get("layer_type")
         layer_geoJson = kwargs.get("layer_geoJson")
         passed_keys = list(self.data.keys())
-        # TODO Figure out way to handle timeValues and order
-        optional_keys = ["timeValues", "order"]
-        if layer_type == "geo" or (layer_type == "arc" and layer_geoJson):
+        optional_keys = []
+        if layer_type == "geo":
             required_keys = ["geoJsonValue"]
         elif layer_type == "arc":
-            if "path" in passed_keys:
+            if layer_geoJson is not None:
+                required_keys = ["geoJsonValue"]
+                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"]
             else:
                 required_keys = ["startLatitude", "startLongitude", "endLatitude", "endLongitude"]
-                optional_keys += ["startAltitude", "endAltitude"]
+                optional_keys += ["startAltitude", "endAltitude", "geoJsonValue", "path"]
         else:
             required_keys = ["latitude", "longitude"]
             optional_keys += ["altitude"]
@@ -209,8 +214,12 @@ class mapFeatures_data_star_data_location(ApiValidator):
                     path=[],
                 )
                 continue
-            if key in ["timeValues", "order"]:
-                continue
+            if key == "geoJsonValue":
+                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],
+                    )
             if not isinstance(value_list, list):
                 self.__error__(
                     msg=f"`{key}` must be a list but got {type(value_list)} instead.", path=[key]
@@ -240,7 +249,7 @@ class mapFeatures_data_star_data_location(ApiValidator):
                         altitudes = None
                 except:
                     self.__error__(
-                        msg=f"`path` must be a list of lists of lists of length 2 or 3. EG: `[[[0,0],[1,1]],[[2,2],[3,3],[4,4],[5,5]]]`",
+                        msg=f"`path` must be a list of lists of lists of length 2 [long,lat] or 3 [long,lat,alt]. EG: `[[[0,0],[1,1]],[[2,2],[3,3],[4,4],[5,5]]]`",
                         path=[key],
                     )
                     continue

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

@@ -82,6 +82,7 @@ class pages_data_star_pageLayout(ApiValidator):
         statId: [str, list, None] = None,
         showToolbar: bool = True,
         maximized: bool = False,
+        defaultToZero: bool = False,
         **kwargs,
     ):
         """
@@ -135,7 +136,8 @@ class pages_data_star_pageLayout(ApiValidator):
             * **Note**: If left unspecified (i.e., `None`), it will default to `settings.showToolbar`.
         * **`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.0b2 → cave_utils-2.2.0b4}/cave_utils/api/settings.py

@@ -291,3 +291,8 @@ class settings_time(ApiValidator):
             * **Example**: `"Decade"`.
         """
         return {"kwargs": kwargs, "accepted_values": {}}
+    
+    def __extend_spec__(self, **kwargs):
+        timeLength = self.data.get("timeLength")
+        if timeLength < 1:
+            self.__error__(f"Time length must be greater than 0.", path=["timeLength"])

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

@@ -4,6 +4,7 @@ General API Spec items that are found in multiple places. This is not a key that
 from pamda import pamda
 import type_enforced
 from cave_utils.api_utils.validator_utils import ApiValidator, CustomKeyValidator
+from typing import Literal
 
 
 @type_enforced.Enforcer
@@ -17,7 +18,7 @@ class props(ApiValidator):
         display: [bool, None] = None,
         enabled: [bool, None] = None,
         apiCommand: [str, None] = None,
-        apiCommandKeys: [list, None] = None,
+        apiCommandKeys: [list[str], None] = None,
         options: [dict, None] = None,
         placeholder: [str, None] = None,
         maxValue: [float, int, None] = None,
@@ -29,7 +30,7 @@ class props(ApiValidator):
         precision: [int, None] = None,
         notationDisplay: [str, None] = None,
         unit: [str, None] = None,
-        views: [list, None] = None,
+        views: [list[str], None] = None,
         legendNotation: [str, None] = None,
         legendPrecision: [int, None] = None,
         legendNotationDisplay: [str, None] = None,
@@ -99,7 +100,7 @@ class props(ApiValidator):
         * **`apiCommand`**: `[str]` = `None` → The name of the API command to trigger.
             * **Note**: If `None`, no `apiCommand` is triggered.
             * **Note**: This attribute is applicable to all props except `"head"` props.
-        * **`apiCommandKeys`**: `[list]` = `None` →
+        * **`apiCommandKeys`**: `[list[str]]` = `None` →
             * The root API keys to pass to your `execute_command` function if an `apiCommand` is provided.
             * **Note**: If `None`, all API keys are passed to your `execute_command`.
             * **Note**: This attribute is applicable to all props except `"head"` props.
@@ -126,15 +127,28 @@ class props(ApiValidator):
         * **`rows`**: `[int]` = `None` →
             * The fixed number of rows to show for a `"textarea"` variant.
             * **Note**: This attribute is applicable exclusively to `"text"` props.
-        * **`views`**: `[list]` = `["year", "day", "hours", "minutes"]` →
+        * **`views`**: `[list[str]]` →
             * The available time units for the represented date and/or time.
+            * **Default Value**:
+                * When **`variant`** == `"date"`: `["year", "day"]`
+                * When **`variant`** == `"time"`: `["hours", "minutes"]`
+                * When **`variant`** == `"datetime"`: `["year", "day", "hours", "minutes"]`
             * **Accepted Values**:
-                * `"year"`: The year view
-                * `"month"`: The month view
-                * `"day"`: The day view
-                * `"hours"`: The hours view
-                * `"minutes"`: The minutes view
-                * `"seconds"`: The seconds view
+                * When **`variant`** == `"date"`:
+                    * `"year"`: The year view
+                    * `"month"`: The month view
+                    * `"day"`: The day view
+                * When **`variant`** == `"time"`:
+                    * `"hours"`: The hours view
+                    * `"minutes"`: The minutes view
+                    * `"seconds"`: The seconds view
+                * When **`variant`** == `"datetime"`:
+                    * `"year"`: The year view
+                    * `"month"`: The month view
+                    * `"day"`: The day view
+                    * `"hours"`: The hours view
+                    * `"minutes"`: The minutes view
+                    * `"seconds"`: The seconds view
             * **Notes**:
                 * The views will be presented in the order specified in the `views` array.
                 * This attribute is applicable exclusively to `"date"` props.
@@ -173,7 +187,7 @@ class props(ApiValidator):
             * **Notes**:
                 * If left unspecified (i.e., `None`), it will default to `settings.defaults.unitPlacement`.
                 * This attribute is applicable exclusively to `"num"` props.
-        * **`notation`**: `[int]` = `"standard"` → The formatting style of a numeric value.
+        * **`notation`**: `[str]` = `"standard"` → The formatting style of a numeric value.
             * **Accepted Values**:
                 * `"standard"`: Plain number formatting
                 * `"compact"`: Resembles the [metric prefix][] system
@@ -184,14 +198,18 @@ class props(ApiValidator):
                 * This attribute is applicable exclusively to `"num"` props.
         * **`notationDisplay`**: `[str]` = `"e+"` | `"short"` → Further customize the formatting within the selected `notation`.
             * **Accepted Values**:
-                * `"short"`: Add symbols `K`, `M`, `B`, and `T` (in `"en-US"`) to denote thousands, millions, billions, and trillions, respectively.
-                * `"long"`: Present numeric values with the informal suffix words `thousand`, `million`, `billion`, and `trillion` (in `"en-US"`).
-                * `"e"`: Exponent symbol in lowercase as per the chosen `locale` identifier
-                * `"e+"`: Similar to `"e"`, but with a plus sign for positive exponents.
-                * `"E"`: Exponent symbol in uppercase as per the chosen `locale` identifier
-                * `"E+"`: Similar to `"E"`, but with a plus sign for positive exponents.
-                * `"x10^"`: Formal scientific notation representation
-                * `"x10^+"`: Similar to `"x10^"`, with a plus sign for positive exponents.
+                * When **`notation`** == `"compact"`:
+                    * `"short"`: Add symbols `K`, `M`, `B`, and `T` (in `"en-US"`) to denote thousands, millions, billions, and trillions, respectively.
+                    * `"long"`: Present numeric values with the informal suffix words `thousand`, `million`, `billion`, and `trillion` (in `"en-US"`).
+                * When **`notation`** == `"scientific"` or `"engineering"`:
+                    * `"e"`: Exponent symbol in lowercase as per the chosen `locale` identifier
+                    * `"e+"`: Similar to `"e"`, but with a plus sign for positive exponents.
+                    * `"E"`: Exponent symbol in uppercase as per the chosen `locale` identifier
+                    * `"E+"`: Similar to `"E"`, but with a plus sign for positive exponents.
+                    * `"x10^"`: Formal scientific notation representation
+                    * `"x10^+"`: Similar to `"x10^"`, with a plus sign for positive exponents.
+                * When **`notation`** == `"standard"`:
+                    * No `notationDisplay` option is allowed for a `"standard"` notation
             * **Notes**:
                 * No `notationDisplay` option is provided for a `"standard"` notation
                 * The options `"short"` and `"long"` are only provided for the `"compact"` notation
@@ -304,20 +322,30 @@ class props(ApiValidator):
         for k, v in passed_values.items():
             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': []
+        }
+        notation = passed_values.get('notation', 'standard')
+        legendNotation = passed_values.get('legendNotation', 'standard')
+        view_options_dict = {
+            "date": ["year", "month", "day"],
+            "time": ["hours", "minutes", "seconds"],
+            "datetime": ["year", "month", "day", "hours", "minutes", "seconds"],
+        }
+        variant = passed_values.get("variant", None)
         return {
             "kwargs": kwargs,
             "accepted_values": {
                 "type": ["head", "num", "toggle", "button", "text", "selector", "date", "media"],
-                "views": ["year", "month", "day", "hours", "minutes", "seconds"],
+                "views": view_options_dict.get(variant, []),
                 "unitPlacement": ["after", "afterWithSpace", "before", "beforeWithSpace"],
-                # TODO: Validate
-                # compact: allowed notation displays -> "short", "long"
-                # scientific|engineering: allowed notation displays -> "e", "e+", "E", "E+", "x10^", "x10^+"
-                # standard: allowed notation displays -> None
                 "notation": ["compact", "precision", "scientific", "engineering"],
-                "notationDisplay": ["short", "long", "e", "e+", "E", "E+", "x10^", "x10^+"],
+                "notationDisplay": notationDisplay_options_dict.get(notation, []),
                 "legendNotation": ["compact", "precision", "scientific", "engineering"],
-                "legendNotationDisplay": ["short", "long", "e", "e+", "E", "E+", "x10^", "x10^+"],
+                "legendNotationDisplay": notationDisplay_options_dict.get(legendNotation, []),
                 "variant": {
                     "head": ["column", "row", "icon", "iconRow"],
                     "text": ["textarea"],
@@ -349,15 +377,15 @@ class props(ApiValidator):
                 **kwargs,
             )
 
-
+@type_enforced.Enforcer
 class props_options(ApiValidator):
     @staticmethod
-    def spec(name: str, path: [list, None] = None, **kwargs):
+    def spec(name: str, path: [list[str], None] = None, **kwargs):
         """
         Arguments:
 
         * **`name`**: `[str]` → The name of the option.
-        * **`path`**: `[list]` = `None` → The path to an option.
+        * **`path`**: `[list[str]]` = `None` → The path to an option.
             * **Notes**:
                 * If `None`, the option will not be selectable
                 * This attribute is applicable exclusively to `"nested"` props
@@ -379,9 +407,6 @@ class props_options(ApiValidator):
                     msg="`path` must be specified and a list of strings for nested options"
                 )
                 return
-            self.__check_type_list__(
-                data=self.data.get("path", []), types=(str,), prepend_path=["path"]
-            )
 
 
 @type_enforced.Enforcer

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

@@ -8,7 +8,7 @@ import type_enforced
 
 @type_enforced.Enforcer
 class Validator:
-    def __init__(self, session_data, ignore_keys: list = list(), **kwargs):
+    def __init__(self, session_data, ignore_keys: list[str] = list(), **kwargs):
         """
         Util to validate your session_data against the API spec.
 
@@ -16,7 +16,7 @@ class Validator:
 
         * **`session_data`**: `[dict]` → The data to validate.
             * **Note**: This should be the data you are sending to the server.
-        * **`ignore_keys`**: `[list]` = `None` → Keys to ignore when validating.
+        * **`ignore_keys`**: `[list[str]]` = `None` → Keys to ignore when validating.
             * **Note**: Any keys specified here will be not be validated if encountered in the data at any level.
         """
         self.session_data = session_data

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

@@ -24,23 +24,23 @@ class ApiValidator:
             "accepted_values": {},
         }
 
-    def __validate__(self, data, log: LogObject, prepend_path: list = list(), **kwargs):
+    def __validate__(self, data:dict, log: LogObject, prepend_path: list[str] = list(), **kwargs):
         """
         Run the API validation process for the passed data.
         """
-        self.data = data
+        # Make a copy of the data to avoid modifying the original
+        self.data = {**data}
         self.ignore_keys = kwargs.get("ignore_keys", set())
         self.log = LogHelper(log=log, prepend_path=prepend_path)
         try:
+            self.__genericKeyValidation__(**kwargs)
             spec_output = self.spec(**self.data)
             extra_kwargs = spec_output.get("kwargs", {})
-            # TODO: Find way to custom check timeValues and order
-            extra_kwargs.pop("order", None)
-            extra_kwargs.pop("timeValues", None)
             if extra_kwargs != {}:
                 self.__warn__(
                     msg=f"Unknown Fields: {str(list(extra_kwargs.keys()))}",
-                )
+                )            
+
         except Exception as e:
             self.__error__(
                 msg=f"Error validating spec: {e}",
@@ -75,21 +75,95 @@ class ApiValidator:
     def __extend_spec__(self, **kwargs):
         pass
 
+    # Additional core validations for generic terms like `order` and `timeValues`
+    def __genericKeyValidation__(self, **kwargs):
+        # 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)
+        if data_timeValues is not None:
+            timeLength = kwargs.get("timeLength")
+            if timeLength is None:
+                self.__error__(
+                    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]]):
+        """
+        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)}
+        if self.__check_subset_valid__(
+            subset=list(order.keys()),
+            valid_values=list(orderable_data_keys.keys()),
+            prepend_path=["order"],
+        ):
+            for order_key, order_list in order.items():
+                self.__check_subset_valid__(
+                    subset=order_list,
+                    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):
+        if len(timeValues) == 0:
+            return
+        if isinstance(timeValues, list):
+            if len(timeValues) != timeLength:
+                self.__error__(
+                    path=['timeValues'],
+                    msg=f"The length of `timeValues` (as a list) must be equal to `settings.time.timeLength` ({timeLength})",
+                )
+                return
+        if isinstance(timeValues, dict):
+            keys = list(timeValues.keys())
+            if not all(isinstance(key, int) for key in keys):
+                self.__error__(
+                    path=['timeValues'],
+                    msg="`timeValues` (as a dict) keys must be integers",
+                )
+                return
+            if not all(key >= 0 and key<timeLength for key in keys):
+                self.__error__(
+                    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()}
+        for timeValue in timeValues:
+            if timeValueTypes != {k:type(v) for k,v in timeValue.items()}:
+                self.__error__(
+                    path=['timeValues'],
+                    msg="All timeValues must have the same keys and each key must have the same type",
+                )
+                return
+        # Update the data with the first timeValue prioritizing original data
+        # over the first timeValue
+        self.data = {**timeValues[0], **self.data}
+
     # Error and Warning Helpers
-    def __error__(self, msg: str, path: list = list()):
+    def __error__(self, msg: str, path: list[str] = list()):
         """
         Raise an error for the log the log
         """
         self.log.add(path=path, msg=msg)
 
-    def __warn__(self, msg: str, path: list = list()):
+    def __warn__(self, msg: str, path: list[str] = list()):
         """
         Raise a warning for the log the log
         """
         self.log.add(path=path, msg=msg, level="warning")
 
     # Useful Validator Checks
-    def __check_rgba_string_valid__(self, rgba_string: str, prepend_path: list = list()):
+    def __check_rgba_string_valid__(self, rgba_string: str, prepend_path: list[str] = list()):
         """
         Validate an rgba string and if an issue is present, log an error
         """
@@ -112,7 +186,7 @@ class ApiValidator:
         except:
             self.__error__(path=prepend_path, msg=msg)
 
-    def __check_pixel_string_valid__(self, pixel_string: str, prepend_path: list = list()):
+    def __check_pixel_string_valid__(self, pixel_string: str, prepend_path: list[str] = list()):
         """
         Validate a pixel string and if an issue is present, log an error
         """
@@ -126,7 +200,7 @@ class ApiValidator:
         except:
             self.__error__(path=prepend_path, msg=msg)
 
-    def __check_url_valid__(self, url: str, prepend_path: list = list()):
+    def __check_url_valid__(self, url: str, prepend_path: list[str] = list()):
         """
         Validate a url and if an issue is present, log an error.
         """
@@ -146,7 +220,7 @@ class ApiValidator:
             return False
         return True
 
-    def __check_date_valid__(self, input: str, date_variant: str, prepend_path: list = list()):
+    def __check_date_valid__(self, input: str, date_variant: str, prepend_path: list[str] = list()):
         """
         Validate a date string and if an issue is present, log an error.
         """
@@ -189,7 +263,7 @@ class ApiValidator:
         self,
         subset: list,
         valid_values: list,
-        prepend_path: list = list(),
+        prepend_path: list[str] = list(),
         valid_values_count: int = 6,
     ):
         """
@@ -211,7 +285,7 @@ class ApiValidator:
             return False
         return True
 
-    def __check_coord_path_valid__(self, coord_path: list, prepend_path: list = 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
         """
@@ -257,7 +331,7 @@ class ApiValidator:
                 return False
         return True
 
-    def __check_type_dict__(self, data: dict, types: tuple, prepend_path: list = list()):
+    def __check_type_dict__(self, data: dict, types: tuple, prepend_path: list[str] = list()):
         """
         Validate a dict only contains certain object types for values and if an issue is present, log an error
 
@@ -274,7 +348,7 @@ class ApiValidator:
                 return False
         return True
 
-    def __check_type__(self, value, check_type, prepend_path: list = list()):
+    def __check_type__(self, value, check_type, prepend_path: list[str] = list()):
         """
         Validate a value is a certain type and if an issue is present, log an error
 

cave_utils-2.2.0b4/cave_utils/socket.py

@@ -0,0 +1,12 @@
+class Socket:
+    def __init__(self, silent=False):
+        self.silent = silent
+        pass
+
+    def broadcast(self, *args, **kwargs):
+        if not self.silent:
+            print("broadcast: ", {"args": args, "kwargs": kwargs})
+
+    def notify(self, *args, **kwargs):
+        if not self.silent:
+            print("notify: ", {"args": args, "kwargs": kwargs})

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cave_utils
-Version: 2.2.0b2
+Version: 2.2.0b4
 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.0b2 → cave_utils-2.2.0b4}/pyproject.toml

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

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

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

cave_utils-2.2.0b2/cave_utils/socket.py

@@ -1,9 +0,0 @@
-class Socket:
-    def __init__(self):
-        pass
-
-    def broadcast(self, *args, **kwargs):
-        print("broadcast: ", {"args": args, "kwargs": kwargs})
-
-    def notify(self, *args, **kwargs):
-        print("notify: ", {"args": args, "kwargs": kwargs})