redcedar 0.93.0__py3-none-any.whl

redcedar/__init__.py

@@ -0,0 +1,7 @@
+"""Red Cedar — Python client for the Red Cedar quantum ML server."""
+
+__version__ = "0.93.0"
+
+from .client import connect, RedCedarClient
+
+__all__ = ["connect", "RedCedarClient", "__version__"]

redcedar/__main__.py

@@ -0,0 +1,7 @@
+"""python -m redcedar — the same as the redcedar command."""
+
+import sys
+
+from .cli import main
+
+sys.exit(main())

redcedar/analysis.py

@@ -0,0 +1,74 @@
+"""Dataset analysis — PCA, Mutual Information, Resource Estimation."""
+
+
+class AnalysisManager:
+    """Run dataset analysis operations on the server."""
+
+    def __init__(self, client):
+        self._client = client
+
+    def pca(self, dataset_id, verbose=False, on_progress=None):
+        """Run PCA analysis on a dataset.
+
+        Args:
+            dataset_id: Dataset ID from the catalog (e.g., 'wdbc', 'iris').
+            verbose: Print progress to stdout; "log" also prints the server's log for the job.
+            on_progress: Callback(percent, message) for progress updates.
+
+        Returns:
+            Dict with variance_ratios, cumulative_variance, thresholds, etc.
+        """
+        if self._client.core:   # local mode: call the core directly
+            return self._client._run_local(self._client.core.pca, dataset_id,
+                                           verbose=verbose, on_progress=on_progress)
+        return self._client._run_job(
+            "/analysis/pca",
+            "/analysis/pca/{job_id}/stream",
+            body={"dataset_id": dataset_id},
+            verbose=verbose,
+            on_progress=on_progress,
+        )
+
+    def mi(self, dataset_id, verbose=False, on_progress=None):
+        """Run Mutual Information feature importance analysis.
+
+        Args:
+            dataset_id: Dataset ID from the catalog.
+            verbose: Print progress to stdout; "log" also prints the server's log for the job.
+            on_progress: Callback(percent, message) for progress updates.
+
+        Returns:
+            Dict with ranked_features, cumulative_mi, thresholds, etc.
+        """
+        if self._client.core:   # local mode: call the core directly
+            return self._client._run_local(self._client.core.mi, dataset_id,
+                                           verbose=verbose, on_progress=on_progress)
+        return self._client._run_job(
+            "/analysis/mi",
+            "/analysis/mi/{job_id}/stream",
+            body={"dataset_id": dataset_id},
+            verbose=verbose,
+            on_progress=on_progress,
+        )
+
+    def qre(self, dataset_id, verbose=False, on_progress=None):
+        """Run Quantum Resource Estimation.
+
+        Args:
+            dataset_id: Dataset ID from the catalog.
+            verbose: Print progress to stdout; "log" also prints the server's log for the job.
+            on_progress: Callback(percent, message) for progress updates.
+
+        Returns:
+            Dict with estimatedQubits, standardDeviation, plotData, etc.
+        """
+        if self._client.core:   # local mode: call the core directly
+            return self._client._run_local(self._client.core.qre, dataset_id,
+                                           verbose=verbose, on_progress=on_progress)
+        return self._client._run_job(
+            "/analysis/qre",
+            "/analysis/qre/{job_id}/stream",
+            body={"dataset_id": dataset_id},
+            verbose=verbose,
+            on_progress=on_progress,
+        )

redcedar/cli.py

@@ -0,0 +1,136 @@
+"""The redcedar command: train, evaluate and predict from the command line.
+
+    redcedar train my_data.csv --qubits 6 --seed 123
+    redcedar evaluate <train_id>
+    redcedar predict <train_id> new_data.csv -o predictions.csv
+    redcedar models
+    redcedar status
+
+The server comes from --url / --api-key, or REDCEDAR_URL / REDCEDAR_API_KEY.
+"""
+
+import argparse
+import sys
+
+import requests
+
+from .client import connect
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser(prog="redcedar", description="Red Cedar quantum machine learning")
+    p.add_argument("--url", help="server URL (default: REDCEDAR_URL or http://127.0.0.1:8002)")
+    p.add_argument("--api-key", help="API key (default: REDCEDAR_API_KEY)")
+    p.add_argument("--local", action="store_true",
+                   help="call the Red Cedar core directly in this process instead of a server "
+                        "(redcedar_core, installed with pip install -e, or the red-cedar folder "
+                        "in REDCEDAR_CORE_PATH)")
+    p.add_argument("-q", "--quiet", action="store_true", help="no progress output")
+    p.add_argument("--log", action="store_true", help="also print the server's log for the job")
+    sub = p.add_subparsers(dest="command", required=True)
+
+    t = sub.add_parser("train", help="train a model on a CSV file or catalog dataset")
+    t.add_argument("data", help="CSV file path or catalog dataset ID")
+    t.add_argument("--settings", help="settings file (.json or .toml)")
+    t.add_argument("--qubits", type=int, help="num_qubits")
+    t.add_argument("--layers", type=int, help="train layers 1 to N (min_layers=1, max_layers=N)")
+    t.add_argument("--seed", type=int, help="seed for the initial parameters")
+    t.add_argument("--backend", help="where the circuits run (default: statevector)")
+    t.add_argument("--task", choices=["classification", "regression"],
+                   help="default: detected from the target column")
+    t.add_argument("--test-size", type=float,
+                   help="held-out test rows, a fraction or a count (0 = train on all rows)")
+
+    e = sub.add_parser("evaluate", help="score a model on its held-out test rows")
+    e.add_argument("train_id")
+    e.add_argument("--layer", type=int)
+    e.add_argument("--backend")
+
+    r = sub.add_parser("predict", help="predictions for new rows")
+    r.add_argument("train_id")
+    r.add_argument("data", help="CSV file with the new rows")
+    r.add_argument("-o", "--output", help="write the rows and predictions to this CSV file")
+    r.add_argument("--layer", type=int)
+    r.add_argument("--backend")
+
+    sub.add_parser("models", help="list recently trained models")
+    sub.add_parser("status", help="check the server and show the server and SDK versions")
+
+    args = p.parse_args(argv)
+    client = connect(url=args.url, api_key=args.api_key, local=args.local or False)
+    verbose = False if args.quiet else "log" if args.log else True
+    run_settings = {"backend": args.backend} if getattr(args, "backend", None) else None
+
+    try:
+        if args.command == "train":
+            from .settings import load_settings
+            settings = load_settings(args.settings)
+            if args.qubits is not None:
+                settings["num_qubits"] = args.qubits
+            if args.layers is not None:
+                settings["min_layers"], settings["max_layers"] = 1, args.layers
+            if args.seed is not None:
+                settings["seed"] = args.seed
+            if args.backend:
+                settings["backend"] = args.backend
+            test_size = args.test_size
+            if test_size is not None and test_size >= 1:
+                test_size = int(test_size)
+            result = client.training.run(args.data, settings=settings, verbose=verbose,
+                                         task=args.task, test_size=test_size)
+            for layer, v in result.get("validation", {}).items():
+                if v.get("test_accuracy") is not None:
+                    print(f"Layer {layer}: test accuracy {v['test_accuracy']:.1%}")
+                elif v.get("test_loss") is not None:
+                    print(f"Layer {layer}: test loss {v['test_loss']:.4f}")
+                else:
+                    print(f"Layer {layer}: trained on all rows (no test set)")
+            print(f"train_id: {result['train_id']}")
+
+        elif args.command == "evaluate":
+            report = client.training.evaluate(args.train_id, layer=args.layer, verbose=verbose,
+                                              settings=run_settings)
+            if report.get("task") == "regression":
+                print(f"Mean absolute error {report['mean_absolute_error']:.4f}, "
+                      f"loss {report['overall_loss']:.4f} on {report['test_samples']} test rows")
+            else:
+                print(f"Accuracy {report['overall_accuracy']:.1%} on {report['test_samples']} test rows")
+            for c in report["per_class"]:
+                print(f"  class {c['class']}: {c['accuracy']:.1%} ({c['samples']} rows)")
+
+        elif args.command == "predict":
+            result = client.inference.run(args.train_id, args.data, layer=args.layer,
+                                          output=args.output, verbose=verbose,
+                                          settings=run_settings)
+            if args.output:
+                print(f"{result['rows']} predictions written to {args.output}")
+            else:
+                for p_row in result["predictions"]:
+                    print(p_row["prediction"])
+            if "accuracy" in result:
+                print(f"Accuracy on these rows: {result['accuracy']:.1%}")
+            if "mean_absolute_error" in result:
+                print(f"Mean absolute error on these rows: {result['mean_absolute_error']:.4f}")
+
+        elif args.command == "models":
+            for m in client.inference.models()["models"]:
+                print(m["train_id"], m.get("dataset_display_name") or m.get("dataset", ""),
+                      m.get("task", ""), f"{m.get('num_qubits')} qubits", f"layers {m.get('layers')}")
+
+        elif args.command == "status":
+            s = client.status()
+            print(f"Server: {client.url or 'none (local mode: the Red Cedar core in this process)'}")
+            print(f"Server version: {s['server_version'] or 'unknown'}")
+            print(f"SDK version: {s['sdk_version']}")
+            if not s["ok"]:
+                print(f"Error: {s['error']}", file=sys.stderr)
+                return 1
+
+    except (RuntimeError, requests.HTTPError, requests.ConnectionError, FileNotFoundError) as err:
+        print(f"Error: {err}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

redcedar/client.py

@@ -0,0 +1,366 @@
+"""Core client — HTTP requests, SSE streaming, authentication."""
+
+import os
+import sys
+import json
+import time
+import threading
+import requests
+
+from .datasets import DatasetManager
+from .analysis import AnalysisManager
+from .training import TrainingManager
+from .inference import InferenceManager
+from .explainable import ExplainableManager
+
+
+def connect(url=None, api_key=None, local=False):
+    """Create a RedCedarClient connected to the server.
+
+    Args:
+        url: Server URL. Defaults to REDCEDAR_URL env var or http://127.0.0.1:8002
+             (the port run_server uses).
+        api_key: API key. Defaults to REDCEDAR_API_KEY env var.
+        local: For development with the Red Cedar source. True calls the Red Cedar
+               core (redcedar_core, installed with `pip install -e .` in a
+               red-cedar folder) directly in this process, so a debugger steps into
+               the Red Cedar code. Or the path of a red-cedar folder to use.
+
+    Returns:
+        RedCedarClient instance.
+    """
+    if local:
+        from .local import import_core
+        return RedCedarClient(None, None, core=import_core(None if local is True else local))
+    url = url or os.environ.get("REDCEDAR_URL", "http://127.0.0.1:8002")
+    api_key = api_key or os.environ.get("REDCEDAR_API_KEY", "")
+    return RedCedarClient(url, api_key)
+
+
+def _raise_for_status(resp):
+    """Like resp.raise_for_status(), but the message includes the server's reason
+    ('detail' from the Red Cedar server, 'error' from the gateway)."""
+    if resp.ok:
+        return
+    try:
+        body = resp.json()
+        reason = body.get("detail") or body.get("error") if isinstance(body, dict) else None
+    except ValueError:
+        reason = None
+    msg = f"{resp.status_code} {resp.reason}"
+    if reason:
+        msg += f": {reason}"
+    raise requests.HTTPError(msg, response=resp)
+
+
+class _ProgressLine:
+    """A job's verbose output: one line, rewritten on each progress update, with a dot
+    added while the job is quiet so it's clear it's still working. The dots come every
+    2 seconds at first, every 5 after 20 seconds and every 10 after a minute, counted
+    from the last update."""
+
+    def __init__(self, out=None):
+        self._out = out or sys.stdout
+        self._lock = threading.Lock()
+        self._text = ""
+        self._ndots = 0
+        self._width = 0   # characters on the current line
+        self._restart()
+        self._stop = threading.Event()
+        threading.Thread(target=self._dots, daemon=True).start()
+
+    def _restart(self):
+        self._since = time.monotonic()
+        self._next = self._since + 2
+
+    def _draw(self):
+        """Write the whole line again, text and dots. Jupyter treats \\r as overwriting
+        the line from its start, so the line is always redrawn rather than added to;
+        trailing spaces clear what's left of a longer line."""
+        s = self._text + (" " + "." * self._ndots if self._ndots else "")
+        print(f"\r{s}{' ' * max(self._width - len(s), 0)}", end="", flush=True, file=self._out)
+        self._width = len(s)
+
+    def _dots(self):
+        while not self._stop.wait(0.5):
+            with self._lock:
+                now = time.monotonic()
+                if now >= self._next:
+                    self._ndots += 1
+                    self._draw()
+                    quiet = now - self._since
+                    self._next = now + (2 if quiet < 20 else 5 if quiet < 60 else 10)
+
+    def update(self, text):
+        """Rewrite the line with new text; the dots start again."""
+        with self._lock:
+            self._text, self._ndots = text, 0
+            self._draw()
+            self._restart()
+
+    def message(self, text):
+        """A line of its own (a log line, an error), below the progress line."""
+        with self._lock:
+            if self._width:
+                print(file=self._out)
+            print(text, flush=True, file=self._out)
+            self._text, self._ndots, self._width = "", 0, 0
+            self._restart()
+
+    def close(self):
+        self._stop.set()
+        with self._lock:
+            if self._width:
+                print(file=self._out)
+                self._text, self._ndots, self._width = "", 0, 0
+
+
+class RedCedarClient:
+    """Main client for interacting with the Red Cedar server."""
+
+    def __init__(self, url, api_key, core=None):
+        self.url = url.rstrip("/") if url else None
+        self.api_key = api_key
+        # Local mode (connect(local=True)): the redcedar_core module. Each SDK call then
+        # calls its core function directly instead of sending a request to a server.
+        self.core = core
+        self._last_job_id = None
+        self._server_version = None
+        self.datasets = DatasetManager(self)
+        self.analysis = AnalysisManager(self)
+        self.training = TrainingManager(self)
+        self.inference = InferenceManager(self)
+        self.explainable = ExplainableManager(self)
+
+    def _server(self, path=""):
+        """The server URL. Local mode has no server: every SDK call has a direct one."""
+        if self.url is None:
+            raise NotImplementedError(f"Local mode has no direct call for {path}")
+        return self.url
+
+    def _headers(self):
+        h = {"Content-Type": "application/json"}
+        if self.api_key:
+            h["x-api-key"] = self.api_key
+        return h
+
+    def _local_call(self, fn, *args, **kwargs):
+        """Call a redcedar_core function (local mode). Something not found, or a bad
+        request, raises requests.HTTPError with the server's message, as in server mode."""
+        try:
+            return fn(*args, **kwargs)
+        except FileNotFoundError as e:
+            raise requests.HTTPError(f"404 Not Found: {e}") from e
+        except ValueError as e:
+            raise requests.HTTPError(f"400 Bad Request: {e}") from e
+
+    def _run_local(self, fn, *args, verbose=False, on_progress=None, events=None, **kwargs):
+        """Run a redcedar_core job function in this thread (local mode). Its events go
+        to the same handler as a server job's: progress, log lines (verbose="log"), and the
+        other events into the events list. Returns the job's result."""
+        out = sys.stdout   # while the job runs, print() goes to its log
+        line = _ProgressLine(out) if verbose else None
+        on_event = lambda e: self._handle_event(e, verbose, on_progress, events, line)  # noqa: E731
+        try:
+            return self._local_call(fn, *args, on_event=on_event, **kwargs)
+        finally:
+            if line:
+                line.close()
+
+    def _get(self, path):
+        resp = requests.get(f"{self._server(path)}{path}", headers=self._headers())
+        _raise_for_status(resp)
+        return resp.json()
+
+    def _post(self, path, body=None):
+        resp = requests.post(
+            f"{self._server(path)}{path}",
+            headers=self._headers(),
+            json=body or {},
+        )
+        _raise_for_status(resp)
+        return resp.json()
+
+    def _post_file(self, path, file_path):
+        """Upload a file as multipart form data (field name 'file')."""
+        headers = {"x-api-key": self.api_key} if self.api_key else {}
+        with open(file_path, "rb") as f:
+            resp = requests.post(
+                f"{self._server(path)}{path}",
+                headers=headers,
+                files={"file": (os.path.basename(file_path), f)},
+            )
+        _raise_for_status(resp)
+        return resp.json()
+
+    def _open_stream(self, path, line=None):
+        """Open a job's SSE stream. A queued job has no stream until it starts
+        (the server answers 404), so wait for it to start."""
+        waiting = False
+        while True:
+            resp = requests.get(
+                f"{self._server(path)}{path}",
+                headers=self._headers(),
+                stream=True,
+            )
+            if resp.status_code != 404:
+                _raise_for_status(resp)
+                return resp
+            resp.close()
+
+            # Also launches the next queued job on servers that only do so on a request.
+            qs = self._get("/jobs/status")
+            if not qs.get("total"):
+                # Nothing queued or running, so the job is gone
+                _raise_for_status(resp)
+            if line and not waiting:
+                line.update("  Waiting in queue...")
+            waiting = True
+            time.sleep(2)
+
+    def _stream_sse(self, path, line=None):
+        """Consume an SSE stream, yielding parsed events."""
+        resp = self._open_stream(path, line)
+
+        event_type = "message"
+        data_buf = ""
+
+        for line in resp.iter_lines(decode_unicode=True):
+            if line is None:
+                continue
+            if line == "":
+                # End of event
+                if data_buf:
+                    try:
+                        parsed = json.loads(data_buf)
+                        parsed["_event"] = event_type
+                        yield parsed
+                    except json.JSONDecodeError:
+                        pass
+                event_type = "message"
+                data_buf = ""
+            elif line.startswith("event: "):
+                event_type = line[7:]
+            elif line.startswith("data: "):
+                data_buf = line[6:]
+
+    def _run_job(self, post_path, stream_path, body=None, verbose=False, on_progress=None,
+                 events=None):
+        """Start a job via POST, consume SSE until done. Returns summary.
+
+        If events is a list, every other event the job sends (e.g. training
+        datapoints and validation results) is appended to it."""
+        result = self._post(post_path, body)
+        job_id = result.get("job_id") or result.get("train_id")
+        self._last_job_id = job_id
+        if not job_id:
+            return result
+
+        # Trigger server-side queue cleanup and job launch before connecting
+        # to SSE. Without this, stale queue entries from prior jobs block
+        # new jobs from starting and training_state is never populated.
+        try:
+            self._get("/jobs/status")
+        except Exception:
+            pass
+
+        line = _ProgressLine() if verbose else None
+        try:
+            for event in self._stream_sse(stream_path.format(job_id=job_id), line):
+                self._handle_event(event, verbose, on_progress, events, line)
+                etype = event.get("_event", event.get("type", ""))
+                if etype == "done":
+                    return event.get("summary", event)
+                elif etype == "error":
+                    raise RuntimeError(event.get("message", "Job failed"))
+                elif etype == "stopped":
+                    raise RuntimeError(event.get("message", "Job stopped"))
+        finally:
+            if line:
+                line.close()
+
+        raise RuntimeError("SSE stream ended without done/error event")
+
+    def _handle_event(self, event, verbose, on_progress, events, line=None):
+        """Report one job event: progress and messages (verbose; the server's log lines
+        only with verbose="log"), the on_progress callback, and the other events into
+        the events list. line is the job's _ProgressLine when verbose."""
+        etype = event.get("_event", event.get("type", ""))
+
+        if etype == "progress":
+            pct = event.get("percent", 0)
+            msg = event.get("message", "")
+            if verbose:
+                line.update(f"  [{pct:3d}%] {msg}")
+            if on_progress:
+                on_progress(pct, msg)
+
+        elif etype == "done":
+            if verbose:
+                line.update("  [100%] Done.")
+                line.close()
+
+        elif etype == "log":
+            if verbose == "log":
+                msg = event.get("message", "")
+                if msg:
+                    line.message(f"  {msg}")
+
+        elif etype == "error":
+            if verbose:
+                line.message(f"  ERROR: {event.get('message', 'Job failed')}")
+
+        elif etype == "stopped":
+            if verbose:
+                line.message(f"  {event.get('message', 'Job stopped')}")
+
+        else:
+            # A training layer's test result
+            if etype == "validation" and verbose:
+                acc, loss = event.get("test_accuracy"), event.get("test_loss")
+                if acc is not None:
+                    line.message(f"  Layer {event.get('layer')}: test accuracy {acc:.1%}")
+                elif loss is not None:
+                    line.message(f"  Layer {event.get('layer')}: test loss {loss:.4f}")
+            if events is not None:
+                events.append(event)
+
+    def status(self):
+        """Check the server, and which versions are in use.
+
+        Returns:
+            Dict with 'ok', 'server_version' (None if the server doesn't report
+            one) and 'sdk_version' (this package's version; its major.minor
+            follows the server's), plus 'error' when 'ok' is False. In local
+            mode, server_version is the version of the Red Cedar code in use.
+        """
+        from . import __version__
+        if self.core:
+            return {"ok": True, "server_version": self.core.version(), "sdk_version": __version__}
+        try:
+            resp = requests.get(f"{self._server('/health')}/health", headers=self._headers(), timeout=5)
+        except requests.ConnectionError:
+            return {"ok": False, "server_version": None, "sdk_version": __version__,
+                    "error": "Cannot reach server"}
+        try:
+            body = resp.json()
+        except ValueError:
+            body = {}
+        if not isinstance(body, dict):
+            body = {}
+        # Through the gateway (/api/health) the server's answer is under "backend"
+        server = body.get("backend", body)
+        if not isinstance(server, dict):
+            server = {}
+        ok = resp.status_code == 200 and server.get("status") == "ok"
+        result = {"ok": ok, "server_version": server.get("version"), "sdk_version": __version__}
+        if not ok:
+            result["error"] = server.get("error") or f"HTTP {resp.status_code}"
+        return result
+
+    @property
+    def server_version(self):
+        """The version of the server this client is connected to (asked once)."""
+        if self._server_version is None:
+            self._server_version = self.status().get("server_version")
+        return self._server_version

redcedar/datasets.py

@@ -0,0 +1,45 @@
+"""Dataset listing and selection."""
+
+import os
+
+
+class DatasetManager:
+    """Access the dataset catalog on the server."""
+
+    def __init__(self, client):
+        self._client = client
+
+    def list(self):
+        """List all available datasets in the catalog.
+
+        Returns:
+            List of dataset dicts with id, name, description, rows, columns, classes.
+        """
+        if self._client.core:   # local mode: call the core directly
+            return self._client.core.datasets()
+        return self._client._get("/datasets")
+
+    def upload(self, file_path):
+        """Upload a CSV file to the server for training.
+
+        The last column is the target (class label); a header row is optional.
+
+        Args:
+            file_path: Path to a local .csv file.
+
+        Returns:
+            The dataset ID to pass to training.run().
+        """
+        if self._client.core:
+            return self._client._local_call(self._client.core.upload, file_path)
+        return self._client._post_file("/upload", file_path)["jobId"]
+
+    def _as_id(self, data):
+        """A CSV file path is uploaded and replaced by its dataset ID; anything
+        else (a catalog ID or an upload ID) is returned as it is."""
+        if isinstance(data, os.PathLike) or (isinstance(data, str) and os.path.isfile(data)):
+            return self.upload(os.fspath(data))
+        # IDs never end in .csv, so this is a file path that doesn't exist
+        if isinstance(data, str) and data.lower().endswith(".csv"):
+            raise FileNotFoundError(f"No such file: {data}")
+        return data

redcedar/explainable.py

@@ -0,0 +1,38 @@
+"""Explainable AI — identify which features drive classification."""
+
+
+class ExplainableManager:
+    """Run explainable AI analysis on trained models."""
+
+    def __init__(self, client):
+        self._client = client
+
+    def run(self, train_id, verbose=False, on_progress=None, settings=None):
+        """Run explainable AI analysis on a trained model.
+
+        Constructs quantum circuits to identify which input
+        features are most important for classification decisions.
+
+        Args:
+            train_id: Training job ID (from training.run() result).
+            verbose: Print progress to stdout; "log" also prints the server's log for the job.
+            on_progress: Callback(percent, message) for progress updates.
+            settings: Optional dict of runtime overrides (e.g. backend, parallelize).
+
+        Returns:
+            Dict with qubit_map (feature importance per qubit),
+            distributions, convergence values, feature_indices, etc.
+        """
+        if self._client.core:   # local mode: call the core directly
+            return self._client._run_local(self._client.core.explain, train_id, settings=settings,
+                                           verbose=verbose, on_progress=on_progress)
+        body = {"train_id": train_id, "user_id": "sdk"}
+        if settings:
+            body["settings"] = settings
+        return self._client._run_job(
+            "/applications/explainable",
+            "/applications/explainable/{job_id}/stream",
+            body=body,
+            verbose=verbose,
+            on_progress=on_progress,
+        )