geoservercloud 0.7.4.dev1__tar.gz → 0.7.4.dev4__tar.gz

{geoservercloud-0.7.4.dev1 → geoservercloud-0.7.4.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: geoservercloud
-Version: 0.7.4.dev1
+Version: 0.7.4.dev4
 Summary: Lightweight Python client to interact with GeoServer Cloud REST API, GeoServer ACL and OGC services
 License: BSD-2-Clause
 Author: Camptocamp

{geoservercloud-0.7.4.dev1 → geoservercloud-0.7.4.dev4}/geoservercloud/geoservercloud.py

@@ -434,6 +434,97 @@ class GeoServerCloud:
 
         return content, code
 
+    def create_pmtiles_datastore(
+        self,
+        workspace_name: str,
+        datastore_name: str,
+        pmtiles_url: str,
+        description: str | None = None,
+        range_reader_provider: str = "file",
+        caching_enabled: bool = True,
+        caching_block_aligned: bool = True,
+        http_timeout_millis: int = 5000,
+        http_trust_all_certificates: bool = False,
+        s3_use_default_credentials_provider: bool = False,
+        s3_force_path_style: bool = True,
+        gcs_default_credentials_chain: bool = False,
+    ) -> tuple[str, int]:
+        """
+        Create a PMTiles datastore, or update it if it already exists.
+
+        :param workspace_name: Name of the workspace
+        :type workspace_name: str
+        :param datastore_name: Name for the PMTiles datastore
+        :type datastore_name: str
+        :param pmtiles_url: URL or path to the PMTiles file
+        :type pmtiles_url: str
+        :param description: Optional description for the datastore
+        :type description: str, optional
+        :param range_reader_provider: Range reader provider type (default: "file")
+        :type range_reader_provider: str, optional
+        :param caching_enabled: Enable caching for range reader (default: True)
+        :type caching_enabled: bool, optional
+        :param caching_block_aligned: Enable block-aligned caching (default: True)
+        :type caching_block_aligned: bool, optional
+        :param http_timeout_millis: HTTP timeout in milliseconds (default: 5000)
+        :type http_timeout_millis: int, optional
+        :param http_trust_all_certificates: Trust all SSL certificates for HTTP (default: False)
+        :type http_trust_all_certificates: bool, optional
+        :param s3_use_default_credentials_provider: Use default AWS credentials provider for S3 (default: False)
+        :type s3_use_default_credentials_provider: bool, optional
+        :param s3_force_path_style: Force path-style access for S3 (default: True)
+        :type s3_force_path_style: bool, optional
+        :param gcs_default_credentials_chain: Use default credentials chain for Google Cloud Storage (default: False)
+        :type gcs_default_credentials_chain: bool, optional
+
+        :return: Tuple of (datastore_name, status_code)
+        :rtype: tuple
+
+        :Example:
+
+        >>> create_pmtiles_datastore(
+        ...     workspace_name="pmtiles_workspace",
+        ...     datastore_name="pmtiles_store",
+        ...     pmtiles_url="file:///mnt/pmtiles/mypmtilesfile.pmtiles",
+        ...     description="My PMTiles datastore",
+        ...     range_reader_provider="file",
+        ... )
+        """
+
+        datastore = DataStore(
+            workspace_name,
+            datastore_name,
+            connection_parameters={
+                "pmtiles": pmtiles_url,
+                "namespace": f"http://{workspace_name}",
+                "io.tileverse.rangereader.provider": range_reader_provider,
+                "io.tileverse.rangereader.caching.enabled": str(
+                    caching_enabled
+                ).lower(),
+                "io.tileverse.rangereader.caching.blockaligned": str(
+                    caching_block_aligned
+                ).lower(),
+                "io.tileverse.rangereader.http.timeout-millis": str(
+                    http_timeout_millis
+                ),
+                "io.tileverse.rangereader.http.trust-all-certificates": str(
+                    http_trust_all_certificates
+                ).lower(),
+                "io.tileverse.rangereader.s3.use-default-credentials-provider": str(
+                    s3_use_default_credentials_provider
+                ).lower(),
+                "io.tileverse.rangereader.s3.force-path-style": str(
+                    s3_force_path_style
+                ).lower(),
+                "io.tileverse.rangereader.gcs.default-credentials-chain": str(
+                    gcs_default_credentials_chain
+                ).lower(),
+            },
+            type="PMTiles",
+            description=description,
+        )
+        return self.rest_service.create_datastore(workspace_name, datastore)
+
     def get_wms_store(
         self, workspace_name: str, datastore_name: str
     ) -> tuple[dict[str, Any] | str, int]:
@@ -723,8 +814,8 @@ class GeoServerCloud:
         layer_name: str,
         workspace_name: str | None = None,
         datastore_name: str | None = None,
-        title: str | dict = "Default title",
-        abstract: str | dict = "Default abstract",
+        title: str | dict | None = None,
+        abstract: str | dict | None = None,
         attributes: dict | None = None,
         epsg: int = 4326,
         keywords: list[str] = [],
@@ -792,9 +883,10 @@ class GeoServerCloud:
         self,
         group: str,
         workspace_name: str | None,
-        layers: list[str],
-        title: str | dict,
-        abstract: str | dict,
+        layers: list[str] | None = None,
+        styles: list[str] | None = None,
+        title: str | dict | None = None,
+        abstract: str | dict | None = None,
         epsg: int = 4326,
         mode: str = "SINGLE",
         enabled: bool = True,
@@ -806,10 +898,15 @@ class GeoServerCloud:
         workspace_name = workspace_name or self.default_workspace
         if not workspace_name:
             raise ValueError("Workspace not provided")
-        if not mode in LayerGroup.modes:
+        if mode not in LayerGroup.modes:
             raise ValueError(
                 f"Invalid mode: {mode}, possible values are: {LayerGroup.modes}"
             )
+        if not layers and not styles:
+            raise ValueError(
+                "Either layers or styles must be provided for a layer group"
+            )
+
         bounds = {
             "minx": utils.EPSG_BBOX[epsg]["nativeBoundingBox"]["minx"],
             "maxx": utils.EPSG_BBOX[epsg]["nativeBoundingBox"]["maxx"],
@@ -817,13 +914,23 @@ class GeoServerCloud:
             "maxy": utils.EPSG_BBOX[epsg]["nativeBoundingBox"]["maxy"],
             "crs": f"EPSG:{epsg}",
         }
+
+        publishables = None
+        if layers:
+            publishables = [f"{workspace_name}:{layer}" for layer in layers]
+
+        formatted_styles = None
+        if styles:
+            formatted_styles = [f"{workspace_name}:{style}" for style in styles]
+
         layer_group = LayerGroup(
             name=group,
             mode=mode,
             workspace_name=workspace_name,
             title=title,
             abstract=abstract,
-            publishables=[f"{workspace_name}:{layer}" for layer in layers],
+            publishables=publishables,
+            styles=formatted_styles,
             bounds=bounds,
             enabled=enabled,
             advertised=advertised,
@@ -903,9 +1010,15 @@ class GeoServerCloud:
         style_name: str,
         filename: str,
         workspace_name: str | None = None,
+        format: str = "sld",
     ) -> tuple[str, int]:
         """Create a style definition"""
-        style = Style(name=style_name, filename=filename, workspace_name=workspace_name)
+        style = Style(
+            name=style_name,
+            filename=filename,
+            workspace_name=workspace_name,
+            format=format,
+        )
         return self.rest_service.create_style_definition(
             style_name=style_name, style=style, workspace_name=workspace_name
         )
@@ -932,21 +1045,31 @@ class GeoServerCloud:
         file: str,
         workspace_name: str | None = None,
     ) -> tuple[str, int]:
-        """Create a style (SLD) from a file, or update it if it already exists.
-        Supported file extensions are .sld and .zip."""
-        file_base_name = Path(file).name
-        file_ext = Path(file).suffix
-        content, code = self.create_style_definition(
-            style_name, f"{file_base_name}.sld", workspace_name
-        )
-        if code >= 400:
-            return content, code
+        """Create a style from a file, or update it if it already exists.
+        Supported file extensions are .sld, .zip and .mbstyle."""
+        file_ext = Path(file).suffix.lower()
         if file_ext == ".sld":
+            style_format = "sld"
+            style_definition_filename = f"{style_name}.sld"
             file_format = "sld"
         elif file_ext == ".zip":
+            style_format = "sld"
+            style_definition_filename = f"{style_name}.sld"
             file_format = "zip"
+        elif file_ext == ".mbstyle":
+            style_format = "mbstyle"
+            style_definition_filename = f"{style_name}.mbstyle"
+            file_format = "mbstyle"
         else:
             raise ValueError(f"Unsupported file extension: {file_ext}")
+        content, code = self.create_style_definition(
+            style_name,
+            style_definition_filename,
+            workspace_name,
+            format=style_format,
+        )
+        if code >= 400:
+            return content, code
         with open(f"{file}", "rb") as fs:
             style: bytes = fs.read()
         return self.rest_service.create_style(

{geoservercloud-0.7.4.dev1 → geoservercloud-0.7.4.dev4}/geoservercloud/models/layergroup.py

@@ -93,6 +93,10 @@ class LayerGroup(EntityModel):
                     {"@type": "layer", "name": p.name} for p in self.publishables
                 ]
             }
+        elif self.styles:
+            # Style group: empty publishables with styles
+            content["publishables"] = {"published": ""}
+
         if self.styles:
             content["styles"] = {"style": [s.asdict() for s in self.styles]}
         elif self.publishables:

{geoservercloud-0.7.4.dev1 → geoservercloud-0.7.4.dev4}/geoservercloud/services/restservice.py

@@ -603,6 +603,8 @@ class RestService:
             headers = {"Content-Type": "application/vnd.ogc.sld+xml"}
         elif format == "zip":
             headers = {"Content-Type": "application/zip"}
+        elif format == "mbstyle":
+            headers = {"Content-Type": "application/vnd.geoserver.mbstyle+json"}
         # Do not check for existence because GeoServer throws a 500 if the style definition exists and not
         # the SLD. Besides PUT is also supported on creation
         response: Response = self.rest_client.put(
@@ -915,7 +917,7 @@ class RestService:
                 url: str = f"{self.base_url}/styles/{style_name}"
             else:
                 url = f"{self.base_url}/workspaces/{workspace_name}/styles/{style_name}"
-            if format in ("json", "sld"):
+            if format in ("json", "sld", "mbstyle"):
                 return f"{url}.{format}"
             return url
 

{geoservercloud-0.7.4.dev1 → geoservercloud-0.7.4.dev4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "geoservercloud"
-version = "0.7.4.dev1"
+version = "0.7.4.dev4"
 description = "Lightweight Python client to interact with GeoServer Cloud REST API, GeoServer ACL and OGC services"
 authors = ["Camptocamp <info@camptocamp.com>"]
 license = "BSD-2-Clause"