cave-utils 3.2.0__tar.gz → 3.3.0__tar.gz

cave_utils-3.3.0/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: cave_utils
+Version: 3.3.0
+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
+Project-URL: Bug Tracker, https://github.com/mit-cave/cave_utils/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE.md
+Requires-Dist: pamda<3.0.0,>=2.7.0
+Requires-Dist: type_enforced<3.0.0,>=2.2.0
+Dynamic: license-file
+
+# Cave Utilities for the Cave App
+[![PyPI version](https://badge.fury.io/py/cave_utils.svg)](https://badge.fury.io/py/cave_utils)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+Basic utilities for the MIT Cave App.
+This package is intended to be used by the Cave App and the Cave API.
+
+## Overview
+
+This package is part of the larger [Cave App](https://github.com/MIT-CAVE/cave_app) framework. It provides utilities that are commonly used across different Cave applications, such as validation and logging. It is designed to be an easy to integrate library that can be used in any Cave application. It also serves to provide automated documentation and testing.
+
+You can find the low level documentation for this package [here](https://mit-cave.github.io/cave_utils/index.html).
+
+
+
+## Setup
+
+Make sure you have Python 3.11.x (or higher) installed on your system. You can download it [here](https://www.python.org/downloads/).
+
+### Installation
+
+```
+pip install cave_utils
+```
+
+# cave_utils development
+
+## Running Tests, Prettifying Code, and Updating Docs
+
+Make sure Docker is installed and running.
+
+- Create a docker container and drop into a shell
+    - `./run.sh`
+- Run all tests (see ./utils/test.sh)
+    - `./run.sh test`
+- Prettify the code (see ./utils/prettify.sh)
+    - `./run.sh prettify`
+- Update the docs (see ./utils/docs.sh)
+    - `./run.sh docs`
+
+- Note: You can and should modify the `Dockerfile` to test different python versions.
+
+### Using Local Hotloading With a Cave App
+
+1. In your `cave_app`, update the following file:
+
+    `utils/run_server.sh`
+    ```
+    #!/bin/bash
+
+    SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+    APP_DIR=$(dirname "$SCRIPT_DIR")
+
+    pip install -e /cave_utils
+
+    source ./utils/helpers/shell_functions.sh
+    source ./utils/helpers/ensure_postgres_running.sh
+    # Check if the app is functional before proceeding
+    if [ "$(python ./manage.py check --deployment_type development | grep "System check identified no issues" | wc -l)" -eq "0" ]; then
+    printf "Unable to start the app due to an error in the code. See the stacktrace above." 2>&1 | pipe_log "ERROR"
+    rm -r "./tmp"
+    exit 1
+    fi
+    source ./utils/helpers/ensure_db_setup.sh
+
+    python "$APP_DIR/manage.py" runserver 0.0.0.0:8000 2>&1 | pipe_log "INFO"
+    ```
+
+2. Remove `cave_utils` from the root `requirements.txt` file
+
+3. In your `cave_app`, set `LIVE_API_VALIDATION_PRINT=True` in the `.env` file
+    - This will validate your data every time an API command is called for each session
+
+4. Use the following command to run your `cave_app`:
+    `cave run --docker-args "--volume {local_path_to_cave_utils}/cave_utils:/cave_utils"`
+    - As you edit `cave_utils`, any changes will be hotloaded into your running `cave_app`
+
+### Using interactive mode in your Cave App and running tests
+
+- Note: This is for very specific use cases, such as running tests or debugging in an interactive shell.
+- Note: In general, we copy all included examples from the cave_app to the `cave_utils/test/api_examples` directory, so you can run tests against them without needing to run the cave_app.
+    - These copied examples can be tested by running `./run.sh test` in the cave_utils directory, which will run all tests in the `cave_utils/test`.
+        - This includes `test_validator.py` which runs all examples in the `cave_utils/test/api_examples` directory
+
+
+1. Run cave_app in interactive mode mounting cave_utils as a volume:
+    `cave run --docker-args "--volume {local_path_to_cave_utils}/cave_utils:/cave_utils" -it`
+2. Then install cave utils in the docker container:
+    `pip install -e /cave_utils`
+3. Then run some tests (eg `validate_all_examples.py`):
+    `python cave_api/tests/validate_all_examples.py`
+
+
+# Generate a New Release
+
+1. Make sure all tests are passing and the code is prettified.
+2. Make sure the documentation is up to date.
+3. Make sure the version number is updated in `setup.cfg` and `pyproject.toml`.
+4. Set up your virtual environment
+    - `python3 -m virtualenv venv`
+    - `source venv/bin/activate`
+    - `pip install -r requirements.txt`
+5. Update the release
+    - `source venv/bin/activate`
+    - `./publish.sh`

cave_utils-3.3.0/README.md

@@ -0,0 +1,104 @@
+# Cave Utilities for the Cave App
+[![PyPI version](https://badge.fury.io/py/cave_utils.svg)](https://badge.fury.io/py/cave_utils)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+Basic utilities for the MIT Cave App.
+This package is intended to be used by the Cave App and the Cave API.
+
+## Overview
+
+This package is part of the larger [Cave App](https://github.com/MIT-CAVE/cave_app) framework. It provides utilities that are commonly used across different Cave applications, such as validation and logging. It is designed to be an easy to integrate library that can be used in any Cave application. It also serves to provide automated documentation and testing.
+
+You can find the low level documentation for this package [here](https://mit-cave.github.io/cave_utils/index.html).
+
+
+
+## Setup
+
+Make sure you have Python 3.11.x (or higher) installed on your system. You can download it [here](https://www.python.org/downloads/).
+
+### Installation
+
+```
+pip install cave_utils
+```
+
+# cave_utils development
+
+## Running Tests, Prettifying Code, and Updating Docs
+
+Make sure Docker is installed and running.
+
+- Create a docker container and drop into a shell
+    - `./run.sh`
+- Run all tests (see ./utils/test.sh)
+    - `./run.sh test`
+- Prettify the code (see ./utils/prettify.sh)
+    - `./run.sh prettify`
+- Update the docs (see ./utils/docs.sh)
+    - `./run.sh docs`
+
+- Note: You can and should modify the `Dockerfile` to test different python versions.
+
+### Using Local Hotloading With a Cave App
+
+1. In your `cave_app`, update the following file:
+
+    `utils/run_server.sh`
+    ```
+    #!/bin/bash
+
+    SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+    APP_DIR=$(dirname "$SCRIPT_DIR")
+
+    pip install -e /cave_utils
+
+    source ./utils/helpers/shell_functions.sh
+    source ./utils/helpers/ensure_postgres_running.sh
+    # Check if the app is functional before proceeding
+    if [ "$(python ./manage.py check --deployment_type development | grep "System check identified no issues" | wc -l)" -eq "0" ]; then
+    printf "Unable to start the app due to an error in the code. See the stacktrace above." 2>&1 | pipe_log "ERROR"
+    rm -r "./tmp"
+    exit 1
+    fi
+    source ./utils/helpers/ensure_db_setup.sh
+
+    python "$APP_DIR/manage.py" runserver 0.0.0.0:8000 2>&1 | pipe_log "INFO"
+    ```
+
+2. Remove `cave_utils` from the root `requirements.txt` file
+
+3. In your `cave_app`, set `LIVE_API_VALIDATION_PRINT=True` in the `.env` file
+    - This will validate your data every time an API command is called for each session
+
+4. Use the following command to run your `cave_app`:
+    `cave run --docker-args "--volume {local_path_to_cave_utils}/cave_utils:/cave_utils"`
+    - As you edit `cave_utils`, any changes will be hotloaded into your running `cave_app`
+
+### Using interactive mode in your Cave App and running tests
+
+- Note: This is for very specific use cases, such as running tests or debugging in an interactive shell.
+- Note: In general, we copy all included examples from the cave_app to the `cave_utils/test/api_examples` directory, so you can run tests against them without needing to run the cave_app.
+    - These copied examples can be tested by running `./run.sh test` in the cave_utils directory, which will run all tests in the `cave_utils/test`.
+        - This includes `test_validator.py` which runs all examples in the `cave_utils/test/api_examples` directory
+
+
+1. Run cave_app in interactive mode mounting cave_utils as a volume:
+    `cave run --docker-args "--volume {local_path_to_cave_utils}/cave_utils:/cave_utils" -it`
+2. Then install cave utils in the docker container:
+    `pip install -e /cave_utils`
+3. Then run some tests (eg `validate_all_examples.py`):
+    `python cave_api/tests/validate_all_examples.py`
+
+
+# Generate a New Release
+
+1. Make sure all tests are passing and the code is prettified.
+2. Make sure the documentation is up to date.
+3. Make sure the version number is updated in `setup.cfg` and `pyproject.toml`.
+4. Set up your virtual environment
+    - `python3 -m virtualenv venv`
+    - `source venv/bin/activate`
+    - `pip install -r requirements.txt`
+5. Update the release
+    - `source venv/bin/activate`
+    - `./publish.sh`

cave_utils-3.3.0/cave_utils/__init__.py

@@ -0,0 +1,110 @@
+"""
+# Cave Utilities for the Cave App
+[![PyPI version](https://badge.fury.io/py/cave_utils.svg)](https://badge.fury.io/py/cave_utils)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+Basic utilities for the MIT Cave App.
+This package is intended to be used by the Cave App and the Cave API.
+
+## Overview
+
+This package is part of the larger [Cave App](https://github.com/MIT-CAVE/cave_app) framework. It provides utilities that are commonly used across different Cave applications, such as validation and logging. It is designed to be an easy to integrate library that can be used in any Cave application. It also serves to provide automated documentation and testing.
+
+You can find the low level documentation for this package [here](https://mit-cave.github.io/cave_utils/index.html).
+
+
+
+## Setup
+
+Make sure you have Python 3.11.x (or higher) installed on your system. You can download it [here](https://www.python.org/downloads/).
+
+### Installation
+
+```
+pip install cave_utils
+```
+
+# cave_utils development
+
+## Running Tests, Prettifying Code, and Updating Docs
+
+Make sure Docker is installed and running.
+
+- Create a docker container and drop into a shell
+    - `./run.sh`
+- Run all tests (see ./utils/test.sh)
+    - `./run.sh test`
+- Prettify the code (see ./utils/prettify.sh)
+    - `./run.sh prettify`
+- Update the docs (see ./utils/docs.sh)
+    - `./run.sh docs`
+
+- Note: You can and should modify the `Dockerfile` to test different python versions.
+
+### Using Local Hotloading With a Cave App
+
+1. In your `cave_app`, update the following file:
+
+    `utils/run_server.sh`
+    ```
+    #!/bin/bash
+
+    SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+    APP_DIR=$(dirname "$SCRIPT_DIR")
+
+    pip install -e /cave_utils
+
+    source ./utils/helpers/shell_functions.sh
+    source ./utils/helpers/ensure_postgres_running.sh
+    # Check if the app is functional before proceeding
+    if [ "$(python ./manage.py check --deployment_type development | grep "System check identified no issues" | wc -l)" -eq "0" ]; then
+    printf "Unable to start the app due to an error in the code. See the stacktrace above." 2>&1 | pipe_log "ERROR"
+    rm -r "./tmp"
+    exit 1
+    fi
+    source ./utils/helpers/ensure_db_setup.sh
+
+    python "$APP_DIR/manage.py" runserver 0.0.0.0:8000 2>&1 | pipe_log "INFO"
+    ```
+
+2. Remove `cave_utils` from the root `requirements.txt` file
+
+3. In your `cave_app`, set `LIVE_API_VALIDATION_PRINT=True` in the `.env` file
+    - This will validate your data every time an API command is called for each session
+
+4. Use the following command to run your `cave_app`:
+    `cave run --docker-args "--volume {local_path_to_cave_utils}/cave_utils:/cave_utils"`
+    - As you edit `cave_utils`, any changes will be hotloaded into your running `cave_app`
+
+### Using interactive mode in your Cave App and running tests
+
+- Note: This is for very specific use cases, such as running tests or debugging in an interactive shell.
+- Note: In general, we copy all included examples from the cave_app to the `cave_utils/test/api_examples` directory, so you can run tests against them without needing to run the cave_app.
+    - These copied examples can be tested by running `./run.sh test` in the cave_utils directory, which will run all tests in the `cave_utils/test`.
+        - This includes `test_validator.py` which runs all examples in the `cave_utils/test/api_examples` directory
+
+
+1. Run cave_app in interactive mode mounting cave_utils as a volume:
+    `cave run --docker-args "--volume {local_path_to_cave_utils}/cave_utils:/cave_utils" -it`
+2. Then install cave utils in the docker container:
+    `pip install -e /cave_utils`
+3. Then run some tests (eg `validate_all_examples.py`):
+    `python cave_api/tests/validate_all_examples.py`
+
+
+# Generate a New Release
+
+1. Make sure all tests are passing and the code is prettified.
+2. Make sure the documentation is up to date.
+3. Make sure the version number is updated in `setup.cfg` and `pyproject.toml`.
+4. Set up your virtual environment
+    - `python3 -m virtualenv venv`
+    - `source venv/bin/activate`
+    - `pip install -r requirements.txt`
+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
+from .arguments import Arguments
+from .geo_utils import GeoUtils

{cave_utils-3.2.0 → cave_utils-3.3.0}/cave_utils/api/__init__.py

@@ -36,7 +36,7 @@ class Root(ApiValidator):
     @staticmethod
     def spec(
         settings: dict,
-        appBar: dict,
+        appBar: dict = dict(),
         panes: dict = dict(),
         pages: dict = dict(),
         maps: dict = dict(),
@@ -52,8 +52,10 @@ class Root(ApiValidator):
         * **`settings`**: `[dict]` → General settings for your application.
             * **Note**: `settings.iconUrl` is the only required field in `settings`
             * **See**: `cave_utils.api.settings`
-        * **`appBar`**: `[dict]` → Configure actions for your app bar(s).
-            * **Note**: `appBar.data` is required and should have at least one item in it.
+        * **`appBar`**: `[dict]` = `None` → Configure actions for your app bar(s).
+            * **Notes**:
+                * If left unspecified, there will be no action elements on the app bar.
+                * Otherwise, `appBar.data` is required and should have at least one item in it.
             * **See**: `cave_utils.api.appBar`
         * **`panes`**: `[dict]` = `{}` → Configure panes for your application.
             * **See**: `cave_utils.api.panes`

{cave_utils-3.2.0 → cave_utils-3.3.0}/cave_utils/api/appBar.py

@@ -51,10 +51,10 @@ class appBar_data_star(ApiValidator):
         icon: str,
         type: str,
         bar: str,
-        variant: [str, None] = None,
-        color: [str, None] = None,
-        apiCommand: [str, None] = None,
-        apiCommandKeys: [list[str], None] = None,
+        variant: str | None = None,
+        color: str | None = None,
+        apiCommand: str | None = None,
+        apiCommandKeys: list[str] | None = None,
         **kwargs,
     ):
         """

{cave_utils-3.2.0 → cave_utils-3.3.0}/cave_utils/api/globalOutputs.py

@@ -15,7 +15,7 @@ class globalOutputs(ApiValidator):
     """
 
     @staticmethod
-    def spec(props: dict, values: [dict, None] = None, layout: [dict, None] = None, **kwargs):
+    def spec(props: dict, values: dict | None = None, layout: dict | None = None, **kwargs):
         """
         Arguments:
 

{cave_utils-3.2.0 → cave_utils-3.3.0}/cave_utils/api/groupedOutputs.py

@@ -121,12 +121,12 @@ class groupedOutputs_data_star_stats(ApiValidator):
     @staticmethod
     def spec(
         name: str,
-        unit: [str, None] = None,
-        unitPlacement: [str, None] = None,
-        precision: [int, None] = None,
-        trailingZeros: [bool, None] = None,
-        notation: [str, None] = None,
-        notationDisplay: [str, None] = None,
+        unit: str | None = None,
+        unitPlacement: str | None = None,
+        precision: int | None = None,
+        trailingZeros: bool | None = None,
+        notation: str | None = None,
+        notationDisplay: str | None = None,
         **kwargs,
     ):
         """
@@ -150,7 +150,7 @@ class groupedOutputs_data_star_stats(ApiValidator):
             * **Notes**:
                 * This ensures that all precision digits are shown. For example: `1.5` → `1.500` when precision is `3`.
                 * If left unspecified (i.e., `None`), it will default to `settings.defaults.trailingZeros`.
-        * **`notation`**: `[int]` = `"standard"` → The formatting style of a numeric value.
+        * **`notation`**: `[str]` = `"standard"` → The formatting style of a numeric value.
         * **`notationDisplay`**: `[str]` = `"e+"` | `"short"` | `None` → Further customize the formatting within the selected `notation`.
             * **Notes**:
                 * No `notationDisplay` option is provided for a `"standard"` notation
@@ -266,7 +266,7 @@ class groupedOutputs_groupings_star(ApiValidator):
         data: dict,
         name: str,
         layoutDirection: str = "vertical",
-        grouping: [str, None] = None,
+        grouping: str | None = None,
         **kwargs,
     ):
         """
@@ -374,10 +374,10 @@ class groupedOutputs_groupings_star_levels_star(ApiValidator):
     @staticmethod
     def spec(
         name: str,
-        parent: [str, None] = None,
-        ordering: [list, None] = None,
+        parent: str | None = None,
+        ordering: list | None = None,
         orderWithParent: bool = True,
-        coloring: [dict, None] = None,
+        coloring: dict | None = None,
         **kwargs,
     ):
         """

{cave_utils-3.2.0 → cave_utils-3.3.0}/cave_utils/api/mapFeatures.py

@@ -46,8 +46,8 @@ class mapFeatures_data_star(ApiValidator):
         name: str,
         props: dict,
         data: dict,
-        layout: [dict, None] = None,
-        geoJson: [dict, None] = None,
+        layout: dict | None = None,
+        geoJson: dict | None = None,
         **kwargs,
     ):
         """
@@ -165,28 +165,28 @@ class mapFeatures_data_star_data_location(ApiValidator):
 
     @staticmethod
     def spec(
-        latitude: [list[list[float, int]], None] = None,
-        longitude: [list[list[float, int]], None] = None,
-        altitude: [list[list[float, int]], None] = None,
-        path: [list[list[list[float, int]]], None] = None,
-        geoJsonValue: [list[str], None] = None,
+        latitude: list[list[float | int]] | None = None,
+        longitude: list[list[float | int]] | None = None,
+        altitude: list[list[float | int]] | None = None,
+        path: list[list[list[float | int]]] | None = None,
+        geoJsonValue: list[str] | None = None,
         **kwargs,
     ):
         """
         Arguments:
 
-        * **`latitude`**: `list[list[float, int]]` = `None` → A list of latitudes for each node.
+        * **`latitude`**: `list[list[float | int]]` = `None` → A list of latitudes for each node.
             * ** Example **: `[45.34, 46.27, 47.34, 48.34]`
             * ** Notes **: Used for `node` layers
-        * **`longitude`**: `list[list[float, int]]` = `None` → A list of longitudes for each node.
+        * **`longitude`**: `list[list[float | int]]` = `None` → A list of longitudes for each node.
             * ** Example **: `[120.34, 121.27, 122.34, 123.34]`
             * ** Note **: Used for `node` layers
-        * **`altitude`**: `list[list[float, int]]` = `None` → The altitude for each node / geo in kilometers.
+        * **`altitude`**: `list[list[float | int]]` = `None` → The altitude for each node / geo in kilometers.
             * ** Example **: `[0, 1000, 2000, 3000]`
             * ** Notes **:
                 * Used for `node` and `geo` layers
                 * This is currently ignored but is planned to be supported in the future.
-        * **`path`**: `list[list[list[float, int]]]` = `None` → A path for each arc in the format `[[long1,lat1,(optional alt1)],[long2,lat2,(optional alt2)],...]`.
+        * **`path`**: `list[list[list[float | int]]]` = `None` → A path for each arc in the format `[[long1,lat1,(optional alt1)],[long2,lat2,(optional alt2)],...]`.
             * ** Example **: `[[[0,0],[1,1]],[[2,2],[3,3],[4,4],[5,5]]]`
             * ** Example with Altitude **: `[[[0,0,0],[1,1,1000]],[[2,2,2000],[3,3,3000],[4,4,4000],[5,5,5000]]]`
             * ** Note **: Used for `arc` layers

{cave_utils-3.2.0 → cave_utils-3.3.0}/cave_utils/api/maps.py

@@ -62,9 +62,12 @@ class maps_additionalMapStyles_star(ApiValidator):
     @staticmethod
     def spec(
         name: str,
-        spec: [dict, str],
-        fog: [dict, None] = None,
+        spec: dict | str,
+        fog: dict | None = None,
         icon: str = "md/MdMap",
+        mapbox: bool = False,
+        light: bool = False,
+        sky: dict | None = None,
         **kwargs,
     ):
         """
@@ -81,8 +84,20 @@ class maps_additionalMapStyles_star(ApiValidator):
                 * Carto: https://github.com/CartoDB/basemap-styles/blob/master/docs/basemap_styles.json
                 * Raster: https://docs.mapbox.com/mapbox-gl-js/example/map-tiles/
         * **`fog`**: `[dict]` = `None` → The fog to show in the map selection menu.
-            * **Note**: `fog` is only validated for its type (`dict`).
-            * **See**: https://docs.mapbox.com/mapbox-gl-js/api/map/#map#setfog
+            * **Notes**:
+                * `fog` is only validated for its type (`dict`).
+                * This is only used for when Mapbox is rendering the map.
+                * When not using Mapbox, use the `sky` property instead.
+                * **See**: https://docs.mapbox.com/mapbox-gl-js/api/map/#map#setfog
+        * **`mapbox`**: `[bool]` = `False` → Enforces Mapbox rendering engine for this map style, even if using non-Mapbox tile sources.
+        * **`light`**: `[bool]` = `False` → Enforces a light theme for map properties, root styling, and controls to improve visualization on light maps.
+        * **`sky`**: `[dict | None]` = `None` → The sky settings for the map style.
+            * **Notes**:
+                * This is only used for when Mapbox is not rendering the map. This allows for sky rendering when using maplibre globe rendering.
+                * When using Mapbox, use the `fog` property instead.
+                * `sky` is only validated for its type `dict` and not its contents.
+                * **See**: https://maplibre.org/maplibre-style-spec/sky/
+
         """
         return {"kwargs": kwargs, "accepted_values": {}}
 
@@ -101,15 +116,15 @@ class maps_data_star(ApiValidator):
     @staticmethod
     def spec(
         name: str,
-        currentStyle: [str, None] = None,
-        currentProjection: [str, None] = None,
-        defaultViewport: [dict, None] = None,
-        optionalViewports: [dict, None] = None,
-        legendGroups: [dict, None] = None,
-        legendView: [str, None] = None,
-        showLegendGroupNames: [bool, None] = None,
-        legendLayout: [str, None] = None,
-        legendWidth: [str, None] = None,
+        currentStyle: str | None = None,
+        currentProjection: str | None = None,
+        defaultViewport: dict | None = None,
+        optionalViewports: dict | None = None,
+        legendGroups: dict | None = None,
+        legendView: str | None = None,
+        showLegendGroupNames: bool | None = None,
+        legendLayout: str | None = None,
+        legendWidth: str | None = None,
         **kwargs,
     ):
         """
@@ -197,15 +212,15 @@ class viewport(ApiValidator):
 
     @staticmethod
     def spec(
-        latitude: [int, float],
-        longitude: [int, float],
-        zoom: [int, float],
-        bearing: [int, float, None] = None,
-        pitch: [int, float, None] = None,
-        maxZoom: [int, float, None] = None,
-        minZoom: [int, float, None] = None,
-        icon: [str, None] = None,
-        name: [str, None] = None,
+        latitude: int | float,
+        longitude: int | float,
+        zoom: int | float,
+        bearing: int | float | None = None,
+        pitch: int | float | None = None,
+        maxZoom: int | float | None = None,
+        minZoom: int | float | None = None,
+        icon: str | None = None,
+        name: str | None = None,
         **kwargs,
     ):
         """
@@ -304,18 +319,18 @@ class maps_data_star_legendGroups_star_data_star(ApiValidator):
     @staticmethod
     def spec(
         value: bool,
-        sizeBy: [str, None] = None,
-        colorBy: [str, None] = None,
-        lineStyle: [str, None] = None,
+        sizeBy: str | None = None,
+        colorBy: str | None = None,
+        lineStyle: str | None = None,
         allowGrouping: bool = False,
-        group: [bool, None] = False,
-        groupCalcBySize: [str, None] = None,
-        groupCalcByColor: [str, None] = None,
+        group: bool | None = False,
+        groupCalcBySize: str | None = None,
+        groupCalcByColor: str | None = None,
         groupScaleWithZoom: bool = False,
-        groupScale: [int, float, None] = None,
-        colorByOptions: [list, None] = None,
-        sizeByOptions: [list, None] = None,
-        icon: [str, None] = None,
+        groupScale: int | float | None = None,
+        colorByOptions: list | None = None,
+        sizeByOptions: list | None = None,
+        icon: str | None = None,
         **kwargs,
     ):
         """