geoservercloud.py

class geoservercloud.GeoServerCloud(url: str = 'http://localhost:9090/geoserver/cloud', user: str = 'admin', password: str = 'geoserver', verifytls: bool = True)

Bases: object

Facade class allowing CRUD operations on GeoServer resources

url

base GeoServer URL

Type:

str

user

GeoServer username

Type:

str

password

GeoServer password

Type:

str

assign_role_to_user(user: str, role: str) → tuple[str, int]

Assign a role to a GeoServer user

cleanup()

Cleanup internal state

create_acl_admin_rule(priority: int = 0, access: str = 'ADMIN', role: str | None = None, user: str | None = None, workspace_name: str | None = None) → tuple[dict | str, int]

Create a GeoServer ACL admin rule

create_acl_rule(priority: int = 0, access: str = 'DENY', role: str | None = None, user: str | None = None, service: str | None = None, request: str | None = None, workspace_name: str | None = None) → tuple[dict | str, int]

Create a GeoServer ACL data rule

create_acl_rules_for_requests(requests: list[str], priority: int = 0, access: str = 'DENY', role: str | None = None, service: str | None = None, workspace_name: str | None = None) → list[tuple[dict | str, int]]

Create ACL rules for multiple type of OGC requests

create_coverage(workspace_name: str, coveragestore_name: str, coverage_name: str, title: str | None = None, native_name: str | None = None) → tuple[str, int]

Publish a coverage layer from a given coverage store

create_coverage_store(workspace_name: str, coveragestore_name: str, url: str, type: str = 'ImageMosaic', enabled: bool = True, metadata: dict | None = None) → tuple[dict[str, Any] | str, int]

Create a coverage store from a store definition. When using a directory path as URL, coverages will be auto-discovered

Parameters:

• workspace_name – Name of the workspace

• coveragestore_name – Name of the coverage store

• url – Directory path on the server or URL of the granules (raster images)

• type – Type of the coverage store, e.g. ImageMosaic, GeoTIFF (default: ImageMosaic)

• enabled – Whether the coverage store is enabled (default: True)

• metadata – Optional metadata dictionary (e.g. {“cogSettings”: {“rangeReaderSettings”: “HTTP”}})

create_feature_type(layer_name: str, workspace_name: str | None = None, datastore_name: str | None = None, title: str | dict = 'Default title', abstract: str | dict = 'Default abstract', attributes: dict | None = None, epsg: int = 4326, keywords: list[str] = []) → tuple[str, int]

Create a feature type or update it if it already exist.

create_gridset(epsg: int) → tuple[str, int]

Create a gridset for GeoWebCache for a given projection Supported EPSG codes are 2056, 21781 and 3857

create_imagemosaic_store_from_directory(workspace_name: str, coveragestore_name: str, directory_path: str) → tuple[str, int]

Create an ImageMosaic coverage store from a directory on the server which contains granules (raster images). Granules and coverages will be auto-discovered. Similar to creating a store from the WebUI. Calls /workspaces/{workspace_name}/coveragestores/{coveragestore_name}/external.imagemosaic

create_imagemosaic_store_from_properties_zip(workspace_name: str, coveragestore_name: str, properties_zip: bytes) → tuple[str, int]

Upload an ImageMosaic coverage store configuration as ZIP to create an empty coverage store. The ZIP contains two files: indexer.properties and datastore.properties Calls /workspaces/{workspace_name}/coveragestores/{coveragestore_name}/file.imagemosaic?configure=none

create_jndi_datastore(workspace_name: str, datastore_name: str, jndi_reference: str, pg_schema: str = 'public', description: str | None = None, set_default_datastore: bool = False) → tuple[str, int]

Create a PostGIS datastore from JNDI resource, or update it if it already exist.

create_layer_group(group: str, workspace_name: str | None, layers: list[str], title: str | dict, abstract: str | dict, epsg: int = 4326, mode: str = 'SINGLE', enabled: bool = True, advertised: bool = True) → tuple[str, int]

Create a layer group or update it if it already exists.

create_pg_datastore(workspace_name: str, datastore_name: str, pg_host: str, pg_port: int, pg_db: str, pg_user: str, pg_password: str, pg_schema: str = 'public', description: str | None = None, set_default_datastore: bool = False) → tuple[str, int]

Create a PostGIS datastore from the DB connection parameters, or update it if it already exist.

create_role(role_name: str) → tuple[str, int]

Create a GeoServer role if it does not already exist

create_style_definition(style_name: str, filename: str, workspace_name: str | None = None) → tuple[str, int]

Create a style definition

create_style_from_file(style_name: str, 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.

create_style_from_string(style_name: str, style_string: str, workspace_name: str | None = None) → tuple[str, int]

Create a style (SLD) from its definition as a string or update it if it already exists.

create_user(user: str, password: str, enabled: bool = True) → tuple[str, int]

Create a GeoServer user

create_wms(workspace: str | None = None) → None

create_wms_layer(workspace_name: str, wms_store_name: str, native_layer_name: str, published_layer_name: str | None = None) → tuple[str, int]

Publish a remote WMS layer If it already exists, delete and recreate it (update is not supported by GeoServer)

create_wms_store(workspace_name: str, wms_store_name: str, capabilities_url: str) → tuple[str, int]

Create a cascaded WMS store, or update it if it already exist.

create_wmts(workspace_name: str | None = None) → None

create_wmts_layer(workspace_name: str, wmts_store: str, native_layer: str, published_layer: str | None = None, epsg: int = 4326, international_title: dict[str, str] | None = None, international_abstract: dict[str, str] | None = None) → tuple[str, int]

Publish a remote WMTS layer (first delete it if it already exists)

create_wmts_store(workspace_name: str, name: str, capabilities: str) → tuple[str, int]

Create a cascaded WMTS store, or update it if it already exist.

create_workspace(workspace_name: str, isolated: bool = False, set_default_workspace: bool = False) → tuple[str, int]

Create a workspace in GeoServer, if it does not already exist. It if exists, update it

delete_acl_admin_rule(id: int | str) → tuple[str, int]

Delete a GeoServer ACL admin rule by id

delete_all_acl_admin_rules() → tuple[str, int]

Delete all existing GeoServer ACL admin rules

delete_all_acl_rules() → tuple[str, int]

Delete all existing GeoServer ACL data rules

delete_coverage_store(workspace_name: str, coveragestore_name: str) → tuple[str, int]

Delete a coverage store recursively

delete_feature_type(workspace_name: str, datastore_name: str, layer_name: str) → tuple[str, int]

Delete a feature type and associated layer

delete_gwc_layer(workspace_name: str, layer: str) → tuple[str, int]

delete_layer_group(workspace_name: str, layer_group_name: str) → tuple[str, int]

Delete a layer group

delete_role(role_name: str) → tuple[str, int]

Delete a GeoServer role

delete_user(user: str) → tuple[str, int]

Delete a GeoServer user

delete_wms_layer(workspace_name: str, wms_store_name: str, wms_layer_name: str) → tuple[str, int]

Delete a WMS layer

delete_wms_store(workspace_name: str, wms_store_name: str) → tuple[str, int]

Delete a WMS store recursively

delete_wmts_store(workspace_name: str, wmts_store_name: str) → tuple[str, int]

Delete a WMTS store recursively

delete_workspace(workspace_name: str) → tuple[str, int]

Delete a GeoServer workspace (recursively)

describe_feature_type(workspace_name: str | None = None, type_name: str | None = None, format: str = 'application/json') → dict[str, Any] | str

WFS DescribeFeatureType request Return the feature type(s) as dict if found, otherwise return the response content as string

get_acl_rules() → tuple[dict[str, Any] | str, int]

Return all GeoServer ACL data rules

get_coverage(workspace_name: str, coveragestore_name: str, coverage_name: str) → tuple[dict[str, object] | str, int]

Get a single coverage for a given workspace, coverage store, and coverage name

get_coverage_store(workspace_name: str, coveragestore_name: str) → tuple[dict[str, Any] | str, int]

Get a coverage store by workspace and name

get_coverages(workspace_name: str, coveragestore_name: str) → tuple[list[dict[str, str]] | str, int]

Get all coverages for a given workspace and coverage store

get_datastores(workspace_name: str) → tuple[list[dict[str, str]] | str, int]

Get all datastores for a given workspace

get_feature(workspace_name: str, type_name: str, feature_id: int | None = None, max_feature: int | None = None, format: str = 'application/json') → dict[str, Any] | str

WFS GetFeature request Return the feature(s) as dict if found, otherwise return the response content as string

get_feature_info(layers: list[str], bbox: tuple[float, float, float, float], size: tuple[int, int], srs: str = 'EPSG:2056', info_format: str = 'application/json', transparent: bool = True, styles: list[str] | None = None, xy: list[float] = [0, 0], workspace_name: str | None = None) → ResponseWrapper | None

WMS GetFeatureInfo request

get_feature_type(workspace_name: str, datastore_name: str, feature_type_name: str) → tuple[dict[str, Any] | str, int]

Get a feature type by workspace, datastore and name

get_feature_types(workspace_name: str, datastore_name: str) → tuple[list[dict[str, Any]] | str, int]

Get all feature types for a given workspace and datastore

get_gwc_layer(workspace_name: str, layer: str) → tuple[dict[str, Any] | str, int]

get_layer_group(workspace_name: str, layer_group_name: str) → tuple[dict[str, Any] | str, int]

Get a layer group by name

get_layer_groups(workspace_name: str) → tuple[list[dict[str, str]] | str, int]

Get all layer groups for a given workspace

get_legend_graphic(layer: str | list[str], format: str = 'image/png', language: str | None = None, style: str | None = None, workspace_name: str | None = None) → Response

WMS GetLegendGraphic request

get_map(layers: list[str], bbox: tuple[float, float, float, float], size: tuple[int, int], srs: str = 'EPSG:2056', format: str = 'image/png', transparent: bool = True, styles: list[str] | None = None, language: str | None = None) → ResponseWrapper | None

WMS GetMap request

get_pg_datastore(workspace_name: str, datastore_name: str) → tuple[dict[str, Any] | str, int]

Get a datastore by workspace and name

get_property_value(workspace_name: str, type_name: str, property: str) → dict | list | str

WFS GetPropertyValue request Return the properties as dict (if one feature was found), a list (if multiple features were found), an empty dict if no feature was found or the response content as string

get_style_definition(style: str, workspace_name: str | None = None) → tuple[dict[str, Any] | str, int]

Get a style definition by name

get_styles(workspace_name: str | None = None) → tuple[list[dict[str, str]] | str, int]

Get all styles for a given workspace. If no workspace is provided, get all global styles

get_tile(layer: str, format: str, tile_matrix_set: str, tile_matrix: str, row: int, column: int, workspace_name: str | None = None) → ResponseWrapper | None

WMTS GetTile request

Parameters:

• layer – Name of the WMTS layer

• format – Image format (e.g. “image/png”)

• tile_matrix_set – Tile matrix set (e.g. “EPSG:3857”)

• tile_matrix – Tile matrix (zoom level)

• row – Tile row

• column – Tile column

• workspace_name – Optional workspace name

Returns:

owslib.util.ResponseWrapper with the tile image or None

get_user_roles(user: str) → tuple[list[str] | str, int]

Get all roles assigned to a GeoServer user

get_wfs_layers(workspace_name: str) → Any | dict[str, Any]

get_wms_layer(workspace_name: str, wms_store_name: str, wms_layer_name: str) → tuple[dict[str, Any] | str, int]

Get a WMS layer by workspace, store and name

get_wms_layers(workspace_name: str, accept_languages: str | None = None) → Any | dict[str, Any]

get_wms_store(workspace_name: str, datastore_name: str) → tuple[dict[str, Any] | str, int]

Get a WMS by workspace and name

get_workspace(workspace_name: str) → tuple[dict[str, str] | str, int]

Get a workspace by name

get_workspace_wms_settings(workspace_name: str) → tuple[dict[str, Any] | str, int]

Get the WMS settings for a given workspace

get_workspaces() → tuple[list[dict[str, str]] | str, int]

Get all GeoServer workspaces

harvest_granules_to_coverage_store(workspace_name: str, coveragestore_name: str, directory_path: str) → tuple[str, int]

Harvest granules (raster files) from a server directory into an existing ImageMosaic coverage store

publish_granule_to_coverage_store(workspace_name: str, coveragestore_name: str, method: str, granule_path: str) → tuple[str, int]

Publish a single granule (raster image) to an existing ImageMosaic coverage store. The granule is an existing file stored either on the server or remotely.

Parameters:

• workspace_name – Name of the workspace

• coveragestore_name – Name of the coverage store

• method – “external” for a file on the server, “remote” for a remote file

• granule_path – file path (for external granules) or URL (for remote granules)

publish_gwc_layer(workspace_name: str, layer: str, epsg: int = 4326) → tuple[str, int]

publish_workspace(workspace_name: str, versions: list[str] = ['1.1.1', '1.3.0'], cite_compliant: bool = False, schema_base_url: str = 'http://schemas.opengis.net', verbose: bool = False, bbox_for_each_crs: bool = False, watermark: dict = {'enabled': False, 'position': 'BOT_RIGHT', 'transparency': 100}, interpolation: str = 'Nearest', get_feature_info_mime_type_checking_enabled: bool = False, get_map_mime_type_checking_enabled: bool = False, dynamic_styling_disabled: bool = False, features_reprojection_disabled: bool = False, max_buffer: int = 0, max_request_memory: int = 0, max_rendering_time: int = 0, max_rendering_errors: int = 0, max_requested_dimension_values: int = 100, cache_configuration: dict = {'enabled': False, 'maxEntries': 1000, 'maxEntrySize': 51200}, remote_style_max_request_time: int = 60000, remote_style_timeout: int = 30000, default_group_style_enabled: bool = True, transform_feature_info_disabled: bool = False, auto_escape_template_values: bool = False) → tuple[str, int]

Publish the WMS service for a given workspace

recreate_workspace(workspace_name: str, isolated: bool = False, set_default_workspace: bool = False) → tuple[str, int]

Create a workspace in GeoServer, and first delete it if it already exists.

remove_role_from_user(user: str, role: str) → tuple[str, int]

Remove a role from a GeoServer user

set_default_layer_style(layer_name: str, workspace_name: str, style: str) → tuple[str, int]

Set the default style for a layer

set_default_locale_for_service(workspace_name: str, locale: str | None) → tuple[str, int]

Set a default language for localized WMS requests

unset_default_locale_for_service(workspace_name) → tuple[str, int]

Remove the default language for localized WMS requests

update_user(user: str, password: str | None = None, enabled: bool | None = None) → tuple[str, int]

Update a GeoServer user