vouchstone-sdk 1.0.0__py3-none-any.whl

vouchstone_sdk/__init__.py

@@ -0,0 +1,20 @@
+"""Vouchstone Python SDK - Build AI Agents with Long-Term Memory"""
+
+from .client import VouchstoneClient
+from .agent import Agent, AgentConfig
+from .memory import SemanticMemory, EpisodicMemory, ProceduralMemory, DecisionGraph
+from .types import Message, Decision, MemoryEntry
+
+__version__ = "1.0.0"
+__all__ = [
+    "VouchstoneClient",
+    "Agent",
+    "AgentConfig",
+    "SemanticMemory",
+    "EpisodicMemory",
+    "ProceduralMemory",
+    "DecisionGraph",
+    "Message",
+    "Decision",
+    "MemoryEntry",
+]

vouchstone_sdk/agent.py

@@ -0,0 +1,156 @@
+"""Agent Base Class with Memory Integration"""
+
+from typing import Optional, Dict, Any, List, Callable
+from dataclasses import dataclass, field
+from abc import ABC, abstractmethod
+import asyncio
+
+from .memory import SemanticMemory, EpisodicMemory, ProceduralMemory, DecisionGraph
+from .types import Message, AgentResponse
+
+@dataclass
+class AgentConfig:
+    """Configuration for an Vouchstone Agent"""
+    name: str
+    model: str = "gpt-4-turbo-preview"
+    temperature: float = 0.7
+    max_tokens: int = 4096
+    system_prompt: Optional[str] = None
+    
+    # Memory configuration
+    semantic_memory: bool = True
+    episodic_memory: bool = True
+    procedural_memory: bool = True
+    decision_graph: bool = True
+    
+    # Memory settings
+    embedding_model: str = "text-embedding-3-small"
+    memory_retention_days: int = 90
+    
+    # Additional config
+    tools: List[Dict[str, Any]] = field(default_factory=list)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+class Agent(ABC):
+    """Base class for Vouchstone Agents with Long-Term Memory"""
+    
+    def __init__(self, config: AgentConfig):
+        self.config = config
+        self.semantic_memory: Optional[SemanticMemory] = None
+        self.episodic_memory: Optional[EpisodicMemory] = None
+        self.procedural_memory: Optional[ProceduralMemory] = None
+        self.decision_graph: Optional[DecisionGraph] = None
+        
+        self._tools: Dict[str, Callable] = {}
+        self._initialized = False
+    
+    async def initialize(
+        self,
+        vector_db_url: Optional[str] = None,
+        graph_db_url: Optional[str] = None
+    ):
+        """Initialize memory systems"""
+        if self.config.semantic_memory:
+            self.semantic_memory = SemanticMemory(
+                embedding_model=self.config.embedding_model,
+                vector_db_url=vector_db_url
+            )
+            await self.semantic_memory.initialize()
+        
+        if self.config.episodic_memory:
+            self.episodic_memory = EpisodicMemory(
+                retention_days=self.config.memory_retention_days
+            )
+            await self.episodic_memory.initialize()
+        
+        if self.config.procedural_memory:
+            self.procedural_memory = ProceduralMemory()
+            await self.procedural_memory.initialize()
+        
+        if self.config.decision_graph:
+            self.decision_graph = DecisionGraph(graph_db_url=graph_db_url)
+            await self.decision_graph.initialize()
+        
+        self._initialized = True
+    
+    def register_tool(self, name: str, func: Callable, description: str):
+        """Register a tool for the agent to use"""
+        self._tools[name] = func
+        self.config.tools.append({
+            "type": "function",
+            "function": {
+                "name": name,
+                "description": description,
+                "parameters": {"type": "object", "properties": {}}
+            }
+        })
+    
+    async def process(self, message: Message) -> AgentResponse:
+        """Process a message and return response"""
+        if not self._initialized:
+            raise RuntimeError("Agent not initialized. Call initialize() first.")
+        
+        # Retrieve relevant memories
+        context = await self._build_context(message)
+        
+        # Run the agent logic
+        response = await self.run(message, context)
+        
+        # Store in episodic memory
+        if self.episodic_memory:
+            await self.episodic_memory.store(message, response)
+        
+        # Update decision graph if enabled
+        if self.decision_graph and response.decisions:
+            for decision in response.decisions:
+                await self.decision_graph.record_decision(decision)
+        
+        return response
+    
+    async def _build_context(self, message: Message) -> Dict[str, Any]:
+        """Build context from memory systems"""
+        context = {}
+        
+        if self.semantic_memory:
+            relevant_docs = await self.semantic_memory.search(
+                message.content,
+                top_k=5
+            )
+            context["semantic"] = relevant_docs
+        
+        if self.episodic_memory:
+            recent_episodes = await self.episodic_memory.get_recent(
+                limit=10
+            )
+            context["episodic"] = recent_episodes
+        
+        if self.procedural_memory:
+            relevant_procedures = await self.procedural_memory.get_relevant(
+                message.content
+            )
+            context["procedural"] = relevant_procedures
+        
+        if self.decision_graph:
+            decision_context = await self.decision_graph.get_context(
+                message.content
+            )
+            context["decision_graph"] = decision_context
+        
+        return context
+    
+    @abstractmethod
+    async def run(self, message: Message, context: Dict[str, Any]) -> AgentResponse:
+        """Implement agent logic - must be overridden"""
+        pass
+    
+    async def close(self):
+        """Cleanup resources"""
+        if self.semantic_memory:
+            await self.semantic_memory.close()
+        if self.episodic_memory:
+            await self.episodic_memory.close()
+        if self.procedural_memory:
+            await self.procedural_memory.close()
+        if self.decision_graph:
+            await self.decision_graph.close()

vouchstone_sdk/client.py

@@ -0,0 +1,126 @@
+"""Vouchstone SDK Client - Connection to Control Plane"""
+
+import httpx
+from typing import Optional, Dict, Any, List
+from .types import AgentDefinition
+
+class VouchstoneClient:
+    """Client for communicating with Vouchstone Control Plane"""
+    
+    def __init__(
+        self,
+        api_key: str,
+        control_plane_url: str = "https://api.vouchstone.ai",
+        tenant_id: Optional[str] = None
+    ):
+        self.api_key = api_key
+        self.base_url = control_plane_url.rstrip("/")
+        self.tenant_id = tenant_id
+        self._client = httpx.AsyncClient(
+            base_url=self.base_url,
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "X-Tenant-ID": tenant_id or "",
+            },
+            timeout=30.0
+        )
+    
+    async def get_agent(self, agent_id: str) -> AgentDefinition:
+        """Fetch agent definition from control plane"""
+        response = await self._client.get(f"/api/v1/agents/{agent_id}")
+        response.raise_for_status()
+        return AgentDefinition(**response.json())
+    
+    async def list_agents(self) -> List[AgentDefinition]:
+        """List all agents for tenant"""
+        response = await self._client.get("/api/v1/agents")
+        response.raise_for_status()
+        return [AgentDefinition(**a) for a in response.json()["agents"]]
+    
+    async def report_metrics(self, metrics: Dict[str, Any]) -> None:
+        """Report metrics back to control plane"""
+        await self._client.post("/api/v1/webhooks/data-plane/metrics", json=metrics)
+    
+    async def report_status(self, agent_id: str, status: Dict[str, Any]) -> None:
+        """Report agent status to control plane"""
+        await self._client.post(
+            "/api/v1/webhooks/data-plane/status",
+            json={"agent_id": agent_id, **status}
+        )
+    
+    # ============================================================
+    # Slice 1 — data plane sync helpers
+    # ============================================================
+
+    async def heartbeat(
+        self,
+        runtime_version: str,
+        pod_count: int,
+        queue_depth: int,
+        last_seq: int,
+        runtime_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """POST /api/v1/data-plane/heartbeat — returns heartbeat response.
+
+        ``runtime_token`` is required (provide either here or via
+        ``X-Runtime-Token`` on the client).
+        """
+        headers = {"X-Runtime-Token": runtime_token or ""}
+        body = {
+            "tenant_id": self.tenant_id,
+            "runtime_version": runtime_version,
+            "pod_count": pod_count,
+            "queue_depth": queue_depth,
+            "last_ledger_seq_forwarded": last_seq,
+        }
+        resp = await self._client.post(
+            "/api/v1/data-plane/heartbeat", json=body, headers=headers,
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    async def replay_ledger(
+        self,
+        entries: List[Dict[str, Any]],
+        runtime_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """POST /api/v1/data-plane/ledger/replay — bulk replay."""
+        headers = {"X-Runtime-Token": runtime_token or ""}
+        body = {"tenant_id": self.tenant_id, "entries": entries}
+        resp = await self._client.post(
+            "/api/v1/data-plane/ledger/replay", json=body, headers=headers,
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    async def fetch_agent_spec(
+        self,
+        agent_id: Optional[str] = None,
+        since: float = 0.0,
+        runtime_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """GET /api/v1/data-plane/agents/spec?since=&tenant_id=.
+
+        ``agent_id`` is optional — when supplied the response is filtered
+        to that agent locally.
+        """
+        headers = {"X-Runtime-Token": runtime_token or ""}
+        params = {"tenant_id": self.tenant_id or "", "since": since}
+        resp = await self._client.get(
+            "/api/v1/data-plane/agents/spec", params=params, headers=headers,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        if agent_id:
+            data["agents"] = [a for a in data.get("agents", []) if str(a.get("id")) == str(agent_id)]
+        return data
+
+    async def close(self):
+        """Close the HTTP client"""
+        await self._client.aclose()
+    
+    async def __aenter__(self):
+        return self
+    
+    async def __aexit__(self, *args):
+        await self.close()

vouchstone_sdk/memory.py

@@ -0,0 +1,243 @@
+"""Memory Systems for Vouchstone Agents"""
+
+from typing import Optional, List, Dict, Any
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+import json
+import hashlib
+
+from .types import MemoryEntry, Decision, Episode
+
+
+class SemanticMemory:
+    """Vector-based semantic memory for knowledge retrieval"""
+    
+    def __init__(
+        self,
+        embedding_model: str = "text-embedding-3-small",
+        vector_db_url: Optional[str] = None,
+        collection_name: str = "semantic_memory"
+    ):
+        self.embedding_model = embedding_model
+        self.vector_db_url = vector_db_url
+        self.collection_name = collection_name
+        self._client = None
+        self._embedder = None
+    
+    async def initialize(self):
+        """Initialize vector DB connection"""
+        if self.vector_db_url:
+            # Use Qdrant or ChromaDB based on URL
+            if "qdrant" in self.vector_db_url:
+                from qdrant_client import QdrantClient
+                self._client = QdrantClient(url=self.vector_db_url)
+            else:
+                import chromadb
+                self._client = chromadb.HttpClient(host=self.vector_db_url)
+        else:
+            # Use in-memory ChromaDB for development
+            import chromadb
+            self._client = chromadb.Client()
+    
+    async def store(self, text: str, metadata: Dict[str, Any] = None) -> str:
+        """Store text with embeddings"""
+        embedding = await self._get_embedding(text)
+        doc_id = hashlib.md5(text.encode()).hexdigest()
+        
+        # Store in vector DB
+        collection = self._client.get_or_create_collection(self.collection_name)
+        collection.add(
+            ids=[doc_id],
+            embeddings=[embedding],
+            documents=[text],
+            metadatas=[metadata or {}]
+        )
+        return doc_id
+    
+    async def search(self, query: str, top_k: int = 5) -> List[MemoryEntry]:
+        """Search for relevant memories"""
+        embedding = await self._get_embedding(query)
+        
+        collection = self._client.get_or_create_collection(self.collection_name)
+        results = collection.query(
+            query_embeddings=[embedding],
+            n_results=top_k
+        )
+        
+        entries = []
+        for i, doc in enumerate(results["documents"][0]):
+            entries.append(MemoryEntry(
+                id=results["ids"][0][i],
+                content=doc,
+                metadata=results["metadatas"][0][i] if results["metadatas"] else {},
+                score=results["distances"][0][i] if results.get("distances") else 0.0
+            ))
+        return entries
+    
+    async def _get_embedding(self, text: str) -> List[float]:
+        """Get embedding for text"""
+        import openai
+        client = openai.AsyncOpenAI()
+        response = await client.embeddings.create(
+            model=self.embedding_model,
+            input=text
+        )
+        return response.data[0].embedding
+    
+    async def close(self):
+        pass
+
+
+class EpisodicMemory:
+    """Time-based episodic memory for conversation history"""
+    
+    def __init__(self, retention_days: int = 90):
+        self.retention_days = retention_days
+        self._episodes: List[Episode] = []
+    
+    async def initialize(self):
+        """Initialize episodic memory storage"""
+        pass
+    
+    async def store(self, message: Any, response: Any) -> str:
+        """Store an episode (message-response pair)"""
+        episode = Episode(
+            id=f"ep_{datetime.utcnow().timestamp()}",
+            timestamp=datetime.utcnow(),
+            message=str(message),
+            response=str(response),
+            metadata={}
+        )
+        self._episodes.append(episode)
+        return episode.id
+    
+    async def get_recent(self, limit: int = 10) -> List[Episode]:
+        """Get recent episodes"""
+        cutoff = datetime.utcnow() - timedelta(days=self.retention_days)
+        recent = [e for e in self._episodes if e.timestamp > cutoff]
+        return sorted(recent, key=lambda x: x.timestamp, reverse=True)[:limit]
+    
+    async def search(self, query: str, limit: int = 5) -> List[Episode]:
+        """Search episodes by content"""
+        matches = []
+        query_lower = query.lower()
+        for episode in self._episodes:
+            if query_lower in episode.message.lower() or query_lower in episode.response.lower():
+                matches.append(episode)
+        return matches[:limit]
+    
+    async def close(self):
+        pass
+
+
+class ProceduralMemory:
+    """Memory for learned procedures and skills"""
+    
+    def __init__(self):
+        self._procedures: Dict[str, Dict[str, Any]] = {}
+    
+    async def initialize(self):
+        pass
+    
+    async def store_procedure(
+        self,
+        name: str,
+        steps: List[str],
+        conditions: Dict[str, Any] = None
+    ) -> str:
+        """Store a procedure"""
+        self._procedures[name] = {
+            "name": name,
+            "steps": steps,
+            "conditions": conditions or {},
+            "created_at": datetime.utcnow().isoformat()
+        }
+        return name
+    
+    async def get_relevant(self, context: str) -> List[Dict[str, Any]]:
+        """Get procedures relevant to context"""
+        # Simple keyword matching - could use embeddings
+        relevant = []
+        context_lower = context.lower()
+        for name, proc in self._procedures.items():
+            if name.lower() in context_lower:
+                relevant.append(proc)
+        return relevant
+    
+    async def execute_procedure(self, name: str, inputs: Dict[str, Any]) -> Any:
+        """Execute a stored procedure"""
+        if name not in self._procedures:
+            raise ValueError(f"Procedure {name} not found")
+        
+        proc = self._procedures[name]
+        # Return steps for now - actual execution would depend on step types
+        return {"procedure": name, "steps": proc["steps"], "inputs": inputs}
+    
+    async def close(self):
+        pass
+
+
+class DecisionGraph:
+    """Graph-based decision memory with reasoning chains"""
+    
+    def __init__(self, graph_db_url: Optional[str] = None):
+        self.graph_db_url = graph_db_url
+        self._driver = None
+        self._decisions: List[Decision] = []
+    
+    async def initialize(self):
+        """Initialize graph database connection"""
+        if self.graph_db_url:
+            from neo4j import AsyncGraphDatabase
+            self._driver = AsyncGraphDatabase.driver(self.graph_db_url)
+    
+    async def record_decision(self, decision: Decision) -> str:
+        """Record a decision in the graph"""
+        self._decisions.append(decision)
+        
+        if self._driver:
+            async with self._driver.session() as session:
+                await session.run(
+                    """
+                    CREATE (d:Decision {
+                        id: $id,
+                        question: $question,
+                        answer: $answer,
+                        confidence: $confidence,
+                        reasoning: $reasoning,
+                        timestamp: datetime()
+                    })
+                    """,
+                    id=decision.id,
+                    question=decision.question,
+                    answer=decision.answer,
+                    confidence=decision.confidence,
+                    reasoning=json.dumps(decision.reasoning)
+                )
+        
+        return decision.id
+    
+    async def get_context(self, query: str) -> Dict[str, Any]:
+        """Get decision context for a query"""
+        # Find related decisions
+        related = []
+        query_lower = query.lower()
+        for decision in self._decisions:
+            if query_lower in decision.question.lower():
+                related.append(decision)
+        
+        return {
+            "related_decisions": related[-5:],
+            "total_decisions": len(self._decisions)
+        }
+    
+    async def get_reasoning_chain(self, decision_id: str) -> List[Dict[str, Any]]:
+        """Get the reasoning chain for a decision"""
+        for decision in self._decisions:
+            if decision.id == decision_id:
+                return decision.reasoning
+        return []
+    
+    async def close(self):
+        if self._driver:
+            await self._driver.close()

vouchstone_sdk/types.py

@@ -0,0 +1,78 @@
+"""Type definitions for Vouchstone SDK"""
+
+from dataclasses import dataclass, field
+from typing import Optional, List, Dict, Any
+from datetime import datetime
+from enum import Enum
+
+
+@dataclass
+class Message:
+    """Input message to an agent"""
+    content: str
+    role: str = "user"
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    timestamp: datetime = field(default_factory=datetime.utcnow)
+
+
+@dataclass
+class Decision:
+    """A decision made by an agent"""
+    id: str
+    question: str
+    answer: str
+    confidence: float
+    reasoning: List[Dict[str, Any]] = field(default_factory=list)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    timestamp: datetime = field(default_factory=datetime.utcnow)
+
+
+@dataclass
+class AgentResponse:
+    """Response from an agent"""
+    content: str
+    decisions: List[Decision] = field(default_factory=list)
+    tool_calls: List[Dict[str, Any]] = field(default_factory=list)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    usage: Dict[str, int] = field(default_factory=dict)
+
+
+@dataclass
+class MemoryEntry:
+    """An entry from memory search"""
+    id: str
+    content: str
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    score: float = 0.0
+
+
+@dataclass
+class Episode:
+    """An episodic memory entry"""
+    id: str
+    timestamp: datetime
+    message: str
+    response: str
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class AgentDefinition:
+    """Agent definition from control plane"""
+    id: str
+    name: str
+    slug: str
+    agent_type: str
+    status: str
+    memory_config: Dict[str, Any]
+    config_schema: Dict[str, Any]
+    code_s3_key: Optional[str] = None
+    description: Optional[str] = None
+    tags: List[str] = field(default_factory=list)
+
+
+class AgentStatus(str, Enum):
+    DRAFT = "draft"
+    ACTIVE = "active"
+    PAUSED = "paused"
+    ARCHIVED = "archived"

vouchstone_sdk-1.0.0.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: vouchstone-sdk
+Version: 1.0.0
+Summary: Python SDK for Vouchstone — AI engineers you can vouch for
+Author: Vouchstone
+Author-email: "Vouchstone Inc." <gaurav@datapitcher.com>
+License: Proprietary
+Project-URL: Homepage, https://vouchstone.ai
+Project-URL: Repository, https://github.com/GGChamp85/Vouchstone
+Project-URL: Documentation, https://vouchstone.ai/docs
+Keywords: ai,agents,memory,enterprise,vouchstone
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: anthropic>=0.18.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: aiofiles>=23.0.0
+Provides-Extra: vector
+Requires-Dist: chromadb>=0.4.0; extra == "vector"
+Requires-Dist: qdrant-client>=1.7.0; extra == "vector"
+Provides-Extra: graph
+Requires-Dist: neo4j>=5.0.0; extra == "graph"
+Provides-Extra: all
+Requires-Dist: chromadb>=0.4.0; extra == "all"
+Requires-Dist: qdrant-client>=1.7.0; extra == "all"
+Requires-Dist: neo4j>=5.0.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Dynamic: author
+Dynamic: requires-python
+
+# Vouchstone SDK
+
+Python SDK for building AI agents on the Vouchstone platform — the first accountable AI engineering firm.
+
+## Install
+
+```bash
+pip install vouchstone-sdk
+
+# With vector memory (ChromaDB)
+pip install vouchstone-sdk[vector]
+
+# With graph memory (Neo4j)
+pip install vouchstone-sdk[graph]
+
+# Everything
+pip install vouchstone-sdk[all]
+```
+
+## Quick Start
+
+```python
+from vouchstone_sdk import Agent, AgentConfig, Message
+
+class MyAgent(Agent):
+    async def run(self, message: Message, context: dict):
+        relevant_docs = context.get("semantic", [])
+        history = context.get("episodic", [])
+
+        response = await self.llm.complete(
+            system=f"You are {self.config.name}. Use the context to help the user.",
+            messages=[{"role": "user", "content": message.content}],
+            context=relevant_docs,
+        )
+        return AgentResponse(content=response)
+
+config = AgentConfig(
+    name="Data Migration Agent",
+    model="claude-sonnet-4-20250514",
+    semantic_memory=True,
+    episodic_memory=True,
+    procedural_memory=True,
+)
+
+agent = MyAgent(config)
+await agent.initialize(vector_db_url="http://chromadb:8000")
+response = await agent.process(Message(content="Migrate our PostgreSQL to Snowflake"))
+```
+
+## 5-Layer Memory Stack
+
+Each agent has access to a biologically-inspired memory architecture:
+
+| Layer | Name | Storage | Purpose |
+|-------|------|---------|---------|
+| 1 | Working | Redis | Current turn context (resets per session) |
+| 2 | Episodic | PostgreSQL | Cross-session traces (append-only) |
+| 3 | Semantic | ChromaDB | Entity store (vector search) |
+| 4 | Procedural | Neo4j | Learned skills (versioned DAG) |
+| 5 | Meta | Control Plane | Decay, dedup, compress, forget |
+
+## Control Plane Client
+
+```python
+from vouchstone_sdk import VouchstoneClient
+
+client = VouchstoneClient(
+    api_url="https://api.vouchstone.ai",
+    api_key="your-api-key",
+    tenant_id="your-tenant-id",
+)
+
+# List agents
+agents = await client.list_agents()
+
+# Execute an agent
+result = await client.execute(agent_id="...", input={"content": "Hello"})
+```
+
+## License
+
+Proprietary — Copyright (c) 2026 Vouchstone Inc. All Rights Reserved.

vouchstone_sdk-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+vouchstone_sdk/__init__.py,sha256=zsYejIqKxod_gkESjH50cDZnBiBF48v6mUIlvSQfZbQ,510
+vouchstone_sdk/agent.py,sha256=uOzYuWM1-QX1pDW81gF96vWZ1yiT6cxdZFvRmBncmY4,5384
+vouchstone_sdk/client.py,sha256=lsVdP0rSy-Iml58vBoIlbjF3lgGvL7ni7RyzBG2Js4E,4492
+vouchstone_sdk/memory.py,sha256=bIBKXubJUWqgJvRXFw_bsLsva3gXAonwJdH3V1gULy4,8326
+vouchstone_sdk/types.py,sha256=sLKYYgdnXlZ1aqhILs_qmgQASL11gDQyHJ35_073-4E,1908
+vouchstone_sdk-1.0.0.dist-info/METADATA,sha256=3SVYINig7kwjNUFMFyyS1zkf0qwI3w5KpYtaWqmAluw,3826
+vouchstone_sdk-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+vouchstone_sdk-1.0.0.dist-info/top_level.txt,sha256=jq-KNYdmZHhfBiit-AgzwaaZ8XKCVBxZhOBlOlY5GZA,15
+vouchstone_sdk-1.0.0.dist-info/RECORD,,

vouchstone_sdk-1.0.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
+

vouchstone_sdk-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+vouchstone_sdk