cave-utils 3.4.0b2__tar.gz → 3.4.2__tar.gz

{cave_utils-3.4.0b2/cave_utils.egg-info → cave_utils-3.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cave_utils
-Version: 3.4.0b2
+Version: 3.4.2
 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-3.4.0b2 → cave_utils-3.4.2}/cave_utils/__init__.py

@@ -103,7 +103,6 @@ Make sure Docker is installed and running.
 5. Update the release
     - `source venv/bin/activate`
     - `./publish.sh`"""
-
 from .log import LogObject, LogHelper
 from .socket import Socket
 from .api_utils.validator import Validator

{cave_utils-3.4.0b2 → cave_utils-3.4.2}/cave_utils/api/appBar.py

@@ -66,7 +66,9 @@ class appBar_data_star(ApiValidator):
         * **`type`**: `[str]` → The type of object displayed when the action is triggered.
             * **Accepted Values**:
                 * `"session"`: The Session Pane
+                    * If you use this type, your field id must be `"session"`.
                 * `"settings"`: The Application Settings Pane
+                    * If you use this type, your field id must be `"settings"`.
                 * `"button"`: A button that allows you to send a command to the CAVE API
                 * `"pane"`: A [custom pane][]
                 * `"page"`: A [page][]
@@ -76,6 +78,8 @@ class appBar_data_star(ApiValidator):
                 * `"lowerLeft"`: Lower section of the left-side bar
                 * `"upperRight"`: Upper section of the right-side bar
                 * `"lowerRight"`: Lower section of the right-side bar
+                * `"none"`: Do not display the action element in the app bar
+                    - This is useful to hide predefined appBar buttions like the `session` or `settings` panes.
         * **`variant`**: `[str]` = `None` → The variant of the button.
             * **Accepted Values**:
                 * When **`type`** == `"pane"`:
@@ -105,7 +109,7 @@ class appBar_data_star(ApiValidator):
             "accepted_values": {
                 "type": ["session", "settings", "button", "pane", "page"],
                 "variant": ["modal", "wall"] if type == "pane" else [],
-                "bar": ["upperLeft", "lowerLeft", "upperRight", "lowerRight"],
+                "bar": ["upperLeft", "lowerLeft", "upperRight", "lowerRight", "none"],
             },
         }
 
@@ -127,3 +131,15 @@ class appBar_data_star(ApiValidator):
                 valid_values=kwargs.get("pane_validPaneIds", []),
                 prepend_path=[],
             )
+        if bar_type == "session":
+            if kwargs.get("CustomKeyValidatorFieldId") != "session":
+                self.__error__(
+                    msg=f"When `type` is 'session', the only valid id for this `appBar.data` item is 'session'. Received: '{kwargs.get('CustomKeyValidatorFieldId')}'",
+                    path=[],
+                )
+        if bar_type == "settings":
+            if kwargs.get("CustomKeyValidatorFieldId") != "settings":
+                self.__error__(
+                    msg=f"When `type` is 'settings', the only valid id for this `appBar.data` item is 'settings'. Received: '{kwargs.get('CustomKeyValidatorFieldId')}'",
+                    path=[],
+                )

{cave_utils-3.4.0b2 → cave_utils-3.4.2}/cave_utils/api_utils/validator_utils.py

@@ -80,6 +80,9 @@ class ApiValidator:
     def __genericKeyValidation__(self, **kwargs):
         # Remove `timeValues` out prior to each level validation
         data_timeValues = self.data.pop("timeValues", None)
+        # Remove 'ignore_keys' from data to avoid validation issues
+        for key in self.ignore_keys:
+            self.data.pop(key, None)
         # Remove `order` out prior to each level validation
         data_order = self.data.pop("order", None)
         if data_timeValues is not None:
@@ -155,7 +158,7 @@ class ApiValidator:
     # Error and Warning Helpers
     def __error__(self, msg: str, path: list[str] = list()):
         """
-        Raise an error for the log the log
+        Raise an error for the log
         """
         self.log.add(path=path, msg=msg)
 

{cave_utils-3.4.0b2 → cave_utils-3.4.2}/cave_utils/custom_coordinates.py

@@ -1,4 +1,4 @@
-import type_enforced, math, requests, re, json
+import type_enforced, math, json
 
 
 @type_enforced.Enforcer
@@ -208,164 +208,32 @@ class CustomCoordinateSystem:
             "path": converted_path,
         }
 
-    def convert_geojson(self, geojson_object: str, write_path: str):
+    def convert_geojson(self, geojson_filepath: str, output_filepath: str):
         """
         Converts the coordinates of the given GeoJSON object using this coordinate system to a longitude-latitdue-altitude system and writes the new object to a file.
 
         Arguments:
 
-        * **`geojson_object`**: `[str]` → The URL or file of the GeoJSON object to use.
-        * **`write_path`**: `[str]` → The file path to write the converted GeoJSON object to.
+        * **`geojson_filepath`**: `[str]` → The file path to the GeoJSON object.
+        * **`output_filepath`**: `[str]` → The file path to write the converted GeoJSON object to.
 
         Returns:
 
         * `[None]`
         """
-        url_regex = r"^https?:\/\/.*"
-        if re.search(url_regex, geojson_object):
-            geojson_object = requests.get(geojson_object).json()
-        else:
-            with open(geojson_object, "r") as f:
-                geojson_object = json.load(f)
+        with open(geojson_filepath, "r") as f:
+            geojson_filepath = json.load(f)
 
-        if geojson_object["type"] == "FeatureCollection":
-            for feature in geojson_object["features"]:
+        if geojson_filepath["type"] == "FeatureCollection":
+            for feature in geojson_filepath["features"]:
                 self.convert_coordinates(feature["geometry"]["coordinates"])
-        elif geojson_object["type"] == "Feature":
-            self.convert_coordinates(geojson_object["geometry"]["coordinates"])
+        elif geojson_filepath["type"] == "Feature":
+            self.convert_coordinates(geojson_filepath["geometry"]["coordinates"])
         else:
-            self.convert_coordinates(geojson_object["coordinates"])
-        with open(write_path, "w") as f:
-            json.dump(geojson_object, f)
-        print(f"GeoJSON converted and saved to {write_path}.")
-
-    def __serialize_geojson__(self, geoJsonLayer: str, geoJsonProp: str, geoJsonValue: list[str]):
-        """
-        Serializes the given GeoJSON object in this coordinate system to a dictionary of the proper format to be used under `mapFeatures.data.*.data.location`.
-
-        Arguments:
-
-        * **`geoJsonLayer`**: `[str]` → The URL of the GeoJSON layer to use.
-            * ** Note **: Must be a FeatureCollection
-        * **`geoJsonProp`**: `[str]` →
-            * The `properties` key (from the object fetched from the `geoJsonLayer` URL) to match with `geoJsonValue`.
-        * **`geoJsonValue`**: `[list[str]]` → A list of geoJsonValue keys that correspond to `geoJsonProp`.
-            * ** Note **: All corresponding geometries must be of similar type:
-                * `Point` and `MultiPoint`
-                * `LineString` and `MultiLineString`
-                * `Polygon` and `MultiPolygon`
-
-        Returns:
-
-        * `[dict]` → The serialized location structure.
-        """
-        geojson_object = requests.get(geoJsonLayer).json()
-        if geojson_object["type"] != "FeatureCollection":
-            raise ValueError("geoJsonLayer must be a FeatureCollection.")
-
-        requested_geometries = []
-        for feature in geojson_object["features"]:
-            if (
-                geoJsonProp in feature["properties"]
-                and feature["properties"][geoJsonProp] in geoJsonValue
-            ):
-                requested_geometries.append(feature["geometry"])
-
-        requested_geometry_types = {geometry["type"] for geometry in requested_geometries}
-        if requested_geometry_types.issubset({"Point", "MultiPoint"}):
-            return self.__serialize_geojson_points__(requested_geometries)
-        elif requested_geometry_types.issubset({"LineString", "MultiLineString"}):
-            return self.__serialize_geojson_lines__(requested_geometries)
-        elif requested_geometry_types.issubset({"Polygon", "MultiPolygon"}):
-            return self.__serialize_geojson_polygons__(requested_geometries)
-        else:
-            raise ValueError(
-                f"Requested geometries must be of similar type but got {requested_geometry_types}."
-            )
-
-    def __serialize_geojson_points__(
-        self, geometries: list[dict[str, str | list[float | int] | list[list[float | int]]]]
-    ):
-        """
-        Serializes the given GeoJSON-format geometries in this coordinate system to a dictionary of the proper format to be used under `mapFeatures.data.*.data.location`.
-
-        Arguments:
-
-        * **`geometries`**: `list[dict[str]]` → The GeoJSON geometries to serialize.
-            * ** Note **: Geometry types must be either `Point` or `MultiPoint`
-
-        Returns:
-
-        * `[dict]` → The serialized location structure.
-        """
-        point_coordinates = []
-        for geometry in geometries:
-            if geometry["type"] == "Point":
-                point_coordinates.append(geometry["coordinates"])
-            elif geometry["type"] == "MultiPoint":
-                for point_coordinate in geometry["coordinates"]:
-                    point_coordinates.append(point_coordinate)
-            else:
-                raise ValueError("Geometries must all have type Point or MultiPoint.")
-        return self.serialize_nodes(point_coordinates)
-
-    def __serialize_geojson_lines__(
-        self,
-        geometries: list[dict[str, str | list[list[float | int]] | list[list[list[float | int]]]]],
-    ):
-        """
-        Serializes the given GeoJSON-format geometries in this coordinate system to a dictionary of the proper format to be used under `mapFeatures.data.*.data.location`.
-
-        Arguments:
-
-        * **`geometries`**: `list[dict[str]]` → The GeoJSON geometries to serialize.
-            * ** Note **: Geometry types must be either `LineString` or `MultiLineString`
-
-        Returns:
-
-        * `[dict]` → The serialized location structure.
-        """
-        line_coordinates = []
-        for geometry in geometries:
-            if geometry["type"] == "LineString":
-                line_coordinates.append(geometry["coordinates"])
-            elif geometry["type"] == "MultiLineString":
-                for line_coordinate in geometry["coordinates"]:
-                    line_coordinates.append(line_coordinate)
-            else:
-                raise ValueError("Geometries must all have type LineString or MultiLineString.")
-        return self.serialize_arcs(line_coordinates)
-
-    def __serialize_geojson_polygons__(
-        self,
-        geometries: list[
-            dict[str, str | list[list[list[float | int]]] | list[list[list[list[float | int]]]]]
-        ],
-    ):
-        """
-        Serializes the given GeoJSON-format geometries in this coordinate system to a dictionary of the proper format to be used under `mapFeatures.data.*.data.location`.
-
-        Arguments:
-
-        * **`geometries`**: `list[dict[str]]` → The GeoJSON geometries to serialize.
-            * ** Notes **:
-                * Geometry types must be either `Polygon` or `MultiPolygon`
-                * Polygon holes are not fully supported; two separate polygons will be displayed instead.
-
-        Returns:
-
-        * `[dict]` → The serialized location structure.
-        """
-        polygon_coordinates = []
-        for geometry in geometries:
-            if geometry["type"] == "Polygon":
-                polygon_coordinates.extend(geometry["coordinates"])
-            elif geometry["type"] == "MultiPolygon":
-                for polygon_coordinate in geometry["coordinates"]:
-                    polygon_coordinates.extend(polygon_coordinate)
-            else:
-                raise ValueError("Geometries must all have type Polygon or MultiPolygon.")
-        return self.serialize_arcs(polygon_coordinates)
+            self.convert_coordinates(geojson_filepath["coordinates"])
+        with open(output_filepath, "w") as f:
+            json.dump(geojson_filepath, f)
+        print(f"GeoJSON converted and saved to {output_filepath}.")
 
     def __validate_coordinate_system__(self):
         """

{cave_utils-3.4.0b2 → cave_utils-3.4.2/cave_utils.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cave_utils
-Version: 3.4.0b2
+Version: 3.4.2
 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-3.4.0b2 → cave_utils-3.4.2}/pyproject.toml

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

{cave_utils-3.4.0b2 → cave_utils-3.4.2}/setup.cfg

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