semanticembed 0.1.0__py3-none-any.whl

semanticembed/__init__.py

@@ -0,0 +1,37 @@
+"""SemanticEmbed SDK — 6D structural intelligence for directed graphs."""
+
+from __future__ import annotations
+
+from .client import encode, encode_file, report, drift
+from .models import SemanticResult, RiskReport, RiskEntry, DIMENSION_NAMES
+from .exceptions import (
+    SemanticEmbedError,
+    AuthenticationError,
+    NodeLimitError,
+    APIError,
+    SemanticConnectionError,
+)
+
+__version__ = "0.1.0"
+
+# Set this to your license key to unlock unlimited nodes:
+#   import semanticembed
+#   semanticembed.license_key = "se-xxxxxxxxxxxxxxxxxxxx"
+license_key: str | None = None
+
+__all__ = [
+    "encode",
+    "encode_file",
+    "report",
+    "drift",
+    "SemanticResult",
+    "RiskReport",
+    "RiskEntry",
+    "DIMENSION_NAMES",
+    "SemanticEmbedError",
+    "AuthenticationError",
+    "NodeLimitError",
+    "APIError",
+    "SemanticConnectionError",
+    "license_key",
+]

semanticembed/client.py

@@ -0,0 +1,240 @@
+"""HTTP client for the SemanticEmbed cloud API."""
+
+from __future__ import annotations
+
+import os
+import time
+from typing import Any
+
+import httpx
+
+from .exceptions import APIError, AuthenticationError, SemanticConnectionError, NodeLimitError
+from .models import DIMENSION_NAMES, RiskEntry, RiskReport, SemanticResult
+
+DEFAULT_API_URL = "https://semanticembed-api-production.up.railway.app"
+FREE_TIER_LIMIT = 50
+
+
+def _resolve_key(license_key: str | None) -> str:
+    """Resolve the API / license key from explicit arg, module-level, env var, or config file."""
+    # 1. Explicit argument
+    if license_key:
+        return license_key
+
+    # 2. Module-level attribute (set by user: semanticembed.license_key = "...")
+    import semanticembed
+    if getattr(semanticembed, "license_key", None):
+        return semanticembed.license_key
+
+    # 3. Environment variable
+    env_key = os.environ.get("SEMANTICEMBED_LICENSE_KEY") or os.environ.get("SEMANTICEMBED_API_KEY")
+    if env_key:
+        return env_key
+
+    # 4. Config file
+    config_path = os.path.expanduser("~/.semanticembed/license")
+    if os.path.isfile(config_path):
+        with open(config_path) as f:
+            key = f.read().strip()
+            if key:
+                return key
+
+    # 5. No key — free tier (server will enforce 50-node limit)
+    return ""
+
+
+def _normalize_edges(edges: Any) -> list[list[str]]:
+    """Accept tuples, lists, or dicts and normalize to [[source, target], ...]."""
+    normalized = []
+    for e in edges:
+        if isinstance(e, dict):
+            src = e.get("source") or e.get("src") or e.get("from")
+            tgt = e.get("target") or e.get("tgt") or e.get("to")
+            if not src or not tgt:
+                raise ValueError(f"Edge dict must have 'source' and 'target' keys: {e}")
+            normalized.append([str(src), str(tgt)])
+        elif isinstance(e, (list, tuple)) and len(e) >= 2:
+            normalized.append([str(e[0]), str(e[1])])
+        else:
+            raise ValueError(f"Invalid edge format: {e}")
+    return normalized
+
+
+def _parse_response(data: dict, elapsed_ms: float) -> SemanticResult:
+    """Parse the API response into SDK models."""
+    raw_embeddings = data.get("embeddings", {})
+    vectors: dict[str, list[float]] = {}
+    for node, emb in raw_embeddings.items():
+        if isinstance(emb, dict):
+            vectors[node] = [emb.get(d, 0.0) for d in DIMENSION_NAMES]
+        elif isinstance(emb, list):
+            vectors[node] = emb[:6]
+        else:
+            vectors[node] = [0.0] * 6
+
+    risks = []
+    for r in data.get("risks", []):
+        risks.append(RiskEntry(
+            node=r.get("node", ""),
+            category=r.get("type", ""),
+            severity=r.get("severity", "info"),
+            description=r.get("description", ""),
+            value=r.get("value", 0.0),
+        ))
+
+    metadata = data.get("metadata", {})
+    graph_info = {
+        "nodes": metadata.get("n_nodes", len(vectors)),
+        "edges": metadata.get("n_edges", 0),
+        "max_depth": metadata.get("max_depth", 0),
+    }
+
+    return SemanticResult(
+        vectors=vectors,
+        graph_info=graph_info,
+        encoding_time_ms=elapsed_ms,
+        risks=risks,
+    )
+
+
+def encode(
+    edges: list,
+    *,
+    license_key: str | None = None,
+    api_url: str | None = None,
+    timeout: float = 30.0,
+) -> SemanticResult:
+    """Encode a directed graph and return 6D structural coordinates.
+
+    Args:
+        edges: List of edges as tuples, lists, or dicts.
+            Examples: [("A", "B"), ("B", "C")]
+                      [{"source": "A", "target": "B"}]
+        license_key: Optional API key. If not provided, checks env/config.
+        api_url: Override the API endpoint (for testing).
+        timeout: Request timeout in seconds.
+
+    Returns:
+        SemanticResult with .vectors, .table, .graph_info, .risks
+    """
+    normalized = _normalize_edges(edges)
+    if len(normalized) < 2:
+        raise ValueError("Graph must have at least 2 edges.")
+
+    key = _resolve_key(license_key)
+    url = (api_url or os.environ.get("SEMANTICEMBED_API_URL") or DEFAULT_API_URL).rstrip("/")
+
+    headers: dict[str, str] = {"Content-Type": "application/json"}
+    if key:
+        headers["X-API-Key"] = key
+
+    # Count nodes for error reporting
+    node_set = set()
+    for e in normalized:
+        node_set.add(e[0])
+        node_set.add(e[1])
+
+    payload = {"edges": normalized}
+
+    start = time.perf_counter()
+    try:
+        with httpx.Client(timeout=timeout) as client:
+            resp = client.post(f"{url}/api/v1/encode", headers=headers, json=payload)
+    except httpx.ConnectError as e:
+        raise SemanticConnectionError(f"Could not connect to SemanticEmbed API at {url}: {e}") from e
+    elapsed_ms = (time.perf_counter() - start) * 1000
+
+    if resp.status_code == 401:
+        raise AuthenticationError("Invalid API key. Check your license key or contact jeffmurr@seas.upenn.edu")
+    if resp.status_code == 403:
+        detail = resp.text[:300]
+        # Parse node count from detail message if possible
+        import re
+        match = re.search(r"(\d+) nodes.*limit.*?(\d+)", detail)
+        if match:
+            n_nodes = int(match.group(1))
+            limit = int(match.group(2))
+        else:
+            n_nodes = len(node_set)
+            limit = FREE_TIER_LIMIT
+        raise NodeLimitError(n_nodes, limit)
+    if resp.status_code >= 400:
+        detail = resp.text[:200]
+        raise APIError(resp.status_code, detail)
+
+    return _parse_response(resp.json(), elapsed_ms)
+
+
+def report(result: SemanticResult) -> RiskReport:
+    """Generate a structural risk report from an encoding result.
+
+    Args:
+        result: A SemanticResult from encode().
+
+    Returns:
+        RiskReport with .risks, .by_category(), .by_severity()
+    """
+    return RiskReport(risks=result.risks)
+
+
+def encode_file(
+    path: str,
+    *,
+    license_key: str | None = None,
+    api_url: str | None = None,
+    timeout: float = 30.0,
+) -> SemanticResult:
+    """Encode a graph from a JSON file.
+
+    The file should contain an "edges" array with objects having
+    "source" and "target" fields.
+
+    Args:
+        path: Path to a JSON file.
+        license_key: Optional API key.
+        api_url: Override the API endpoint.
+        timeout: Request timeout in seconds.
+
+    Returns:
+        SemanticResult
+    """
+    import json
+    with open(path) as f:
+        data = json.load(f)
+
+    edges = data.get("edges", [])
+    if not edges:
+        raise ValueError(f"No 'edges' array found in {path}")
+
+    return encode(edges, license_key=license_key, api_url=api_url, timeout=timeout)
+
+
+def drift(
+    before: SemanticResult,
+    after: SemanticResult,
+) -> dict[str, dict[str, float]]:
+    """Compare two encoding results and return per-node, per-dimension deltas.
+
+    Args:
+        before: Encoding result from the earlier version.
+        after: Encoding result from the later version.
+
+    Returns:
+        Dict mapping node names to dicts of dimension deltas.
+        Positive values mean the dimension increased.
+    """
+    all_nodes = set(before.vectors.keys()) | set(after.vectors.keys())
+    changes: dict[str, dict[str, float]] = {}
+
+    for node in sorted(all_nodes):
+        v_before = before.vectors.get(node, [0.0] * 6)
+        v_after = after.vectors.get(node, [0.0] * 6)
+        deltas = {}
+        for i, dim in enumerate(DIMENSION_NAMES):
+            delta = v_after[i] - v_before[i]
+            if abs(delta) > 1e-6:
+                deltas[dim] = round(delta, 4)
+        if deltas:
+            changes[node] = deltas
+
+    return changes

semanticembed/exceptions.py

@@ -0,0 +1,34 @@
+"""SemanticEmbed SDK exceptions."""
+
+
+class SemanticEmbedError(Exception):
+    """Base exception for all SDK errors."""
+
+
+class AuthenticationError(SemanticEmbedError):
+    """Invalid or missing API key / license key."""
+
+
+class NodeLimitError(SemanticEmbedError):
+    """Graph exceeds the node limit for the current plan."""
+
+    def __init__(self, n_nodes: int, limit: int):
+        self.n_nodes = n_nodes
+        self.limit = limit
+        super().__init__(
+            f"Graph has {n_nodes} nodes but your plan allows {limit}. "
+            f"Contact jeffmurr@seas.upenn.edu for a license key"
+        )
+
+
+class APIError(SemanticEmbedError):
+    """Server returned an error response."""
+
+    def __init__(self, status: int, detail: str):
+        self.status = status
+        self.detail = detail
+        super().__init__(f"API error {status}: {detail}")
+
+
+class SemanticConnectionError(SemanticEmbedError):
+    """Could not connect to the SemanticEmbed API."""

semanticembed/models.py

@@ -0,0 +1,118 @@
+"""Response models for SemanticEmbed SDK."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+DIMENSION_NAMES = ["depth", "independence", "hierarchy", "throughput", "criticality", "fanout"]
+
+
+@dataclass
+class RiskEntry:
+    """A single structural risk finding."""
+
+    node: str
+    category: str
+    severity: str
+    description: str
+    value: float
+
+    def json(self) -> dict[str, Any]:
+        return {
+            "node": self.node,
+            "category": self.category,
+            "severity": self.severity,
+            "description": self.description,
+            "value": self.value,
+        }
+
+
+@dataclass
+class RiskReport:
+    """Structural risk report for a graph."""
+
+    risks: list[RiskEntry] = field(default_factory=list)
+
+    def by_category(self, category: str) -> list[RiskEntry]:
+        """Filter risks by category name (case-insensitive)."""
+        cat = category.lower().replace("_", " ").replace("-", " ")
+        return [r for r in self.risks if cat in r.category.lower().replace("_", " ")]
+
+    def by_severity(self, severity: str) -> list[RiskEntry]:
+        """Filter risks by severity level."""
+        return [r for r in self.risks if r.severity == severity]
+
+    def json(self) -> list[dict[str, Any]]:
+        return [r.json() for r in self.risks]
+
+    def __str__(self) -> str:
+        if not self.risks:
+            return "STRUCTURAL RISK REPORT\n======================\n\nNo structural risks detected."
+
+        lines = ["STRUCTURAL RISK REPORT", "=" * 22, ""]
+
+        # Group by category
+        categories: dict[str, list[RiskEntry]] = {}
+        for r in self.risks:
+            categories.setdefault(r.category, []).append(r)
+
+        for cat, entries in categories.items():
+            label = cat.upper().replace("_", " ")
+            lines.append(f"{label}:")
+            for r in entries:
+                lines.append(f"  - {r.node:<30} | {r.description}")
+            lines.append("")
+
+        return "\n".join(lines)
+
+
+@dataclass
+class SemanticResult:
+    """Result of a 6D structural encoding."""
+
+    vectors: dict[str, list[float]]
+    graph_info: dict[str, Any]
+    encoding_time_ms: float
+    risks: list[RiskEntry] = field(default_factory=list)
+
+    def __getitem__(self, node: str) -> list[float]:
+        return self.vectors[node]
+
+    def dimensions(self, node: str) -> dict[str, float]:
+        """Return named dimensions for a node."""
+        v = self.vectors[node]
+        return dict(zip(DIMENSION_NAMES, v))
+
+    @property
+    def nodes(self) -> list[str]:
+        """All node names."""
+        return list(self.vectors.keys())
+
+    @property
+    def table(self) -> str:
+        """Formatted table sorted by criticality (highest first)."""
+        header = f"{'Node':<35} {'Depth':>6} {'Indep':>6} {'Hier':>6} {'Thru':>6} {'Crit':>6} {'Fan':>6}"
+        sep = "-" * len(header)
+        rows = sorted(
+            self.vectors.items(),
+            key=lambda x: x[1][4],  # criticality index
+            reverse=True,
+        )
+        lines = [header, sep]
+        for node, v in rows:
+            name = node if len(node) <= 35 else node[:32] + "..."
+            lines.append(
+                f"{name:<35} {v[0]:>6.3f} {v[1]:>6.3f} {v[2]:>6.3f} {v[3]:>6.3f} {v[4]:>6.3f} {v[5]:>6.3f}"
+            )
+        return "\n".join(lines)
+
+    def json(self) -> dict[str, Any]:
+        """Full result as a JSON-serializable dict."""
+        return {
+            "vectors": self.vectors,
+            "graph_info": self.graph_info,
+            "encoding_time_ms": self.encoding_time_ms,
+            "risks": [r.json() for r in self.risks],
+        }

semanticembed-0.1.0.dist-info/METADATA

@@ -0,0 +1,257 @@
+Metadata-Version: 2.4
+Name: semanticembed
+Version: 0.1.0
+Summary: 6D structural intelligence for directed graphs. Six numbers per node. Sub-millisecond.
+Project-URL: Homepage, https://github.com/jmurray10/semanticembed-sdk
+Project-URL: Documentation, https://github.com/jmurray10/semanticembed-sdk
+Project-URL: Repository, https://github.com/jmurray10/semanticembed-sdk
+Author-email: Jeff Murray <jeffmurr@seas.upenn.edu>
+License: Proprietary
+License-File: LICENSE
+Keywords: graph,microservices,observability,risk-detection,structural-analysis
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.24
+Description-Content-Type: text/markdown
+
+# SemanticEmbed SDK
+
+**Structural intelligence for directed graphs. Six numbers per node. Sub-millisecond.**
+
+SemanticEmbed computes a 6-dimensional structural encoding for every node in a directed graph. From a bare edge list -- no runtime telemetry, no historical data, no tuning -- it produces six independent measurements that fully describe each node's structural role.
+
+> **Validated against production incidents.** In a blind test against a live production environment (100+ services, 2,500+ incidents over 30 days), the majority of topology-relevant incidents occurred on nodes that 6D structural analysis had flagged as risky -- from the call graph alone, before any incident occurred.
+
+---
+
+## Why 6D?
+
+Observability tools tell you **what broke**. SemanticEmbed tells you **what will break** -- from topology alone.
+
+- **No agents, no instrumentation** -- just an edge list
+- **Sub-millisecond** -- encodes 100+ node graphs in <1ms
+- **Works on any directed graph** -- microservices, AI agent pipelines, data workflows, CI/CD
+- **Mathematically independent axes** -- six dimensions, zero redundancy, each captures structural information no other metric provides
+
+---
+
+## Try It Now
+
+**[Open the Interactive Demo in Google Colab](https://colab.research.google.com/github/jmurray10/semanticembed-sdk/blob/main/notebooks/01_quickstart.ipynb)** -- runs in your browser, nothing to install locally.
+
+---
+
+## Install
+
+```bash
+pip install semanticembed
+```
+
+**Free tier:** Up to 50 nodes per graph. No signup required.
+
+---
+
+## Quick Start
+
+```python
+from semanticembed import encode, report
+
+# Any directed graph as an edge list
+edges = [
+    ("frontend", "api-gateway"),
+    ("api-gateway", "order-service"),
+    ("api-gateway", "user-service"),
+    ("order-service", "payment-service"),
+    ("order-service", "inventory-service"),
+    ("payment-service", "database"),
+]
+
+# Compute the 6D encoding (sub-millisecond)
+result = encode(edges)
+
+# Six structural measurements per node
+for node, vector in result.vectors.items():
+    print(f"{node}: {vector}")
+
+# Structural risk report
+print(report(result))
+```
+
+Output:
+
+```
+STRUCTURAL RISK REPORT
+======================
+
+AMPLIFICATION RISKS (high fanout, high criticality):
+  - api-gateway    | fanout=0.667 | criticality=0.556
+
+CONVERGENCE SINKS (low independence, many upstream callers):
+  - database       | independence=0.000
+
+STRUCTURAL SPOF (low independence, high upstream dependency):
+  - api-gateway    | independence=0.000 | every request flows through this node
+```
+
+---
+
+## What It Finds That Other Tools Miss
+
+| Your current tools | SemanticEmbed |
+|---|---|
+| This service has high latency | This service is on 89% of all paths (structural SPOF) |
+| This service had 5 errors | This service fans out to 12 downstream services (amplification risk) |
+| This service is healthy | This service has zero lateral redundancy (convergence sink) |
+
+Runtime monitoring tells you what is slow **now**. Structural analysis tells you what **will** cause cascading failures regardless of current load.
+
+---
+
+## The Six Dimensions
+
+Every node gets six independent structural measurements:
+
+| Dimension | What It Measures | Risk Signal |
+|-----------|-----------------|-------------|
+| **Depth** | Position in the execution pipeline (0.0 = entry, 1.0 = deepest) | Deep nodes accumulate upstream latency |
+| **Independence** | Lateral redundancy at the same pipeline stage | Low independence = structural chokepoint |
+| **Hierarchy** | Module or group membership | Cross-module dependencies = blast radius |
+| **Throughput** | Fraction of total traffic flowing through the node | High throughput + low independence = hidden bottleneck |
+| **Criticality** | Fraction of end-to-end paths depending on this node | High criticality = SPOF |
+| **Fanout** | Broadcaster (1.0) vs aggregator (0.0) | High fanout = amplification risk |
+
+These six properties are mathematically independent -- knowing any five tells you nothing about the sixth.
+
+See [docs/dimensions.md](docs/dimensions.md) for the full reference.
+
+---
+
+## Use Cases
+
+**Microservice architectures** -- Find SPOFs, amplification cascades, and convergence bottlenecks in any service mesh. Works with Kubernetes, Istio, OTel traces, or static architecture diagrams.
+
+**AI agent pipelines** -- Identify vendor concentration risk, gateway bottlenecks, and guardrail single points of failure in LLM orchestration graphs.
+
+**CI/CD and data pipelines** -- Detect structural fragility in build graphs, ETL workflows, and deployment pipelines before they cause cascading failures.
+
+**Architecture drift monitoring** -- Compare structural fingerprints across releases. Know exactly which services changed structural role and by how much.
+
+---
+
+## Notebooks
+
+Step-by-step Colab notebooks. Click to open, run in your browser.
+
+| Notebook | Use Case | What You Learn |
+|----------|----------|---------------|
+| [01 - Quickstart](https://colab.research.google.com/github/jmurray10/semanticembed-sdk/blob/main/notebooks/01_quickstart.ipynb) | Getting started | Install, encode a graph, read the risk report |
+| [02 - Dimensions Deep Dive](https://colab.research.google.com/github/jmurray10/semanticembed-sdk/blob/main/notebooks/02_dimensions.ipynb) | Understanding 6D | What each dimension means, with worked examples |
+| [03 - Drift Detection](https://colab.research.google.com/github/jmurray10/semanticembed-sdk/blob/main/notebooks/03_drift_detection.ipynb) | Architecture drift | Compare graph versions, detect structural changes |
+| [04 - Bring Your Own Graph](https://colab.research.google.com/github/jmurray10/semanticembed-sdk/blob/main/notebooks/04_bring_your_own.ipynb) | Any graph | Load from JSON, OTel traces, or Kubernetes |
+| [05 - AI Agent Pipelines](https://colab.research.google.com/github/jmurray10/semanticembed-sdk/blob/main/notebooks/05_ai_agent_pipelines.ipynb) | AI/LLM agents | Vendor concentration, gateway bottlenecks, guardrail SPOFs |
+| [06 - CI/CD & Data Pipelines](https://colab.research.google.com/github/jmurray10/semanticembed-sdk/blob/main/notebooks/06_cicd_pipelines.ipynb) | CI/CD & ETL | Build graph fragility, pipeline bottlenecks, drift gates |
+| [07 - OpenTelemetry](https://colab.research.google.com/github/jmurray10/semanticembed-sdk/blob/main/notebooks/07_opentelemetry.ipynb) | OTel traces | Extract edges from traces, structural analysis, CI/CD gates |
+
+---
+
+## Example Graphs
+
+The `examples/` directory contains edge lists for well-known architectures:
+
+| File | Application | Nodes | Edges |
+|------|------------|-------|-------|
+| [google_online_boutique.json](examples/google_online_boutique.json) | Google Online Boutique (microservices) | 11 | 15 |
+| [weaveworks_sock_shop.json](examples/weaveworks_sock_shop.json) | Weaveworks Sock Shop (microservices) | 15 | 15 |
+| [ai_agent_pipeline.json](examples/ai_agent_pipeline.json) | Multi-agent LLM orchestration | 12 | 15 |
+| [cicd_pipeline.json](examples/cicd_pipeline.json) | CI/CD build pipeline | 13 | 17 |
+
+---
+
+## React Components
+
+Drop-in React components for rendering SDK results. See [examples/react/](examples/react/) for the full source.
+
+| Component | What it renders |
+|-----------|----------------|
+| `useSemanticEmbed.ts` | React hook — call `encode()` from your frontend |
+| `RiskTable.tsx` | Sortable risk table with severity badges |
+| `RadarChart.tsx` | 6D radar chart comparing node profiles |
+| `TopologySummary.tsx` | KPI cards + risk breakdown |
+
+```tsx
+import { useSemanticEmbed } from './useSemanticEmbed';
+import { RiskTable } from './RiskTable';
+
+function App() {
+  const { result, loading, encode } = useSemanticEmbed();
+  return (
+    <>
+      <button onClick={() => encode([["A","B"],["B","C"],["C","D"]])}>Analyze</button>
+      {result && <RiskTable risks={result.risks} />}
+    </>
+  );
+}
+```
+
+---
+
+## Input Format
+
+SemanticEmbed accepts any directed graph as an edge list.
+
+```python
+# Python tuples
+edges = [("A", "B"), ("B", "C")]
+result = encode(edges)
+
+# JSON file
+result = encode_file("my_graph.json")
+```
+
+JSON format:
+
+```json
+{
+  "edges": [
+    {"source": "A", "target": "B"},
+    {"source": "B", "target": "C"}
+  ]
+}
+```
+
+See [docs/input_format.md](docs/input_format.md) for the full spec.
+
+---
+
+## Documentation
+
+| Document | Description |
+|----------|-------------|
+| [docs/getting_started.md](docs/getting_started.md) | Install, encode, read results, export -- one page |
+| [docs/api_reference.md](docs/api_reference.md) | Every function, class, parameter, and return type |
+| [docs/dimensions.md](docs/dimensions.md) | The six structural dimensions -- full reference |
+| [docs/input_format.md](docs/input_format.md) | Edge list input specification |
+| [docs/output_format.md](docs/output_format.md) | Encoding output and risk report format |
+
+---
+
+## License
+
+SemanticEmbed SDK is proprietary software distributed as a compiled package.
+Free tier available for graphs up to 50 nodes. See [LICENSE](LICENSE) for terms.
+
+**Patent pending.** Application #63/994,075.
+
+---
+
+## Contact
+
+Email jeffmurr@seas.upenn.edu

semanticembed-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+semanticembed/__init__.py,sha256=yUlt-QWKUJGswliwg9_UrOqkDe2mRbkW8A_lgt8osOo,875
+semanticembed/client.py,sha256=pbO3ZK7dZ2kjZM9WWjuBvRpqNtWHj65y68s9KCboMe4,7613
+semanticembed/exceptions.py,sha256=h-AenVWauzIyRZT_17QLpNXLAdroRZ9z0IKN0lPu0H8,965
+semanticembed/models.py,sha256=lP4egjv6qSKK_BsmPF60OAdB0UTfQ1SCwwacdtGRtFk,3661
+semanticembed-0.1.0.dist-info/METADATA,sha256=Dry7UW4kkqXOltONImempie8X2ww9IpvVIj_oorIWj0,10127
+semanticembed-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+semanticembed-0.1.0.dist-info/licenses/LICENSE,sha256=B64mn9F_MbnqYyNznp6j1vPfGEyrENUDY0gJBAvsdFI,665
+semanticembed-0.1.0.dist-info/RECORD,,

semanticembed-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

semanticembed-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,18 @@
+SemanticEmbed SDK License
+
+Copyright (c) 2026 SemanticEmbed Inc. All rights reserved.
+
+This software is proprietary and confidential. Unauthorized copying,
+distribution, modification, or use of this software, via any medium,
+is strictly prohibited.
+
+The SemanticEmbed SDK is distributed as a compiled package for the
+sole purpose of interfacing with the SemanticEmbed cloud API. It does
+not contain the encoding algorithm or any proprietary computation logic.
+
+Free tier: graphs up to 50 nodes, no signup required.
+Paid tier: unlimited nodes, requires a valid license key.
+
+Patent pending. Application #63/994,075.
+
+For licensing inquiries: jeffmurr@seas.upenn.edu