geodeploy 1.4.0__tar.gz → 1.6.0__tar.gz

{geodeploy-1.4.0/geodeploy.egg-info → geodeploy-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geodeploy
-Version: 1.4.0
+Version: 1.6.0
 Summary: Command-line client and Python API for GeoDeploy — upload spatial data, build and publish portals.
 Author: Koffi Dodji Noumonvi
 License-Expression: Apache-2.0

{geodeploy-1.4.0 → geodeploy-1.6.0}/README.md

@@ -37,6 +37,14 @@ User documentation is `docs/cli.md`; this file is the technical note.
 - `portals.py` — portal CRUD and `layer_configs` surgery. `layer_configs[0]` = top of the list =
   drawn on top. `editable_config()` drops server-owned fields before a round-trip PUT.
 - `styles.py` — the style vocabulary of `api/geodeploy/services/symbology.py`, in both directions.
+- `expressions.py` — **QGIS expressions ⇄ MapLibre expressions**, over a subset that is declared
+  rather than discovered. A rule is a filter, and so is a subset string and every data-defined
+  property, so this is what lets rule-based rendering travel at all. Anything outside the subset
+  raises `Unsupported` **naming the construct** — the fidelity report is built from those names, and
+  a translator that silently approximates publishes a map the author never saw. `to_maplibre` is
+  generous (its input is whatever somebody typed in QGIS); `from_maplibre` is deliberately narrow
+  (its input is a filter GeoDeploy itself stored). The SERVER never calls either: a rule arrives
+  already translated, so there is one translator rather than two that would drift.
   `build_style()` **assembles** it from plain arguments; `parse()`/`Style` **reads** one back
   (mode, field, classes, categories, size, extrusion, rescale) so a consumer — the QGIS plugin —
   does not re-decide what `color_mode: "graduated"` implies. `Style` is a reader, not a schema: it
@@ -192,5 +200,13 @@ the CLI yet; see below).
   run on, and only the second one is visible to a user with an old install.
 
 ## Last updated
+2026-09-05 (`styles.picture_data_uri` + `--marker-image` / `--fill-pattern` / `--line-marker` /
+`--centroid-marker`, each taking a local image FILE. These four keys already *survived* a CLI
+restyle — `build_style` merges onto the existing style, so a marker the QGIS plugin rendered was
+never dropped by `--color red` — but there was no way to SET one without going through QGIS, which
+made "can it all be done from the CLI?" a no for the part of the vocabulary that is pixels rather
+than words. The size ceiling is the plugin's own 96 KB on RAW bytes, deliberately: a file the CLI
+accepted that the plugin would have refused is two ceilings for one key.)
+
 2026-08-12 (created — packaged CLI + Python client, replacing `examples/geodeploy_cli.py`; then
 `browse` + anonymous layer download on top of the new `/api/public` and per-layer export endpoints)

{geodeploy-1.4.0 → geodeploy-1.6.0}/geodeploy/__init__.py

@@ -14,7 +14,7 @@ from __future__ import annotations
 # The CLI's version tracks the GeoDeploy release it ships with. A PyPI version can never be
 # re-uploaded, so a number is only spent once the release it names exists: 1.3.0b1 proved the
 # packaging against the real index, and this is the release it was rehearsing for.
-__version__ = "1.4.0"
+__version__ = "1.6.0"
 
 from .client import Client  # noqa: E402  (after __version__ — the user agent reads it)
 from .errors import (  # noqa: E402
@@ -25,6 +25,7 @@ from .errors import (  # noqa: E402
     GeoDeployError,
     NotFoundError,
     PermissionError_,
+    RateLimited,
     ServerError,
     TransportError,
     ValidationError,
@@ -43,6 +44,7 @@ __all__ = [
     "ConflictError",
     "NotFoundError",
     "PermissionError_",
+    "RateLimited",
     "ServerError",
     "TransportError",
     "ValidationError",

{geodeploy-1.4.0 → geodeploy-1.6.0}/geodeploy/cli/commands/_common.py

@@ -14,7 +14,8 @@ from typing import Any, Dict, List, Optional
 
 from ...errors import ValidationError
 from ...styles import (CLASSIFY_METHODS, COLOR_MODES, LINE_TYPES, MARKERS, RAMPS, build_style,
-                       parse_categories, parse_classes)
+                       parse_categories, parse_classes, parse_number_list,
+                       LINE_CAPS, LINE_JOINS, LABEL_FONTS)
 
 
 def add_style_args(parser, raster: bool = True) -> None:
@@ -46,7 +47,7 @@ def add_style_args(parser, raster: bool = True) -> None:
     driven.add_argument("--classify", nargs="?", const="quantile", choices=CLASSIFY_METHODS,
                         help="compute classes from the data: quantile (default), equal, jenks")
     driven.add_argument("--classes", type=int, default=None,
-                        help="how many classes to compute (2-12, default 5)")
+                        help="how many classes to compute (2-100, default 5)")
     driven.add_argument("--ramp", choices=RAMPS, help="colour ramp for computed classes")
     driven.add_argument("--reverse-ramp", action="store_true",
                         help="run the ramp the other way (light end for the low values)")
@@ -99,6 +100,92 @@ def add_style_args(parser, raster: bool = True) -> None:
                           help="high end of the contour colour range (defaults to --rescale)")
         rast.add_argument("--bidx", help="band selection: '1' or '3,2,1' for an RGB composite")
 
+    # The line and marker vocabulary MapLibre draws natively. Each round-trips exactly from QGIS.
+    line = parser.add_argument_group("lines and markers")
+    line.add_argument("--dash-pattern",
+                      help="dash and gap lengths in MULTIPLES OF THE LINE WIDTH, e.g. '3,2' or "
+                           "'3,2,1,2' — wins over --line-type")
+    line.add_argument("--no-dash-pattern", action="store_true",
+                      help="drop a custom dash pattern, leaving --line-type")
+    line.add_argument("--line-cap", choices=LINE_CAPS, help="how a line ends")
+    line.add_argument("--line-join", choices=LINE_JOINS, help="how a line turns a corner")
+    line.add_argument("--line-offset", type=float,
+                      help="draw the line this many pixels to one side (negative for the other)")
+    line.add_argument("--marker-rotation", type=float, help="turn each marker, in degrees")
+    line.add_argument("--marker-offset", help="move each marker, as 'x,y' in pixels")
+    line.add_argument("--marker-opacity", type=float, help="the marker's own opacity, 0-1")
+
+    # PICTURES FROM A FILE. These three keys already SURVIVED a CLI restyle — `build_style` merges
+    # onto the existing style, so a marker rendered by the QGIS plugin was never dropped — but there
+    # was no way to SET one without QGIS. A PNG or SVG on disk is the obvious other source, and the
+    # renderers cannot tell the two apart: both arrive as the same data URI.
+    pics = parser.add_argument_group("pictures (from a local image file)")
+    pics.add_argument("--marker-image", metavar="FILE",
+                      help="draw each point as this image instead of a generated shape")
+    pics.add_argument("--fill-pattern", metavar="FILE",
+                      help="tile this image across each polygon (it must tile seamlessly)")
+    pics.add_argument("--line-marker", metavar="FILE",
+                      help="repeat this image along each line, rotated with it")
+    pics.add_argument("--centroid-marker", metavar="FILE",
+                      help="place this image at each polygon's centre")
+    for flag, what in (("--no-marker-image", "the point picture"),
+                       ("--no-fill-pattern", "the polygon pattern"),
+                       ("--no-line-marker", "the markers along the line"),
+                       ("--no-centroid-marker", "the centre marker")):
+        pics.add_argument(flag, action="store_true", help="remove {0}".format(what))
+    pics.add_argument("--line-marker-spacing", type=float,
+                      help="pixels between repeated line markers")
+
+    # Scale range and "draws nothing" belong to the LAYER, not to one symbol.
+    scope = parser.add_argument_group("where the layer draws")
+    scope.add_argument("--min-zoom", type=float,
+                       help="hide the layer below this zoom (QGIS's most-zoomed-OUT scale limit)")
+    scope.add_argument("--max-zoom", type=float, help="hide the layer above this zoom")
+    scope.add_argument("--no-symbol", action="store_true",
+                       help="draw nothing, but keep the layer listed — QGIS's No symbols renderer")
+    scope.add_argument("--symbol", dest="no_symbol", action="store_false", default=None,
+                       help="undo --no-symbol")
+
+    # LABELS. Their own group because a label is a second thing drawn for the same feature — its
+    # own text, font, colour and zoom range — and it becomes its own MapLibre layer.
+    lab = parser.add_argument_group("labels")
+    lab.add_argument("--label-field", help="the attribute to label with — turns labelling ON")
+    lab.add_argument("--no-labels", action="store_true", help="stop labelling this layer")
+    lab.add_argument("--label-size", type=float, help="label text size in pixels")
+    lab.add_argument("--label-color", help="label text colour")
+    lab.add_argument("--label-font", choices=LABEL_FONTS,
+                     help="a portal can only draw the fonts its glyph set contains")
+    lab.add_argument("--label-halo-color", help="colour of the outline behind the text")
+    lab.add_argument("--label-halo-width", type=float, help="halo width in pixels (0 for none)")
+    lab.add_argument("--label-offset", help="move the text, as 'x,y' in pixels")
+    lab.add_argument("--label-placement", choices=("point", "line"),
+                     help="place the text at a point, or bend it along the line")
+    lab.add_argument("--label-line-position", choices=("on", "above", "below"),
+                     help="where along-the-line labels sit. A contour's height is written ON the "
+                          "line; a river's name usually sits above it. Carried for QGIS, which is "
+                          "the only surface that can draw the difference")
+    lab.add_argument("--label-per-part", action="store_true",
+                     help="label every PART of a multi-part feature instead of the feature once — "
+                          "an archipelago wants this, a country with two islands does not")
+    lab.add_argument("--label-transform", choices=("none", "uppercase", "lowercase"))
+    lab.add_argument("--label-max-width", type=float, help="wrap the text at this many ems")
+    lab.add_argument("--label-allow-overlap", action="store_true",
+                     help="draw every label even where they collide")
+    lab.add_argument("--label-priority", type=float,
+                     help="0-10, higher wins the space when labels collide")
+    lab.add_argument("--label-min-zoom", type=float, help="hide the labels below this zoom")
+    lab.add_argument("--label-max-zoom", type=float, help="hide the labels above this zoom")
+
+    # RULES. A rule list is not something anyone types at a shell — it comes out of QGIS, through
+    # the plugin — so the CLI's job is to move one around and to get rid of one, not to compose it
+    # field by field. `--rules @file.json` is how a rule-based style is scripted into an instance.
+    parser.add_argument("--rules",
+                        help="a JSON list (or @file.json) of rule objects — "
+                             '{label, expression, filter, style, minzoom, maxzoom} — usually '
+                             "written by the QGIS plugin")
+    parser.add_argument("--no-rules", action="store_true",
+                        help="drop the rule list, leaving the layer's own single symbol")
+
     parser.add_argument("--style-json",
                         help="a JSON object (or @file.json) merged in last — the escape hatch for "
                              "anything these flags do not cover")
@@ -133,7 +220,9 @@ def style_from_args(args, client=None, layer_ref: Optional[Any] = None,
                  "rescale", "algorithm", "zfactor", "increment", "thickness", "minz", "maxz",
                  "color_field", "color_mode", "size_field", "other_color", "size_stops",
                  "extrude_field", "extrude_scale", "extrude_base", "extrude_color",
-                 "extrude_opacity", "extrude_radius"):
+                 "extrude_opacity", "extrude_radius",
+                 "line_cap", "line_join", "line_offset", "marker_rotation", "marker_opacity",
+                 "min_zoom", "max_zoom"):
         kwargs[name] = getattr(args, name, None)
     if getattr(args, "bidx", None):
         kwargs["bidx"] = [int(b) for b in str(args.bidx).replace(" ", "").split(",") if b]
@@ -147,6 +236,48 @@ def style_from_args(args, client=None, layer_ref: Optional[Any] = None,
         kwargs["categories"] = parse_categories(args.categories)
     if getattr(args, "no_classification", False):
         kwargs["clear_classification"] = True
+    for arg, key in (("marker_image", "marker_image"), ("fill_pattern", "fill_pattern"),
+                     ("line_marker", "line_marker"), ("centroid_marker", "centroid_marker")):
+        path = getattr(args, arg, None)
+        if path:
+            kwargs[key] = path
+        if getattr(args, "no_" + arg, False):
+            kwargs["no_" + key] = True
+    if getattr(args, "line_marker_spacing", None) is not None:
+        kwargs["line_marker_spacing"] = args.line_marker_spacing
+    for name in ("dash_pattern", "marker_offset", "no_dash_pattern", "no_symbol"):
+        value = getattr(args, name, None)
+        if value is not None and value is not False:
+            kwargs[name] = value
+        elif name == "no_symbol" and value is False:
+            kwargs[name] = False          # `--symbol` explicitly turns it back on
+    labels = {}
+    for arg, key in (("label_field", "field"), ("label_size", "size"), ("label_color", "color"),
+                     ("label_font", "font"), ("label_halo_color", "halo_color"),
+                     ("label_halo_width", "halo_width"), ("label_placement", "placement"),
+                     ("label_line_position", "line_position"),
+                     ("label_transform", "transform"), ("label_max_width", "max_width"),
+                     ("label_priority", "priority"), ("label_min_zoom", "minzoom"),
+                     ("label_max_zoom", "maxzoom")):
+        value = getattr(args, arg, None)
+        if value is not None:
+            labels[key] = value
+    # A FLAG, so only its presence means anything: `store_true` leaves False for "not asked", and
+    # sending that would turn the setting OFF on a style that had it on.
+    if getattr(args, "label_per_part", False):
+        labels["label_per_part"] = True
+    if getattr(args, "label_offset", None):
+        labels["offset"] = parse_number_list(args.label_offset, "--label-offset", length=2)
+    if getattr(args, "label_allow_overlap", False):
+        labels["allow_overlap"] = True
+    if labels:
+        kwargs["labels"] = labels
+    if getattr(args, "no_labels", False):
+        kwargs["clear_labels"] = True
+    if getattr(args, "rules", None):
+        kwargs["rules"] = read_json_arg(args.rules, "--rules", allow_list=True)
+    if getattr(args, "no_rules", False):
+        kwargs["clear_rules"] = True
 
     style = build_style(style, **kwargs)
 
@@ -156,11 +287,15 @@ def style_from_args(args, client=None, layer_ref: Optional[Any] = None,
     return style
 
 
-def read_json_arg(value: str, label: str) -> Dict[str, Any]:
+def read_json_arg(value: str, label: str, allow_list: bool = False):
     """A JSON object given inline, or `@path` to read it from a file (or `@-` for stdin).
 
     `utf-8-sig` on the file: PowerShell's `>` writes UTF-16 or a BOM, which is how the reference
     script's `portal-set` used to fail on Windows with an unreadable JSON error.
+
+    `allow_list` is for `--rules`, which is a JSON ARRAY rather than an object — the object check
+    below is otherwise the thing that catches a style file with the wrong shape, and loosening it
+    for everything would trade a clear message for a confusing one further down.
     """
     text = value
     if value.startswith("@"):
@@ -174,6 +309,10 @@ def read_json_arg(value: str, label: str) -> Dict[str, Any]:
         data = json.loads(text)
     except ValueError as exc:
         raise ValidationError(400, "{0} is not valid JSON: {1}".format(label, exc))
+    if allow_list:
+        if not isinstance(data, list):
+            raise ValidationError(400, "{0} must be a JSON list.".format(label))
+        return data
     if not isinstance(data, dict):
         raise ValidationError(400, "{0} must be a JSON object.".format(label))
     return data

{geodeploy-1.4.0 → geodeploy-1.6.0}/geodeploy/cli/commands/portals.py

@@ -39,13 +39,14 @@ examples:
   geodeploy portals create "Field sites 2026"
   geodeploy portals create "Catalogue" --experience catalog --access organization
   geodeploy portals create "Story" --experience storymap --template minimal
+  geodeploy portals create "Fleet" --experience dashboard --template dashboard-monitoring
 """)
     create.add_argument("title")
     create.add_argument("--description", help="About text, or @file.md")
     create.add_argument("--template", default="minimal", dest="template_id",
                         help="template id (see `geodeploy catalog templates`)")
     create.add_argument("--experience", choices=ARCHETYPES,
-                        help="webmap (default), storymap or catalog")
+                        help="webmap (default), storymap, catalog or dashboard")
     create.add_argument("--access", choices=ACCESS_TYPES, default="public",
                         help="who may view the PUBLISHED portal")
     create.add_argument("--password", help="the password, when --access password")

{geodeploy-1.4.0 → geodeploy-1.6.0}/geodeploy/cli/commands/sources.py

@@ -1,11 +1,18 @@
-"""`geodeploy sources …` — external WMS / XYZ / WFS services used without ingesting them."""
+"""`geodeploy sources …` — somebody else's service, used in a portal without ingesting it.
+
+XYZ, WMS, WMTS, WFS, OGC API - Features, vector tiles and PMTiles. See
+`geodeploy/sources.py` for what each one is and which of them are fetched through the
+instance rather than straight from the provider (the answer is CORS).
+"""
 from __future__ import annotations
 
+from ...sources import SOURCE_TYPES
 from ..main import add_command, group_parser
 from ..output import EXIT_GENERIC, EXIT_OK
 from ._common import confirm
 
-COLUMNS = ["id", "name", "source_type", "kind", "url", "layer_name", "visibility", "created_by"]
+COLUMNS = ["id", "name", "source_type", "kind", "url", "layer_name", "source_layer",
+           "visibility", "created_by"]
 
 
 def register(subparsers) -> None:
@@ -22,16 +29,28 @@ examples:
       --layer-name ortho_2025 --version 1.3.0
   geodeploy sources add "Municipalities" https://wfs.example.org/ows --type wfs \\
       --layer-name ms:kommun
-
-A WFS is probed when it is registered, so a wrong typeName fails here rather than as an empty
-layer on a published map.
+  geodeploy sources add "Roads" https://example.org/ogc/collections/roads --type ogcapi
+  geodeploy sources add "Basemap" https://tiles.example.org/tiles.json --type vectortile
+  geodeploy sources add "Buildings" https://files.example.org/b.pmtiles --type pmtiles
+
+Everything that can be checked is checked when it is registered — a WFS and an OGC API
+collection are fetched, a TileJSON is read, a PMTiles header is parsed — so a wrong name or
+an unreachable host fails here rather than as an empty layer on a published map. That is
+also where the layer inside a tile set, its zoom range and its extent come from.
 """)
     add.add_argument("name")
     add.add_argument("service_url", metavar="url", help="the service endpoint")
-    add.add_argument("--type", dest="source_type", required=True, choices=["xyz", "wms", "wfs"])
-    add.add_argument("--layer-name", help="WMS `layers` / WFS `typeName` (required for both)")
+    add.add_argument("--type", dest="source_type", required=True, choices=list(SOURCE_TYPES))
+    add.add_argument("--layer-name",
+                     help="which layer of the service: WMS/WMTS `layers`, WFS `typeName`, or an "
+                          "OGC API collection id (optional when the URL already names it)")
+    add.add_argument("--source-layer",
+                     help="the layer INSIDE a vector tile or PMTiles archive. Read from the "
+                          "service where it publishes one (TileJSON, PMTiles metadata); give it "
+                          "when it does not, because a style that names none draws nothing")
+    add.add_argument("--matrix-set", help="WMTS TileMatrixSet (default GoogleMapsCompatible)")
     add.add_argument("--version", help="WMS (default 1.3.0) or WFS (default 2.0.0) version")
-    add.add_argument("--format", dest="image_format", help="WMS image format (default image/png)")
+    add.add_argument("--format", dest="image_format", help="WMS/WMTS image format (default image/png)")
     add.add_argument("--attribution")
 
     show = add_command(group, "show", cmd_show, "one source")
@@ -57,7 +76,8 @@ def cmd_list(ctx, args) -> int:
 
 def cmd_add(ctx, args) -> int:
     source = ctx.client().sources.create(
-        args.name, args.source_type, args.service_url, layer_name=args.layer_name, version=args.version,
+        args.name, args.source_type, args.service_url, layer_name=args.layer_name,
+        source_layer=args.source_layer, matrix_set=args.matrix_set, version=args.version,
         image_format=args.image_format, attribution=args.attribution)
     ctx.out.render(source, COLUMNS + ["bbox", "geometry_type"])
     if not ctx.out.json_mode:

{geodeploy-1.4.0 → geodeploy-1.6.0}/geodeploy/client.py

@@ -17,7 +17,8 @@ from __future__ import annotations
 
 import json as _json
 import os
-from typing import Any, Callable, Dict, Optional, Union
+import time as _time
+from typing import Any, Callable, Dict, Optional
 from urllib.parse import quote, urlencode, urljoin
 
 from . import errors
@@ -27,6 +28,22 @@ __all__ = ["Client"]
 
 #: Sent on every request. An instance's access log is where an operator works out that "the API is
 #: hammering us" is in fact someone's nightly CLI job, so it names the tool and its version.
+def _retry_after(response) -> Optional[float]:
+    """`Retry-After` in seconds, when the server sent one and it is a number.
+
+    The HTTP-date form is deliberately not parsed: it needs a clock the client cannot trust to
+    agree with the server's, and every limiter in this stack sends seconds or nothing at all.
+    """
+    raw = (response.headers or {}).get("retry-after")
+    if raw is None:
+        return None
+    try:
+        seconds = float(str(raw).strip())
+    except (TypeError, ValueError):
+        return None
+    return max(0.0, min(300.0, seconds)) if seconds == seconds else None
+
+
 def _default_user_agent() -> str:
     from . import __version__
     return "geodeploy-cli/{0}".format(__version__)
@@ -52,7 +69,9 @@ class Client(object):
                  transport: Optional[Any] = None, timeout: float = 120.0,
                  upload_timeout: float = 3600.0, user_agent: Optional[str] = None,
                  verify_tls: bool = True, retries: int = 2,
-                 on_request: Optional[Callable[[str, str], None]] = None):
+                 on_request: Optional[Callable[[str, str], None]] = None,
+                 rate_limit_retries: int = 6,
+                 on_throttled: Optional[Callable[[float, int, int], None]] = None):
         from .config import normalize_url
         self.url = normalize_url(url)
         self.token = token or None
@@ -64,6 +83,14 @@ class Client(object):
         #: Called with (method, url) before each request — the CLI's `-v` uses it, and a plugin can
         #: route it to the QGIS message log without this module knowing what logging is.
         self.on_request = on_request
+        #: How many times a 429 is waited out before it is raised. Six covers a group push against
+        #: the shipped `rate=5r/m` upload limit; past that something is wrong that waiting will not
+        #: fix, and the caller deserves to hear about it.
+        self.rate_limit_retries = max(0, int(rate_limit_retries))
+        #: Called with (seconds, attempt, of) each time a request is held back. The point is that a
+        #: long wait should look like progress rather than like a hang — the CLI prints it and the
+        #: plugin puts it in the status bar.
+        self.on_throttled = on_throttled
 
         # Namespaces. Imported here rather than at module scope because each one imports this
         # module for typing; the cost is one attribute lookup at construction.
@@ -137,9 +164,47 @@ class Client(object):
 
         if self.on_request:
             self.on_request(method.upper(), url)
-        response = self.transport.send(
-            Request(method, url, hdrs, data, timeout if timeout is not None else self.timeout))
-        return self._handle(response, parse)
+
+        # RATE LIMITING IS A WAIT, NOT A FAILURE. An instance throttles its upload route — nginx
+        # ships `rate=5r/m` — and pushing a group of layers is exactly the burst that trips it. The
+        # user saw "HTTP 429" partway through and had to press the button again to get the rest,
+        # which is the client asking a person to do a computer's job.
+        #
+        # RETRYING A POST IS SAFE HERE, and that is worth stating because usually it would not be:
+        # the rejection happens at the front door, before the request is proxied to the application
+        # at all, so nothing was created and nothing was half-done. A 429 means "not yet".
+        deadline_attempts = self.rate_limit_retries + 1
+        for attempt in range(deadline_attempts):
+            response = self.transport.send(
+                Request(method, url, hdrs, data,
+                        timeout if timeout is not None else self.timeout))
+            if response.status != 429 or attempt == deadline_attempts - 1:
+                return self._handle(response, parse)
+            wait = _retry_after(response) or self._backoff(attempt)
+            if self.on_throttled:
+                self.on_throttled(wait, attempt + 1, self.rate_limit_retries)
+            _time.sleep(wait)
+            # A BODY THAT WAS READ ONCE CANNOT BE SENT AGAIN. A file-like body is consumed by the
+            # first attempt, so it is rewound where that is possible and the retry abandoned where
+            # it is not — a silently truncated upload would be far worse than a 429.
+            if data is not None and not isinstance(data, (bytes, bytearray, str)):
+                seek = getattr(data, "seek", None)
+                if not callable(seek):
+                    return self._handle(response, parse)
+                try:
+                    seek(0)
+                except Exception:                                # noqa: BLE001
+                    return self._handle(response, parse)
+        return self._handle(response, parse)                     # pragma: no cover - loop returns
+
+    def _backoff(self, attempt: int) -> float:
+        """How long to wait before retry `attempt`, when the server did not say.
+
+        The shipped limit is `rate=5r/m` — one request every twelve seconds — so the first wait is
+        just over that, and later ones grow in case several clients are queued behind the same
+        bucket. Capped, because a wait nobody can see the end of is indistinguishable from a hang.
+        """
+        return min(60.0, 13.0 * (attempt + 1))
 
     def get(self, path: str, params: Optional[Dict[str, Any]] = None, **kw: Any) -> Any:
         return self.request("GET", path, params=params, **kw)
@@ -199,7 +264,7 @@ class Client(object):
     def _handle(self, response: Response, parse: bool = True) -> Any:
         if response.status >= 400:
             raise errors.from_status(response.status, _detail(response), response.url,
-                                     _safe_json(response))
+                                     _safe_json(response), _retry_after(response))
         if not parse:
             return response
         if response.status == 204 or not response.content:

{geodeploy-1.4.0 → geodeploy-1.6.0}/geodeploy/config.py

@@ -285,7 +285,7 @@ def _store_credential(origin: str, entry: Dict[str, Any], use_keyring: bool = Tr
                 # Drop any older file copy, so a secret lives in ONE place, not two.
                 _write_credentials({k: v for k, v in _read_credentials().items() if k != origin})
                 return "keyring"
-            except Exception:
+            except Exception:  # nosec B110 - intentional: a cosmetic failure must not take down the layer
                 pass  # Locked/denied keyring: fall back to the file rather than losing the login.
     creds = _read_credentials()
     creds[origin] = entry
@@ -309,7 +309,7 @@ def load_credential(url: str) -> Dict[str, Any]:
                     # Pre-1.3 entries stored the bare token string. Read it rather than making a
                     # working login look like no login at all.
                     return {"token": value}
-        except Exception:
+        except Exception:  # nosec B110 - intentional: a cosmetic failure must not take down the layer
             pass
     entry = _read_credentials().get(origin) or {}
     return dict(entry) if isinstance(entry, dict) else {}
@@ -345,7 +345,7 @@ def delete_token(url: str, kind: Optional[str] = None) -> bool:
             if kr.get_password(KEYRING_SERVICE, origin):
                 kr.delete_password(KEYRING_SERVICE, origin)
                 removed = True
-        except Exception:
+        except Exception:  # nosec B110 - intentional: a cosmetic failure must not take down the layer
             pass
     creds = _read_credentials()
     if creds.pop(origin, None) is not None:

{geodeploy-1.4.0 → geodeploy-1.6.0}/geodeploy/errors.py

@@ -72,12 +72,30 @@ class ValidationError(APIError):
     """400 / 413 / 422 — the request itself was wrong: bad geometry columns, oversized file."""
 
 
+class RateLimited(APIError):
+    """Too many requests, too quickly — the server refused this one and wants it later.
+
+    NOT A FAILURE OF THE REQUEST. The instance's front door rejects these before they ever reach the
+    application, so nothing was created, nothing was half-done, and sending the same request again
+    after a wait is safe even when it is a POST. That is what makes `Client` retry them for you.
+
+    `retry_after` is the server's own answer in seconds when it gave one.
+    """
+
+    def __init__(self, status, detail, url="", payload=None, retry_after=None):
+        super().__init__(status, detail, url, payload)
+        self.retry_after = retry_after
+
+
 class ServerError(APIError):
     """5xx — the instance failed. Worth retrying; not worth reformulating the request."""
 
 
-def from_status(status: int, detail: str, url: str = "", payload: Any = None) -> APIError:
+def from_status(status: int, detail: str, url: str = "", payload: Any = None,
+                retry_after: Any = None) -> APIError:
     """Map an HTTP status onto the class above that a caller can act on."""
+    if status == 429:
+        return RateLimited(status, detail, url, payload, retry_after)
     if status == 401:
         return AuthError(status, detail, url, payload)
     if status == 403: