reliafy-client 0.1.0__tar.gz

reliafy_client-0.1.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: reliafy-client
+Version: 0.1.0
+Summary: Push SurPyval models to Reliafy — shareable, trackable, citable reliability analyses.
+Author: Reliafy
+License: AGPL-3.0-or-later
+Project-URL: Homepage, https://reliafy.com
+Project-URL: Source, https://github.com/Reliafy/reliafy
+Project-URL: Documentation, https://github.com/Reliafy/reliafy/blob/main/python/README.md
+Keywords: reliability,survival-analysis,weibull,surpyval,maintenance
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# reliafy — push SurPyval models to Reliafy
+
+Fit a model anywhere with [SurPyval](https://github.com/derrynknife/SurPyval),
+then make it a shareable, trackable, citable artifact in
+[Reliafy](https://reliafy.com) with one call. The notebook is the lab;
+Reliafy is the plant.
+
+```bash
+pip install reliafy-client
+```
+
+(The package installs as `reliafy-client`; you import it as `reliafy`.)
+
+## Quick start
+
+```python
+import surpyval as sp
+import reliafy
+
+# Fit however you like — censored data, offsets, whatever.
+model = sp.Weibull.fit(x=failures, c=censoring_flags)
+
+reliafy.configure(token="rlf_...")            # from Reliafy → API access (Pro)
+url = reliafy.push(model, name="Pump bearings — 2026 refit", unit="hours")
+print(url)                                    # open it in Reliafy
+```
+
+`push()` uploads the model **and its fitted data** by default, so Reliafy
+shows the full probability plot with confidence bounds — and the model stays
+editable and refittable in the app, and can be cited as RCM evidence, used in
+RBD blocks, or tracked against a fleet.
+
+Offset / limited-failure-population / zero-inflated fits are detected
+automatically from the model and reproduced.
+
+## Options
+
+```python
+# Parameters only (no data upload): functions & life metrics, no plot.
+reliafy.push(model, name="From a report", data=False)
+
+# No SurPyval object — just numbers:
+reliafy.push_params("weibull", [1200.0, 2.3], name="Handbook value", unit="hours")
+
+# Self-hosted instance:
+reliafy.configure(token="rlf_...", base_url="https://reliafy.mycompany.com")
+```
+
+Configuration also reads `RELIAFY_TOKEN` and `RELIAFY_BASE_URL` from the
+environment.
+
+## Notes
+
+- The token is a personal API token, created on the **API access** page in
+  Reliafy. On Reliafy Cloud this is a Pro feature; self-hosted instances have
+  it unconditionally.
+- Supported distributions: Weibull, Exponential, Normal, LogNormal, Gamma,
+  LogLogistic, Exponentiated Weibull, Gumbel, Logistic.
+- Pure standard library — no dependencies. You bring SurPyval to do the fit.

reliafy_client-0.1.0/README.md

@@ -0,0 +1,59 @@
+# reliafy — push SurPyval models to Reliafy
+
+Fit a model anywhere with [SurPyval](https://github.com/derrynknife/SurPyval),
+then make it a shareable, trackable, citable artifact in
+[Reliafy](https://reliafy.com) with one call. The notebook is the lab;
+Reliafy is the plant.
+
+```bash
+pip install reliafy-client
+```
+
+(The package installs as `reliafy-client`; you import it as `reliafy`.)
+
+## Quick start
+
+```python
+import surpyval as sp
+import reliafy
+
+# Fit however you like — censored data, offsets, whatever.
+model = sp.Weibull.fit(x=failures, c=censoring_flags)
+
+reliafy.configure(token="rlf_...")            # from Reliafy → API access (Pro)
+url = reliafy.push(model, name="Pump bearings — 2026 refit", unit="hours")
+print(url)                                    # open it in Reliafy
+```
+
+`push()` uploads the model **and its fitted data** by default, so Reliafy
+shows the full probability plot with confidence bounds — and the model stays
+editable and refittable in the app, and can be cited as RCM evidence, used in
+RBD blocks, or tracked against a fleet.
+
+Offset / limited-failure-population / zero-inflated fits are detected
+automatically from the model and reproduced.
+
+## Options
+
+```python
+# Parameters only (no data upload): functions & life metrics, no plot.
+reliafy.push(model, name="From a report", data=False)
+
+# No SurPyval object — just numbers:
+reliafy.push_params("weibull", [1200.0, 2.3], name="Handbook value", unit="hours")
+
+# Self-hosted instance:
+reliafy.configure(token="rlf_...", base_url="https://reliafy.mycompany.com")
+```
+
+Configuration also reads `RELIAFY_TOKEN` and `RELIAFY_BASE_URL` from the
+environment.
+
+## Notes
+
+- The token is a personal API token, created on the **API access** page in
+  Reliafy. On Reliafy Cloud this is a Pro feature; self-hosted instances have
+  it unconditionally.
+- Supported distributions: Weibull, Exponential, Normal, LogNormal, Gamma,
+  LogLogistic, Exponentiated Weibull, Gumbel, Logistic.
+- Pure standard library — no dependencies. You bring SurPyval to do the fit.

reliafy_client-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+# Distribution name is reliafy-client (the bare `reliafy` name is taken on
+# PyPI by an unrelated project); the import package stays `import reliafy`.
+name = "reliafy-client"
+version = "0.1.0"
+description = "Push SurPyval models to Reliafy — shareable, trackable, citable reliability analyses."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "AGPL-3.0-or-later" }
+authors = [{ name = "Reliafy" }]
+keywords = ["reliability", "survival-analysis", "weibull", "surpyval", "maintenance"]
+dependencies = []          # stdlib only; SurPyval is optional (yours to fit with)
+
+[project.urls]
+Homepage = "https://reliafy.com"
+Source = "https://github.com/Reliafy/reliafy"
+Documentation = "https://github.com/Reliafy/reliafy/blob/main/python/README.md"
+
+[tool.setuptools]
+packages = ["reliafy"]

reliafy_client-0.1.0/reliafy/__init__.py

@@ -0,0 +1,173 @@
+"""reliafy — push SurPyval models to Reliafy.
+
+Build a model in a notebook with SurPyval, then make it a shareable,
+trackable, citable artifact in Reliafy with one call:
+
+    import surpyval as sp
+    import reliafy
+
+    model = sp.Weibull.fit(x=my_data)
+
+    reliafy.configure(token="rlf_...")           # from the API access page
+    url = reliafy.push(model, name="Pump bearings")
+    print(url)                                    # open it in the app
+
+The token is a personal API token (Reliafy Cloud → API access; a Pro
+feature). Self-hosted instances pass ``base_url`` to point at your server.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.request
+
+__all__ = ["configure", "push", "push_params", "ReliafyError"]
+
+_DEFAULT_BASE = "https://reliafy.com"
+
+# SurPyval distribution name -> Reliafy id (the server also resolves these,
+# but mapping here gives a clear error before the network call).
+_DIST_MAP = {
+    "Weibull": "weibull",
+    "Exponential": "exponential",
+    "Normal": "normal",
+    "LogNormal": "lognormal",
+    "Gamma": "gamma",
+    "LogLogistic": "loglogistic",
+    "ExpoWeibull": "expo_weibull",
+    "Gumbel": "gumbel",
+    "Logistic": "logistic",
+}
+
+_config = {
+    "token": os.environ.get("RELIAFY_TOKEN"),
+    "base_url": os.environ.get("RELIAFY_BASE_URL", _DEFAULT_BASE),
+}
+
+
+class ReliafyError(RuntimeError):
+    pass
+
+
+def configure(token: str | None = None, base_url: str | None = None) -> None:
+    """Set the API token and (optionally) the base URL for later calls.
+
+    Both also read from ``RELIAFY_TOKEN`` / ``RELIAFY_BASE_URL`` in the
+    environment.
+    """
+    if token is not None:
+        _config["token"] = token
+    if base_url is not None:
+        _config["base_url"] = base_url.rstrip("/")
+
+
+def _dist_name(model) -> str:
+    dist = getattr(model, "dist", None)
+    name = getattr(dist, "name", None) or type(dist).__name__.rstrip("_")
+    if name not in _DIST_MAP:
+        raise ReliafyError(
+            f"Distribution {name!r} isn't supported by Reliafy import. "
+            f"Supported: {', '.join(sorted(_DIST_MAP))}."
+        )
+    return _DIST_MAP[name]
+
+
+def _extract(model, include_data: bool):
+    """Pull distribution, params, data, and extras off a fitted SurPyval model."""
+    body = {
+        "distribution": _dist_name(model),
+        "params": [{"value": float(v)} for v in list(model.params)],
+    }
+    extras = {}
+    for attr, default in (("gamma", 0.0), ("p", 1.0), ("f0", 0.0)):
+        val = getattr(model, attr, None)
+        if val is not None and float(val) != default:
+            extras[attr] = float(val)
+    if extras:
+        body["extras"] = extras
+        # Also flag the equivalent options so a data-backed refit reproduces them.
+        body["options"] = {
+            "offset": "gamma" in extras, "lfp": "p" in extras, "zi": "f0" in extras,
+        }
+
+    data = getattr(model, "data", None)
+    if include_data and data is not None and data.get("x") is not None:
+        out = {"x": [float(v) for v in data["x"]]}
+        c = data.get("c")
+        if c is not None and any(int(v) != 0 for v in c):
+            out["c"] = [int(v) for v in c]
+        n = data.get("n")
+        if n is not None and any(int(v) != 1 for v in n):
+            out["n"] = [int(v) for v in n]
+        body["data"] = out
+    return body
+
+
+def _post(payload: dict) -> dict:
+    token = _config.get("token")
+    if not token:
+        raise ReliafyError(
+            "No API token. Call reliafy.configure(token='rlf_...') or set "
+            "RELIAFY_TOKEN. Create a token on the API access page (Pro)."
+        )
+    url = _config["base_url"].rstrip("/") + "/api/import/models"
+    req = urllib.request.Request(
+        url,
+        data=json.dumps(payload).encode(),
+        headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=60) as resp:
+            result = json.loads(resp.read())
+    except urllib.error.HTTPError as exc:
+        try:
+            detail = json.loads(exc.read()).get("detail", exc.reason)
+        except Exception:
+            detail = exc.reason
+        raise ReliafyError(f"Reliafy returned {exc.code}: {detail}") from None
+    except urllib.error.URLError as exc:
+        raise ReliafyError(f"Couldn't reach Reliafy at {url}: {exc.reason}") from None
+    return result
+
+
+def push(model, name: str, *, data: bool = True, unit: str | None = None) -> str:
+    """Push a fitted SurPyval model to Reliafy; return the URL to open it.
+
+    ``data=True`` (default) uploads the model's fitted observations too, so
+    Reliafy shows the full probability plot and the model stays editable and
+    refittable. ``data=False`` uploads parameters only.
+    """
+    if not name or not str(name).strip():
+        raise ReliafyError("A name is required.")
+    body = _extract(model, include_data=data)
+    body["name"] = str(name).strip()
+    if unit:
+        body["unit"] = unit
+    result = _post(body)
+    return _config["base_url"].rstrip("/") + result["url"]
+
+
+def push_params(distribution: str, params, name: str, *, unit: str | None = None,
+                extras: dict | None = None) -> str:
+    """Push a model by distribution + parameter values (no SurPyval object).
+
+    ``params`` is a sequence of numbers in the distribution's natural order,
+    or a list of ``{"name": ..., "value": ...}`` dicts. ``extras`` may hold
+    ``gamma``/``p``/``f0`` for offset/LFP/zero-inflated models.
+    """
+    norm = []
+    for p in params:
+        if isinstance(p, dict):
+            norm.append({"value": float(p["value"]), **({"name": p["name"]} if "name" in p else {})})
+        else:
+            norm.append({"value": float(p)})
+    body = {"name": str(name).strip(), "distribution": distribution, "params": norm}
+    if unit:
+        body["unit"] = unit
+    if extras:
+        body["extras"] = {k: float(v) for k, v in extras.items()}
+    result = _post(body)
+    return _config["base_url"].rstrip("/") + result["url"]

reliafy_client-0.1.0/reliafy_client.egg-info/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: reliafy-client
+Version: 0.1.0
+Summary: Push SurPyval models to Reliafy — shareable, trackable, citable reliability analyses.
+Author: Reliafy
+License: AGPL-3.0-or-later
+Project-URL: Homepage, https://reliafy.com
+Project-URL: Source, https://github.com/Reliafy/reliafy
+Project-URL: Documentation, https://github.com/Reliafy/reliafy/blob/main/python/README.md
+Keywords: reliability,survival-analysis,weibull,surpyval,maintenance
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# reliafy — push SurPyval models to Reliafy
+
+Fit a model anywhere with [SurPyval](https://github.com/derrynknife/SurPyval),
+then make it a shareable, trackable, citable artifact in
+[Reliafy](https://reliafy.com) with one call. The notebook is the lab;
+Reliafy is the plant.
+
+```bash
+pip install reliafy-client
+```
+
+(The package installs as `reliafy-client`; you import it as `reliafy`.)
+
+## Quick start
+
+```python
+import surpyval as sp
+import reliafy
+
+# Fit however you like — censored data, offsets, whatever.
+model = sp.Weibull.fit(x=failures, c=censoring_flags)
+
+reliafy.configure(token="rlf_...")            # from Reliafy → API access (Pro)
+url = reliafy.push(model, name="Pump bearings — 2026 refit", unit="hours")
+print(url)                                    # open it in Reliafy
+```
+
+`push()` uploads the model **and its fitted data** by default, so Reliafy
+shows the full probability plot with confidence bounds — and the model stays
+editable and refittable in the app, and can be cited as RCM evidence, used in
+RBD blocks, or tracked against a fleet.
+
+Offset / limited-failure-population / zero-inflated fits are detected
+automatically from the model and reproduced.
+
+## Options
+
+```python
+# Parameters only (no data upload): functions & life metrics, no plot.
+reliafy.push(model, name="From a report", data=False)
+
+# No SurPyval object — just numbers:
+reliafy.push_params("weibull", [1200.0, 2.3], name="Handbook value", unit="hours")
+
+# Self-hosted instance:
+reliafy.configure(token="rlf_...", base_url="https://reliafy.mycompany.com")
+```
+
+Configuration also reads `RELIAFY_TOKEN` and `RELIAFY_BASE_URL` from the
+environment.
+
+## Notes
+
+- The token is a personal API token, created on the **API access** page in
+  Reliafy. On Reliafy Cloud this is a Pro feature; self-hosted instances have
+  it unconditionally.
+- Supported distributions: Weibull, Exponential, Normal, LogNormal, Gamma,
+  LogLogistic, Exponentiated Weibull, Gumbel, Logistic.
+- Pure standard library — no dependencies. You bring SurPyval to do the fit.

reliafy_client-0.1.0/reliafy_client.egg-info/SOURCES.txt

@@ -0,0 +1,7 @@
+README.md
+pyproject.toml
+reliafy/__init__.py
+reliafy_client.egg-info/PKG-INFO
+reliafy_client.egg-info/SOURCES.txt
+reliafy_client.egg-info/dependency_links.txt
+reliafy_client.egg-info/top_level.txt

reliafy_client-0.1.0/reliafy_client.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

reliafy_client-0.1.0/reliafy_client.egg-info/top_level.txt

@@ -0,0 +1 @@
+reliafy

reliafy_client-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+