Issue #294 blacken code snippets in docs

cherry-picked improvements from  running blacken-docs tool
on docs with

    git ls-files -z -- '*.rst' | xargs -0 blacken-docs`

Author: soxofaan

docs/basics.rst

@@ -126,8 +126,8 @@ We load an initial small spatio-temporal slice (a data cube) as follows:
     sentinel2_cube = connection.load_collection(
         "SENTINEL2_L2A",
         spatial_extent={"west": 5.14, "south": 51.17, "east": 5.17, "north": 51.19},
-        temporal_extent = ["2021-02-01", "2021-04-30"],
-        bands=["B02", "B04", "B08"]
+        temporal_extent=["2021-02-01", "2021-04-30"],
+        bands=["B02", "B04", "B08"],
     )
 
 Note how we specify a the region of interest, a time range and a set of bands to load.
@@ -279,8 +279,8 @@ First, we load a new ``SENTINEL2_L2A`` based data cube with this specific ``SCL`
     s2_scl = connection.load_collection(
         "SENTINEL2_L2A",
         spatial_extent={"west": 5.14, "south": 51.17, "east": 5.17, "north": 51.19},
-        temporal_extent = ["2021-02-01", "2021-04-30"],
-        bands=["SCL"]
+        temporal_extent=["2021-02-01", "2021-04-30"],
+        bands=["SCL"],
     )
 
 Now we can use the compact "band math" feature again to build a
@@ -362,7 +362,7 @@ Building on the experience from previous sections, we first build a masked EVI c
     sentinel2_cube = connection.load_collection(
         "SENTINEL2_L2A",
         spatial_extent={"west": 5.14, "south": 51.17, "east": 5.17, "north": 51.19},
-        temporal_extent = ["2020-01-01", "2021-12-31"],
+        temporal_extent=["2020-01-01", "2021-12-31"],
         bands=["B02", "B04", "B08", "SCL"],
     )
 
@@ -413,6 +413,7 @@ which we massage a bit more:
     from openeo.rest.conversions import timeseries_json_to_pandas
 
     import json
+
     with open("evi-aggregation.json") as f:
         data = json.load(f)
 

docs/cookbook/job_manager.rst

@@ -77,9 +77,11 @@ Basic usage example with a remote process definition:
 
     # Initialize job database from a dataframe,
     # with desired parameter values to fill in.
-    df = pd.DataFrame({
-        "start_date": ["2021-01-01", "2021-02-01", "2021-03-01"],
-    })
+    df = pd.DataFrame(
+        {
+            "start_date": ["2021-01-01", "2021-02-01", "2021-03-01"],
+        }
+    )
     job_db = create_job_db("jobs.csv").initialize_from_df(df)
 
     # Create and run job manager,

docs/cookbook/localprocessing.rst

@@ -48,11 +48,12 @@ The following code snippet loads Sentinel-2 L2A data from a public STAC Catalog,
     >>> temporal_extent = ["2019-01-01", "2019-06-15"]
     >>> bands = ["red"]
     >>> properties = {"eo:cloud_cover": dict(lt=50)}
-    >>> s2_cube = local_conn.load_stac(url=url,
-    ...    spatial_extent=spatial_extent,
-    ...    temporal_extent=temporal_extent,
-    ...    bands=bands,
-    ...    properties=properties,
+    >>> s2_cube = local_conn.load_stac(
+    ...     url=url,
+    ...     spatial_extent=spatial_extent,
+    ...     temporal_extent=temporal_extent,
+    ...     bands=bands,
+    ...     properties=properties,
     ... )
     >>> s2_cube.execute()
     <xarray.DataArray 'stackstac-08730b1b5458a4ed34edeee60ac79254' (time: 177,
@@ -94,6 +95,7 @@ With some sample data we can now check the STAC metadata for the local files by
 .. code:: python
 
    from openeo.local import LocalConnection
+
    local_data_folders = [
        "./openeo-localprocessing-data/sample_netcdf",
        "./openeo-localprocessing-data/sample_geotiff",
@@ -162,10 +164,11 @@ We can perform the same example using data provided by STAC Collection:
 .. code:: python
 
     from openeo.local import LocalConnection
+
     local_conn = LocalConnection("./")
 
     url = "https://earth-search.aws.element84.com/v1/collections/sentinel-2-l2a"
-    spatial_extent =  {"east": 11.40, "north": 46.52, "south": 46.46, "west": 11.25}
+    spatial_extent = {"east": 11.40, "north": 46.52, "south": 46.46, "west": 11.25}
     temporal_extent = ["2022-06-01", "2022-06-30"]
     bands = ["red", "nir"]
     properties = {"eo:cloud_cover": dict(lt=80)}

docs/cookbook/tricks.rst

@@ -69,11 +69,13 @@ For example:
 .. code-block:: python
 
     # `execute` with raw JSON string
-    connection.execute("""
+    connection.execute(
+        """
         {
             "add": {"process_id": "add", "arguments": {"x": 3, "y": 5}, "result": true}
         }
-    """)
+    """
+    )
 
     # `download` with local path to JSON file
     connection.download("path/to/my-process-graph.json")
@@ -99,7 +101,7 @@ where you could pass a *backend-side* path as ``geometries``, e.g.:
 
     cube = cube.aggregate_spatial(
         geometries="/backend/path/to/geometries.json",
-        reducer="mean"
+        reducer="mean",
     )
 
 The client would handle this by automatically adding a ``read_vector`` process
@@ -124,7 +126,7 @@ for example as follows:
 
     cube = cube.aggregate_spatial(
         geometries=process("read_vector", filename="/backend/path/to/geometries.json"),
-        reducer="mean"
+        reducer="mean",
     )
 
 Note that this is also works with older versions of the openEO Python client library.

docs/data_access.rst

@@ -274,7 +274,7 @@ For example, to filter on the relative orbit number of SAR data:
         "SENTINEL1_GRD",
         ...,
         properties={
-            "relativeOrbitNumber": lambda x: x==116
+            "relativeOrbitNumber": lambda x: x == 116,
         },
     )
 

docs/federation-extension.rst

@@ -37,6 +37,7 @@ using :py:meth:`OpenEoCapabilities.ext_federation_backend_details() <openeo.rest
 .. code-block:: python
 
     import openeo
+
     connection = openeo.connect(url=...)
     capabilities = connection.capabilities()
     print("Federated backends:", capabilities.ext_federation_backend_details())
@@ -57,6 +58,7 @@ and can be inspected as follows:
 .. code-block:: python
 
     import openeo
+
     connection = openeo.connect(url=...)
     collections = connection.list_collections()
     print("Number of collections:", len(collections))

docs/udf.rst

@@ -28,13 +28,15 @@ using the openEO Python Client library:
     import openeo
 
     # Build a UDF object from an inline string with Python source code.
-    udf = openeo.UDF("""
-    import xarray
+    udf = openeo.UDF(
+        """
+        import xarray
 
-    def apply_datacube(cube: xarray.DataArray, context: dict) -> xarray.DataArray:
-        cube.values = 0.0001 * cube.values
-        return cube
-    """)
+        def apply_datacube(cube: xarray.DataArray, context: dict) -> xarray.DataArray:
+            cube.values = 0.0001 * cube.values
+            return cube
+        """
+    )
 
     # Or load the UDF code from a separate file.
     # udf = openeo.UDF.from_file("udf-code.py")
@@ -173,7 +175,7 @@ In most of the examples here, we will start from an initial Sentinel2 data cube
         "SENTINEL2_L2A",
         spatial_extent={"west": 4.00, "south": 51.04, "east": 4.10, "north": 51.1},
         temporal_extent=["2022-03-01", "2022-03-31"],
-        bands=["B02", "B03", "B04"]
+        bands=["B02", "B03", "B04"],
     )
 
 
@@ -203,6 +205,7 @@ The UDF code is this short script (the part that does the actual value rescaling
 
     import xarray
 
+
     def apply_datacube(cube: xarray.DataArray, context: dict) -> xarray.DataArray:
         cube.values = 0.0001 * cube.values
         return cube
@@ -244,17 +247,19 @@ The UDF-specific part is highlighted.
         "SENTINEL2_L2A",
         spatial_extent={"west": 4.00, "south": 51.04, "east": 4.10, "north": 51.1},
         temporal_extent=["2022-03-01", "2022-03-31"],
-        bands=["B02", "B03", "B04"]
+        bands=["B02", "B03", "B04"],
     )
 
     # Create a UDF object from inline source code.
-    udf = openeo.UDF("""
-    import xarray
+    udf = openeo.UDF(
+        """
+        import xarray
 
-    def apply_datacube(cube: xarray.DataArray, context: dict) -> xarray.DataArray:
-        cube.values = 0.0001 * cube.values
-        return cube
-    """)
+        def apply_datacube(cube: xarray.DataArray, context: dict) -> xarray.DataArray:
+            cube.values = 0.0001 * cube.values
+            return cube
+        """
+    )
 
     # Pass UDF object as child process to `apply`.
     rescaled = s2_cube.apply(process=udf)
@@ -309,13 +314,15 @@ To invoke a UDF like this, the apply_neighborhood method is most suitable:
 
 .. code-block:: python
 
-    udf_code = Path('udf_modify_spatial.py').read_text()
+    udf_code = Path("udf_modify_spatial.py").read_text()
     cube_updated = cube.apply_neighborhood(
-        lambda data: data.run_udf(udf=udf_code, runtime='Python-Jep', context=dict()),
+        lambda data: data.run_udf(udf=udf_code, runtime="Python-Jep", context=dict()),
         size=[
-            {'dimension': 'x', 'value': 128, 'unit': 'px'},
-            {'dimension': 'y', 'value': 128, 'unit': 'px'}
-        ], overlap=[])
+            {"dimension": "x", "value": 128, "unit": "px"},
+            {"dimension": "y", "value": 128, "unit": "px"},
+        ],
+        overlap=[],
+    )
 
 
 
@@ -350,13 +357,17 @@ the datacube.
 
 .. code-block:: python
 
-    output_cube = inputs_cube.apply_neighborhood(my_udf, size=[
-            {'dimension': 'x', 'value': 112, 'unit': 'px'},
-            {'dimension': 'y', 'value': 112, 'unit': 'px'}
-        ], overlap=[
-            {'dimension': 'x', 'value': 8, 'unit': 'px'},
-            {'dimension': 'y', 'value': 8, 'unit': 'px'}
-        ])
+    output_cube = inputs_cube.apply_neighborhood(
+        my_udf,
+        size=[
+            {"dimension": "x", "value": 112, "unit": "px"},
+            {"dimension": "y", "value": 112, "unit": "px"},
+        ],
+        overlap=[
+            {"dimension": "x", "value": 8, "unit": "px"},
+            {"dimension": "y", "value": 8, "unit": "px"},
+        ],
+    )
 
 
 
@@ -396,7 +407,7 @@ and apply it along a dimension:
 
 .. code-block:: python
 
-    smoothing_udf = openeo.UDF.from_file('smooth_savitzky_golay.py')
+    smoothing_udf = openeo.UDF.from_file("smooth_savitzky_golay.py")
     smoothed_evi = evi_cube_masked.apply_dimension(smoothing_udf, dimension="t")
 
 
@@ -630,6 +641,7 @@ For example: to discover the shape of the data cube chunk that you receive in yo
     from openeo.udf import inspect
     import xarray
 
+
     def apply_datacube(cube: xarray.DataArray, context: dict) -> xarray.DataArray:
         inspect(data=[cube.shape], message="UDF logging shape of my cube")
         cube.values = 0.0001 * cube.values

docs/udp.rst

@@ -474,12 +474,12 @@ building, storing, and finally executing the UDP.
         name="temporal_extent",
         description="The date range to calculate the EVI for.",
         schema={"type": "array", "subtype": "temporal-interval"},
-        default =["2018-06-15", "2018-06-27"]
+        default=["2018-06-15", "2018-06-27"],
     )
     geometry = Parameter(
         name="geometry",
         description="The geometry (a single (multi)polygon or a feature collection of (multi)polygons) of to calculate the EVI for.",
-        schema={"type": "object", "subtype": "geojson"}
+        schema={"type": "object", "subtype": "geojson"},
     )
 
     # Load raw SENTINEL2_L2A data