featurecanvas 0.1.0__py3-none-any.whl

featurecanvas/__init__.py

@@ -0,0 +1,4 @@
+from .client import FeatureCanvas, Session, Node
+
+__version__ = "0.1.0"
+__all__ = ["FeatureCanvas", "Session", "Node"]

featurecanvas/client.py

@@ -0,0 +1,252 @@
+"""
+FeatureCanvas Python SDK client.
+
+Wraps the FeatureCanvas REST API so you can build feature pipelines in code,
+run them, and export generated Python scripts — all without opening a browser.
+"""
+from __future__ import annotations
+
+import io
+from pathlib import Path
+from typing import Any
+
+import requests
+
+
+class FeatureCanvas:
+    """Entry point. Create one per backend URL.
+
+    Args:
+        base_url: URL of your deployed FeatureCanvas backend, e.g.
+                  "https://featurecanvas.onrender.com"
+        timeout:  Request timeout in seconds (default 60 — transforms on large
+                  datasets can take a moment on a cold Render instance).
+    """
+
+    def __init__(self, base_url: str, timeout: int = 60):
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._session = requests.Session()
+
+    def _get(self, path: str, **kwargs) -> Any:
+        resp = self._session.get(f"{self.base_url}{path}", timeout=self.timeout, **kwargs)
+        resp.raise_for_status()
+        return resp.json()
+
+    def _post(self, path: str, **kwargs) -> Any:
+        resp = self._session.post(f"{self.base_url}{path}", timeout=self.timeout, **kwargs)
+        resp.raise_for_status()
+        return resp.json()
+
+    def health(self) -> dict:
+        """Check if the backend is reachable."""
+        return self._get("/api/health")
+
+    def transforms(self) -> list[dict]:
+        """List all available transforms with their keys and param schemas."""
+        return self._get("/api/transforms")["transforms"]
+
+    def upload(self, path: str | Path) -> "Session":
+        """Upload a CSV file and return a Session you can build transforms on.
+
+        Args:
+            path: Local path to a .csv file.
+
+        Returns:
+            Session object bound to the new session ID.
+
+        Example:
+            session = fc.upload("data/train.csv")
+        """
+        p = Path(path)
+        if not p.exists():
+            raise FileNotFoundError(f"CSV not found: {path}")
+        with open(p, "rb") as f:
+            resp = self._session.post(
+                f"{self.base_url}/api/upload",
+                files={"file": (p.name, f, "text/csv")},
+                timeout=self.timeout,
+            )
+        resp.raise_for_status()
+        data = resp.json()
+        return Session(client=self, session_id=data["session_id"], _profile=data["profile"])
+
+
+class Session:
+    """A FeatureCanvas session tied to one uploaded dataset.
+
+    Don't construct this directly — use ``FeatureCanvas.upload()``.
+    """
+
+    def __init__(self, client: FeatureCanvas, session_id: str, _profile: dict):
+        self._client = client
+        self.session_id = session_id
+        self._profile = _profile
+        self.target_col: str | None = None
+
+    def profile(self) -> dict:
+        """Column stats for the raw uploaded data."""
+        return self._profile
+
+    def columns(self, parent_id: str | None = None) -> list[str]:
+        """Columns available at a given point in the graph.
+
+        Args:
+            parent_id: Backend node ID to scope to. None = raw upload columns.
+        """
+        params = {}
+        if parent_id:
+            params["parent_id"] = parent_id
+        return self._client._get(f"/api/columns/{self.session_id}", params=params)["columns"]
+
+    def set_target(self, column: str, has_train_test_split: bool = False) -> "Session":
+        """Set the target column for impact scoring and leakage detection.
+
+        Returns self so you can chain: ``session.set_target("churned").apply(...)``
+        """
+        self._client._post("/api/target", json={
+            "session_id": self.session_id,
+            "target_column": column,
+            "has_train_test_split": has_train_test_split,
+        })
+        self.target_col = column
+        return self
+
+    def apply(
+        self,
+        transform_key: str,
+        parent_id: str | None = None,
+        **params,
+    ) -> "Node":
+        """Apply a transform and return a Node representing its output.
+
+        Args:
+            transform_key: One of the transform keys from ``fc.transforms()``,
+                           e.g. "log", "standard_scale", "frequency_encode".
+            parent_id:     Backend node ID to attach to. None = attach to the
+                           raw uploaded data (root of the graph).
+            **params:      Transform parameters, e.g. ``column="age"``,
+                           ``n_bins=10``, ``strategy="quantile"``.
+
+        Returns:
+            Node — call ``.apply()`` on it to chain further transforms,
+            ``.profile()`` to inspect output stats, or ``.code()`` to export.
+
+        Example:
+            node = session.apply("log", column="monthly_income")
+            node2 = node.apply("standard_scale", column="monthly_income_log")
+        """
+        result = self._client._post("/api/transform/apply", json={
+            "session_id": self.session_id,
+            "transform_key": transform_key,
+            "params": params,
+            "parent_id": parent_id,
+        })
+        return Node(
+            session=self,
+            node_id=result["node_id"],
+            transform_key=transform_key,
+            params=params,
+            output_columns=result["output_columns"],
+            _profile=result["profile"],
+            _leakage=result["leakage_findings"],
+            _quick_scores=result.get("quick_scores", {}),
+        )
+
+
+class Node:
+    """A single applied transform node in the pipeline graph.
+
+    Chain further transforms with ``.apply()``, or read results with
+    ``.profile()``, ``.leakage()``, ``.code()``, ``.scores()``.
+    """
+
+    def __init__(
+        self,
+        session: Session,
+        node_id: str,
+        transform_key: str,
+        params: dict,
+        output_columns: list[str],
+        _profile: dict,
+        _leakage: list[dict],
+        _quick_scores: dict,
+    ):
+        self._session = session
+        self.node_id = node_id
+        self.transform_key = transform_key
+        self.params = params
+        self.output_columns = output_columns
+        self._profile = _profile
+        self._leakage = _leakage
+        self._quick_scores = _quick_scores
+
+    def apply(self, transform_key: str, **params) -> "Node":
+        """Chain a new transform onto this node's output.
+
+        This node becomes the parent — the new transform only sees columns
+        that exist at this point in the graph, not sibling branches.
+
+        Example:
+            log_node = session.apply("log", column="income")
+            scaled = log_node.apply("standard_scale", column="income_log")
+        """
+        return self._session.apply(
+            transform_key=transform_key,
+            parent_id=self.node_id,
+            **params,
+        )
+
+    def profile(self) -> dict:
+        """Column stats for this node's output dataframe."""
+        return self._profile
+
+    def columns(self) -> list[str]:
+        """Column names available at this node's output."""
+        return [c["name"] for c in self._profile["columns"]]
+
+    def leakage(self) -> list[dict]:
+        """Leakage findings scoped to this node's branch."""
+        return self._leakage
+
+    def scores(self) -> dict:
+        """Quick MI/correlation scores for each output column against the target."""
+        return self._quick_scores
+
+    def has_leakage(self, severity: str = "high") -> bool:
+        """True if any leakage finding at or above the given severity exists."""
+        order = {"low": 0, "medium": 1, "high": 2}
+        threshold = order.get(severity, 2)
+        return any(order.get(f["severity"], 0) >= threshold for f in self._leakage)
+
+    def code(self) -> str:
+        """Export the Python script for this node's entire branch — ready to
+        paste into a notebook or production pipeline with no FeatureCanvas dependency."""
+        resp = self._session._client._session.get(
+            f"{self._session._client.base_url}/api/export/code/{self._session.session_id}",
+            params={"node_id": self.node_id},
+            timeout=self._session._client.timeout,
+        )
+        resp.raise_for_status()
+        return resp.text
+
+    def spec(self) -> dict:
+        """Export the portable JSON spec for this node's branch."""
+        return self._session._client._get(
+            f"/api/export/spec/{self._session.session_id}",
+            params={"node_id": self.node_id},
+        )
+
+    def remove(self) -> None:
+        """Remove this node and all its descendants from the session graph."""
+        self._session._client._post("/api/transform/remove", json={
+            "session_id": self._session.session_id,
+            "node_id": self.node_id,
+        })
+
+    def __repr__(self) -> str:
+        return (
+            f"Node(transform={self.transform_key!r}, "
+            f"output_columns={self.output_columns!r}, "
+            f"leakage_findings={len(self._leakage)})"
+        )

featurecanvas-0.1.0.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: featurecanvas
+Version: 0.1.0
+Summary: Python SDK for FeatureCanvas — the no-code feature engineering studio
+Author-email: "G. Preetham Saxon" <gpreethamsaxon@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/GPREETHAMSAXON/FeatureCanvas
+Project-URL: Documentation, https://github.com/GPREETHAMSAXON/FeatureCanvas#readme
+Keywords: feature-engineering,machine-learning,data-science,featurecanvas
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0

featurecanvas-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+featurecanvas/__init__.py,sha256=v6w5Wxq_7yMNJCYGM7JaIJPSODiVSOxAsCAsTeZ7gg0,121
+featurecanvas/client.py,sha256=zfZoONfIhh3hNb44ATyshHzqx2avdgdRIOcLKFaNibQ,9138
+featurecanvas-0.1.0.dist-info/METADATA,sha256=Jv8XqGkjrV6CV89VHm0cowKfsJKwKxesb1x-y4ANchQ,771
+featurecanvas-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+featurecanvas-0.1.0.dist-info/top_level.txt,sha256=JIiFx4DrGhtl7zOqHBeYYK1mX5MmEGx64636iJ6zxWs,14
+featurecanvas-0.1.0.dist-info/RECORD,,

featurecanvas-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

featurecanvas-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+featurecanvas