geoservercloud 0.2.3.dev3__tar.gz → 0.2.4.dev2__tar.gz

{geoservercloud-0.2.3.dev3 → geoservercloud-0.2.4.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: geoservercloud
-Version: 0.2.3.dev3
+Version: 0.2.4.dev2
 Summary: Lightweight Python client to interact with GeoServer Cloud REST API, GeoServer ACL and OGC services
 License: BSD-2-Clause
 Author: Camptocamp

{geoservercloud-0.2.3.dev3 → geoservercloud-0.2.4.dev2}/geoservercloud/geoservercloud.py

@@ -1,4 +1,5 @@
 import os.path
+from json import JSONDecodeError
 from pathlib import Path
 from typing import Any
 
@@ -92,6 +93,9 @@ class GeoServerCloud:
         return response
 
     def delete_workspace(self, workspace: str) -> Response:
+        """
+        Delete a GeoServer workspace (recursively)
+        """
         path: str = f"/rest/workspaces/{workspace}.json?recurse=true"
         response: Response = self.delete_request(path)
         if self.default_workspace == workspace:
@@ -112,6 +116,9 @@ class GeoServerCloud:
         )
 
     def publish_workspace(self, workspace) -> Response:
+        """
+        Publish the WMS service for a given workspace
+        """
         path: str = f"{self.workspace_wms_settings_path(workspace)}"
 
         data: dict[str, dict[str, Any]] = Templates.workspace_wms(workspace)
@@ -120,6 +127,9 @@ class GeoServerCloud:
     def set_default_locale_for_service(
         self, workspace: str, locale: str | None
     ) -> Response:
+        """
+        Set a default language for localized WMS requests
+        """
         path: str = self.workspace_wms_settings_path(workspace)
         data: dict[str, dict[str, Any]] = {
             "wms": {
@@ -129,6 +139,9 @@ class GeoServerCloud:
         return self.put_request(path, json=data)
 
     def unset_default_locale_for_service(self, workspace) -> None:
+        """
+        Remove the default language for localized WMS requests
+        """
         self.set_default_locale_for_service(workspace, None)
 
     def create_pg_datastore(
@@ -447,6 +460,9 @@ class GeoServerCloud:
         styles: list[str] | None = None,
         language: str | None = None,
     ) -> ResponseWrapper | None:
+        """
+        WMS GetMap request
+        """
         if not self.wms:
             self.create_wms()
         params: dict[str, Any] = {
@@ -478,6 +494,9 @@ class GeoServerCloud:
         styles: list[str] | None = None,
         xy: list[float] = [0, 0],
     ) -> ResponseWrapper | None:
+        """
+        WMS GetFeatureInfo request
+        """
         if not self.wms:
             self.create_wms()
         params = {
@@ -504,6 +523,9 @@ class GeoServerCloud:
         style: str | None = None,
         workspace: str | None = None,
     ) -> Response:
+        """
+        WMS GetLegendGraphic request
+        """
         path: str
         if not workspace:
             path = "/wms"
@@ -526,6 +548,9 @@ class GeoServerCloud:
     def get_tile(
         self, layer, format, tile_matrix_set, tile_matrix, row, column
     ) -> ResponseWrapper | None:
+        """
+        WMTS GetTile request
+        """
         if not self.wmts:
             self.create_wmts()
         if self.wmts:
@@ -539,18 +564,108 @@ class GeoServerCloud:
             )
         return None
 
+    def get_feature(
+        self,
+        workspace: str,
+        type_name: str,
+        feature_id: int | None = None,
+        max_feature: int | None = None,
+        format: str = "application/json",
+    ) -> dict[str, Any] | bytes:
+        """WFS GetFeature request
+        Return the feature(s) as dict if found, otherwise return the raw response content as bytes
+        """
+        path = f"/{workspace}/wfs"
+        params = {
+            "service": "WFS",
+            "version": "1.1.0",
+            "request": "GetFeature",
+            "typeName": type_name,
+            "outputFormat": format,
+        }
+        if feature_id:
+            params["featureID"] = str(feature_id)
+        if max_feature:
+            params["maxFeatures"] = str(max_feature)
+        response = self.get_request(path, params=params)
+        try:
+            return response.json()
+        except JSONDecodeError:
+            return response.content
+
+    def describe_feature_type(
+        self,
+        workspace: str,
+        type_name: str | None = None,
+        format: str = "application/json",
+    ) -> dict[str, Any] | bytes:
+        """WFS DescribeFeatureType request
+        Return the feature type(s) as dict if found, otherwise return the raw response content as bytes
+        """
+        path = f"/{workspace}/wfs"
+        params = {
+            "service": "WFS",
+            "version": "1.1.0",
+            "request": "DescribeFeatureType",
+            "outputFormat": format,
+        }
+        if type_name:
+            params["typeName"] = type_name
+        response = self.get_request(path, params=params)
+        try:
+            return response.json()
+        except JSONDecodeError:
+            return response.content
+
+    def get_property_value(
+        self,
+        workspace: str,
+        type_name: str,
+        property: str,
+    ) -> dict | list | bytes:
+        """WFS GetPropertyValue request
+        Return the properties as dict (if one feature was found), a list (if multiple features were found)
+        or an empty dict if no feature was found. Otherwise throw a requests.exceptions.HTTPError
+        """
+        path = f"/{workspace}/wfs"
+        params = {
+            "service": "WFS",
+            "version": "2.0.0",
+            "request": "GetPropertyValue",
+            "typeNames": type_name,
+            "valueReference": property,
+        }
+        response = self.get_request(path, params=params)
+        value_collection = xmltodict.parse(response.content).get("wfs:ValueCollection")
+        if not value_collection:
+            return response.content
+        else:
+            return value_collection.get("wfs:member", {})
+
     def create_role(self, role_name: str) -> Response:
+        """
+        Create a GeoServer role
+        """
         return self.post_request(f"/rest/security/roles/role/{role_name}")
 
     def delete_role(self, role_name: str) -> Response:
+        """
+        Delete a GeoServer role
+        """
         return self.delete_request(f"/rest/security/roles/role/{role_name}")
 
     def create_role_if_not_exists(self, role_name: str) -> Response | None:
+        """
+        Create a GeoServer role if it does not yet exist
+        """
         if self.role_exists(role_name):
             return None
         return self.create_role(role_name)
 
     def role_exists(self, role_name: str) -> bool:
+        """
+        Check if a GeoServer role exists
+        """
         response = self.get_request(
             f"/rest/security/roles", headers={"Accept": "application/json"}
         )
@@ -565,6 +680,9 @@ class GeoServerCloud:
         user: str | None = None,
         workspace: str | None = None,
     ) -> Response:
+        """
+        Create a GeoServer ACL admin rule
+        """
         path = "/acl/api/adminrules"
         return self.post_request(
             path,
@@ -578,44 +696,101 @@ class GeoServerCloud:
         )
 
     def delete_acl_admin_rule(self, id: int) -> Response:
+        """
+        Delete a GeoServer ACL admin rule by id
+        """
         path = f"/acl/api/adminrules/id/{id}"
         return self.delete_request(path)
 
     def delete_all_acl_admin_rules(self) -> Response:
+        """
+        Delete all existing GeoServer ACL admin rules
+        """
         path = "/acl/api/adminrules"
         return self.delete_request(path)
 
+    def get_acl_rules(self) -> dict[str, Any]:
+        """
+        Return all GeoServer ACL data rules
+        """
+        path = "/acl/api/rules"
+        response = self.get_request(path)
+        return response.json()
+
+    def create_acl_rules_for_requests(
+        self,
+        requests: list[str],
+        priority: int = 0,
+        access: str = "DENY",
+        role: str | None = None,
+        service: str | None = None,
+        workspace: str | None = None,
+    ) -> list[Response]:
+        """
+        Create ACL rules for multiple type of OGC requests
+        """
+        responses = []
+        for request in requests:
+            responses.append(
+                self.create_acl_rule(
+                    priority=priority,
+                    access=access,
+                    role=role,
+                    request=request,
+                    service=service,
+                    workspace=workspace,
+                )
+            )
+        return responses
+
     def create_acl_rule(
         self,
         priority: int = 0,
         access: str = "DENY",
         role: str | None = None,
+        user: str | None = None,
         service: str | None = None,
+        request: str | None = None,
         workspace: str | None = None,
     ) -> Response:
+        """
+        Create a GeoServer ACL data rule
+        """
         path = "/acl/api/rules"
-        return self.post_request(
-            path,
-            json={
-                "priority": priority,
-                "access": access,
-                "role": role,
-                "service": service,
-                "workspace": workspace,
-            },
-        )
+        json = {"priority": priority, "access": access}
+        if role:
+            json["role"] = role
+        if user:
+            json["user"] = user
+        if service:
+            json["service"] = service
+        if request:
+            json["request"] = request
+        if workspace:
+            json["workspace"] = workspace
+        return self.post_request(path, json=json)
 
     def delete_all_acl_rules(self) -> Response:
+        """
+        Delete all existing GeoServer ACL data rules
+        """
         path = "/acl/api/rules"
         return self.delete_request(path)
 
     def create_or_update_resource(self, path, resource_path, payload) -> Response:
+        """
+        Create a GeoServer resource or update it if it already exists
+        """
         if not self.resource_exists(resource_path):
             return self.post_request(path, json=payload)
         else:
             return self.put_request(resource_path, json=payload)
 
     def create_gridset(self, epsg: int) -> Response | None:
+        """
+        Create a gridset for GeoWebCache for a given projection
+        Supported EPSG codes are 2056, 21781 and 3857
+        """
         resource_path: str = f"/gwc/rest/gridsets/EPSG:{epsg}.xml"
         if self.resource_exists(resource_path):
             return None
@@ -628,6 +803,9 @@ class GeoServerCloud:
         return self.put_request(resource_path, data=data, headers=headers)
 
     def resource_exists(self, path: str) -> bool:
+        """
+        Check if a resource (given its path) exists in GeoServer
+        """
         # GeoServer raises a 500 when posting to a datastore or feature type that already exists, so first do
         # a get request
         response = self.get_request(path)

geoservercloud-0.2.4.dev2/geoservercloud/gridsets/21781.xml

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<gridSet>
+  <name>EPSG:21781</name>
+  <srs>
+    <number>21781</number>
+  </srs>
+  <extent>
+    <coords>
+      <double>420000.0</double>
+      <double>-674000.0</double>
+      <double>1444000.0</double>
+      <double>350000.0</double>
+    </coords>
+  </extent>
+  <resolutions>
+    <double>4000.0</double>
+    <double>3750.0</double>
+    <double>3500.0</double>
+    <double>3250.0</double>
+    <double>3000.0</double>
+    <double>2750.0</double>
+    <double>2500.0</double>
+    <double>2250.0</double>
+    <double>2000.0</double>
+    <double>1750.0</double>
+    <double>1500.0</double>
+    <double>1250.0</double>
+    <double>1000.0</double>
+    <double>750.0</double>
+    <double>650.0</double>
+    <double>500.0</double>
+    <double>250.0</double>
+    <double>100.0</double>
+    <double>50.0</double>
+    <double>20.0</double>
+    <double>10.0</double>
+    <double>5.0</double>
+    <double>2.5</double>
+    <double>2.0</double>
+    <double>1.5</double>
+    <double>1.0</double>
+    <double>0.5</double>
+    <double>0.25</double>
+    <double>0.1</double>
+  </resolutions>
+  <scaleNames>
+    <string>EPSG:21781:0</string>
+    <string>EPSG:21781:1</string>
+    <string>EPSG:21781:2</string>
+    <string>EPSG:21781:3</string>
+    <string>EPSG:21781:4</string>
+    <string>EPSG:21781:5</string>
+    <string>EPSG:21781:6</string>
+    <string>EPSG:21781:7</string>
+    <string>EPSG:21781:8</string>
+    <string>EPSG:21781:9</string>
+    <string>EPSG:21781:10</string>
+    <string>EPSG:21781:11</string>
+    <string>EPSG:21781:12</string>
+    <string>EPSG:21781:13</string>
+    <string>EPSG:21781:14</string>
+    <string>EPSG:21781:15</string>
+    <string>EPSG:21781:16</string>
+    <string>EPSG:21781:17</string>
+    <string>EPSG:21781:18</string>
+    <string>EPSG:21781:19</string>
+    <string>EPSG:21781:20</string>
+    <string>EPSG:21781:21</string>
+    <string>EPSG:21781:22</string>
+    <string>EPSG:21781:23</string>
+    <string>EPSG:21781:24</string>
+    <string>EPSG:21781:25</string>
+    <string>EPSG:21781:26</string>
+    <string>EPSG:21781:27</string>
+    <string>EPSG:21781:28</string>
+  </scaleNames>
+  <tileHeight>256</tileHeight>
+  <tileWidth>256</tileWidth>
+  <yCoordinateFirst>false</yCoordinateFirst>
+  <alignTopLeft>false</alignTopLeft>
+  <metersPerUnit>1.0</metersPerUnit>
+  <pixelSize>2.8E-4</pixelSize>
+</gridSet>

{geoservercloud-0.2.3.dev3 → geoservercloud-0.2.4.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "geoservercloud"
-version = "0.2.3.dev3"
+version = "0.2.4.dev2"
 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"