marpledata 3.2.0__tar.gz → 3.2.2__tar.gz

marpledata-3.2.2/CHANGELOG.md

@@ -0,0 +1,39 @@
+# Changelog
+
+All notable changes to the Python SDK package `marpledata` will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [3.2.2] - 2026-06-01
+
+### Changed
+
+- Added default request timeouts and bounded retries to improve SDK reliability on spotty networks.
+- Retried idempotent direct-storage uploads while keeping Marple API POST retries conservative.
+
+## [3.2.1] - 2026-05-22
+
+### Changed
+
+- Included the SDK version in the `X-Request-Source` header sent by the Marple Insight client, matching the Marple DB client.
+
+## [3.2.0] - 2026-05-22
+
+### Added
+
+- Added the current Marple DB ingestion flow to `DataStream.push_file`.
+- Added automatic upload mode handling for server upload, Azure direct upload, single presigned upload, and multipart upload.
+- Added `concurrency` to control parallel direct-storage uploads.
+- Added `upload_mode="server"` to force uploads through the Marple DB API server when direct storage URLs are blocked.
+- Added `azure-storage-blob` as a runtime dependency for Azure-backed direct uploads.
+
+### Changed
+
+- Updated upload error handling to abort failed ingestions with a reason.
+- Undeprecated `DB.delete_stream` and `DB.delete_dataset` convenience methods.
+- Expanded README and Sphinx documentation for large-file uploads, forced server uploads, and integration test configuration.
+
+### Notes
+
+- `DB.push_file`, `DB.download_signal`, and `DB.update_metadata` remain deprecated compatibility paths. Prefer `DataStream`, `Dataset`, and `Signal` methods for new code.

{marpledata-3.2.0 → marpledata-3.2.2}/LICENSE

@@ -1,4 +1,4 @@
-Copyright [2025] Marple BV
+Copyright 2022-2026 Marple BV
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

{marpledata-3.2.0 → marpledata-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: marpledata
-Version: 3.2.0
+Version: 3.2.2
 Summary: Marple SDK for Python
 Project-URL: Homepage, https://www.marpledata.com/
 Project-URL: Documentation, https://marpledata.gitlab.io/marple-sdk/
@@ -51,6 +51,8 @@ from marple import DB      # Marple DB
 from marple import Insight # Marple Insight
 ```
 
+For release notes, see [`CHANGELOG.md`](CHANGELOG.md).
+
 ## Marple DB
 
 To get started:

{marpledata-3.2.0 → marpledata-3.2.2}/README.md

@@ -17,6 +17,8 @@ from marple import DB      # Marple DB
 from marple import Insight # Marple Insight
 ```
 
+For release notes, see [`CHANGELOG.md`](CHANGELOG.md).
+
 ## Marple DB
 
 To get started:

{marpledata-3.2.0 → marpledata-3.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "marpledata"
-version = "3.2.0"
+version = "3.2.2"
 description = "Marple SDK for Python"
 authors = [
   { name = "Matthias Baert", email = "support@marpledata.com" },

{marpledata-3.2.0 → marpledata-3.2.2}/src/marple/__init__.py

@@ -3,4 +3,4 @@ from .db import DB
 from .insight import Insight
 
 __all__ = ["DB", "Insight", "db"]
-__version__ = "3.2.0"
+__version__ = "3.2.2"

{marpledata-3.2.0 → marpledata-3.2.2}/src/marple/db/datastream.py

@@ -153,7 +153,11 @@ class DataStream(BaseModel):
         if init.presigned_url is None:
             raise ValueError("Single upload mode without presigned_url")
         with path.open("rb") as file:
-            response = requests.put(init.presigned_url, data=file, headers={"Content-Length": str(file_size)})
+            response = self._client.storage_session.put(
+                init.presigned_url,
+                data=file,
+                headers={"Content-Length": str(file_size)},
+            )
         _validate_storage_response(response, "Storage PUT failed")
 
     def _upload_multipart(
@@ -183,7 +187,11 @@ class DataStream(BaseModel):
                     file.seek(offset)
                     chunk = file.read(part_len)
 
-                    response = requests.put(part.url, data=chunk, headers={"Content-Length": str(part_len)})
+                    response = self._client.storage_session.put(
+                        part.url,
+                        data=chunk,
+                        headers={"Content-Length": str(part_len)},
+                    )
                     _validate_storage_response(response, f"Part {part.part_number} storage PUT failed")
 
         with ThreadPoolExecutor(max_workers=concurrency) as executor:

{marpledata-3.2.0 → marpledata-3.2.2}/src/marple/insight.py

@@ -2,6 +2,7 @@ from pathlib import Path
 from typing import Optional
 from urllib import request
 
+import marple
 import requests
 from marple.utils import validate_response
 from requests import Response
@@ -25,7 +26,7 @@ class Insight:
         bearer_token = f"Bearer {api_token}"
         self.session = requests.Session()
         self.session.headers.update({"Authorization": bearer_token})
-        self.session.headers.update({"X-Request-Source": "sdk/python"})
+        self.session.headers.update({"X-Request-Source": f"sdk/python:{marple.__version__}"})
         self.check_connection()
 
     # User functions #
@@ -181,3 +182,39 @@ class Insight:
 
         request.urlretrieve(download_url, target_path)
         return target_path
+   
+You generate Marple analysis plots from user questions.
+
+Supported plot types:
+- timeseries: use for one or more signals over time.
+- scatter: use for relationships between signals. Signal order is [x, y, optional color].
+- heatmap: use for histograms of x/y relationships. Signal order is [x, y].
+- map: use for geographic trajectory data. Signal order is [latitude, longitude, optional color].
+- frequency: use for frequency/FFT analysis of one or more signals.
+- state: use for discrete or categorical state signals.
+- message: use for message/log views. Use for sparse text-based data.
+- metadata: use for dataset metadata views. Use an empty signals list.
+
+Always call search_signals before add_plot. Only use signal keys returned by search_signals. Search results may be truncated.
+This is a single-turn plot generation task that creates exactly one plot. You cannot ask the user follow-up questions.
+If the request is ambiguous, make a reasonable best effort using search_signals.
+Provide a short description in add_plot summarizing the plot for the user.
+
+Examples:
+User: "all speed signals"
+search_signals({"text":"speed"})
+search_signals({"text":"*speed*","glob":true})
+
+
+User: "speed and rpm over time"
+add_plot({"plotType":"timeseries","signals":["speed_key","rpm_key"],"description":"Created speed and rpm over time."})
+
+User: "speed vs throttle colored by rpm"
+add_plot({"plotType":"scatter","signals":["throttle_key","speed_key","rpm_key"],"description":"Created speed versus throttle, colored by rpm."})
+
+User: "show me dataset metadata"
+add_plot({"plotType":"metadata","signals":[],"description":"Created a metadata plot."})
+
+Dataset profile:
+
+ 

marpledata-3.2.2/src/marple/profile.json

@@ -0,0 +1,95 @@
+{
+  "dataset": {
+    "id": "{\"dataset\": \"SH-01 2026-05-31 Spa\"}",
+    "name": "SH-01 2026-05-31 Spa",
+    "realtime": false,
+    "timestampStart": "31/05/2026 08:27",
+    "timestampStop": "31/05/2026 08:48",
+    "duration": "21m15s",
+    "metadata": {
+      "dataset": "SH-01 2026-05-31 Spa",
+      "session": "SH",
+      "outing": "Outing 1",
+      "car": "M42",
+      "driver": "JS",
+      "track": "Spa",
+      "acquisition type": "Cable"
+    }
+  },
+  "signalCount": 126,
+  "facets": {
+    "signalStatus": {
+      "FROZEN_TO_COLD": 0,
+      "COLD": 0,
+      "HOT": 0,
+      "COLD_TO_HOT": 0
+    },
+    "datatype": { "number": 121, "text": 5 },
+    "metadata.count_text": { "0": 121, "11486": 5 },
+    "metadata.count_value": {
+      "0": 5,
+      "1275": 55,
+      "2550": 42,
+      "6376": 11,
+      "11486": 13
+    },
+    "metadata.group": {
+      "acceleration": 3,
+      "velocity": 9,
+      "brakes": 7,
+      "controls": 4,
+      "position": 4,
+      "lap": 6,
+      "drs": 4,
+      "damage": 6,
+      "engine": 4,
+      "general": 2,
+      "fuel": 3,
+      "gear": 2,
+      "gforce": 3,
+      "gps": 2,
+      "pit": 4,
+      "spectating": 2,
+      "kers": 2,
+      "cars": 2,
+      "orientation": 3,
+      "lights": 1,
+      "sector": 3,
+      "session": 2,
+      "sli": 1,
+      "speed": 1,
+      "suspension": 12,
+      "team": 1,
+      "distance": 1,
+      "track": 2,
+      "traction": 1,
+      "tyres": 17,
+      "flags": 2,
+      "wheels": 4,
+      "displacement": 3,
+      "rotation": 3
+    },
+    "metadata.unit": {
+      "rad/s²": 3,
+      "rad/s": 3,
+      "enum": 10,
+      "%": 2,
+      "°C": 9,
+      "rpm": 3,
+      "L": 2,
+      "G": 2,
+      "g": 1,
+      "°": 2,
+      "J": 2,
+      "m": 9,
+      "s": 6,
+      "km/h": 1,
+      "rad": 7,
+      "m/s": 15,
+      "m/s²": 4,
+      "mm": 4,
+      "psi": 4
+    }
+  },
+  "metadataKeys": ["count_text", "count_value", "description", "group", "unit"]
+}

{marpledata-3.2.0 → marpledata-3.2.2}/src/marple/utils.py

@@ -15,6 +15,8 @@ from marple.db.constants import (
     COL_VAL_TEXT,
     COL_VAL_TEXT_IDX,
 )
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
 
 
 def validate_response(response: requests.Response, failure_message: str) -> dict:
@@ -34,7 +36,20 @@ def validate_response(response: requests.Response, failure_message: str) -> dict
     return r_json
 
 
+class TimeoutHTTPAdapter(HTTPAdapter):
+    def __init__(self, *args, timeout=None, **kwargs):
+        self.timeout = timeout
+        super().__init__(*args, **kwargs)
+
+    def send(self, request, **kwargs):
+        if kwargs.get("timeout") is None:
+            kwargs["timeout"] = self.timeout
+        return super().send(request, **kwargs)
+
+
 class DBClient:
+    DEFAULT_TIMEOUT = (5, 300)
+
     def __init__(self, api_token: str, api_url: str, datapool: str, cache_folder: str):
         self.api_token = api_token
         self.api_url = api_url
@@ -42,10 +57,46 @@ class DBClient:
         self.cache_folder = cache_folder
         self._signal_map: dict[str, int] | None = None
 
-        self.session = requests.Session()
+        self.session = self._create_api_session()
+        self.storage_session = self._create_storage_session()
         self.session.headers.update({"Authorization": f"Bearer {self.api_token}"})
         self.session.headers.update({"X-Request-Source": f"sdk/python:{marple.__version__}"})
 
+    def _create_api_session(self) -> requests.Session:
+        retry = Retry(
+            total=5,
+            connect=5,
+            read=2,
+            status=2,
+            backoff_factor=0.5,
+            status_forcelist=(429, 502, 503, 504),
+            allowed_methods=frozenset({"GET", "HEAD", "OPTIONS", "DELETE"}),
+            respect_retry_after_header=True,
+            raise_on_status=False,
+        )
+        return self._create_session(retry)
+
+    def _create_storage_session(self) -> requests.Session:
+        retry = Retry(
+            total=5,
+            connect=5,
+            read=5,
+            status=5,
+            backoff_factor=0.5,
+            status_forcelist=(429, 500, 502, 503, 504),
+            allowed_methods=frozenset({"PUT", "GET", "HEAD"}),
+            respect_retry_after_header=True,
+            raise_on_status=False,
+        )
+        return self._create_session(retry)
+
+    def _create_session(self, retry: Retry) -> requests.Session:
+        session = requests.Session()
+        adapter = TimeoutHTTPAdapter(max_retries=retry, timeout=self.DEFAULT_TIMEOUT)
+        session.mount("https://", adapter)
+        session.mount("http://", adapter)
+        return session
+
     def get(self, url: str, *args, **kwargs) -> requests.Response:
         return self.session.get(f"{self.api_url}{url}", *args, **kwargs)
 

marpledata-3.2.2/tests/test_reliability.py

@@ -0,0 +1,102 @@
+from collections.abc import Iterator
+from contextlib import contextmanager
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from threading import Thread
+
+import pytest
+from marple.utils import DBClient
+from requests import Response
+from requests.adapters import HTTPAdapter
+
+
+@contextmanager
+def retry_test_server(statuses: list[int]) -> Iterator[tuple[str, dict[str, int]]]:
+    calls = {"GET": 0, "POST": 0, "PUT": 0}
+
+    class Handler(BaseHTTPRequestHandler):
+        def do_GET(self) -> None:
+            self._handle()
+
+        def do_POST(self) -> None:
+            self._handle()
+
+        def do_PUT(self) -> None:
+            self._handle()
+
+        def log_message(self, format: str, *args) -> None:
+            return
+
+        def _handle(self) -> None:
+            calls[self.command] += 1
+            length = int(self.headers.get("Content-Length", "0"))
+            if length:
+                self.rfile.read(length)
+            status = statuses[min(calls[self.command] - 1, len(statuses) - 1)]
+            self.send_response(status)
+            self.send_header("Content-Length", "0")
+            self.end_headers()
+
+    server = HTTPServer(("127.0.0.1", 0), Handler)
+    thread = Thread(target=server.serve_forever)
+    thread.start()
+
+    try:
+        host, port = server.server_address
+        yield f"http://{host}:{port}", calls
+    finally:
+        server.shutdown()
+        thread.join()
+        server.server_close()
+
+
+def make_client(api_url: str = "http://example.test") -> DBClient:
+    return DBClient(
+        api_token="test-token",
+        api_url=api_url,
+        datapool="default",
+        cache_folder="./.test_cache",
+    )
+
+
+def test_api_session_retries_retryable_get_status() -> None:
+    with retry_test_server([503, 200]) as (api_url, calls):
+        response = make_client(api_url).get("/health")
+
+    assert response.status_code == 200
+    assert calls["GET"] == 2
+
+
+def test_default_timeout_applied(monkeypatch: pytest.MonkeyPatch) -> None:
+    timeouts = []
+
+    def fake_send(self, request, **kwargs) -> Response:
+        timeouts.append(kwargs["timeout"])
+        response = Response()
+        response.status_code = 200
+        response.url = request.url
+        response._content = b"{}"
+        return response
+
+    monkeypatch.setattr(HTTPAdapter, "send", fake_send)
+
+    client = make_client()
+    client.get("/health")
+    client.get("/health", timeout=(1, 2))
+
+    assert timeouts == [DBClient.DEFAULT_TIMEOUT, (1, 2)]
+
+
+def test_storage_put_retries_retryable_status() -> None:
+    with retry_test_server([503, 200]) as (storage_url, calls):
+        response = make_client().storage_session.put(f"{storage_url}/blob", data=b"payload")
+
+    assert response.status_code == 200
+    assert calls["PUT"] == 2
+
+
+def test_api_post_body_is_not_replayed_after_status_failure() -> None:
+    with retry_test_server([503, 200]) as (api_url, calls):
+        response = make_client(api_url).post("/ingestion", data=b"payload")
+
+    assert response.status_code == 503
+    assert calls["POST"] == 1

{marpledata-3.2.0 → marpledata-3.2.2}/uv.lock

@@ -599,7 +599,7 @@ wheels = [
 
 [[package]]
 name = "marpledata"
-version = "3.2.0"
+version = "3.2.2"
 source = { editable = "." }
 dependencies = [
     { name = "azure-storage-blob" },