waveflowdb-client 0.0.1__tar.gz → 0.0.2__tar.gz

{waveflowdb_client-0.0.1 → waveflowdb_client-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
-Name: waveflowdb-client
-Version: 0.0.1
+Name: waveflowdb_client
+Version: 0.0.2
 Summary: VectorLake SDK — Deterministic backend engine powering agent workflows
 Author-email: "agentanalytics.ai" <nitin@agentanalytics.ai>
 License: MIT License
@@ -73,7 +73,7 @@ to interact with the Vector Lake API.
 ### 1. Install Dependencies
 
 ``` bash
-pip install waveflowdb-client
+pip install waveflowdb_client
 ```
 
 ### 2. Configure API Credentials

{waveflowdb_client-0.0.1 → waveflowdb_client-0.0.2}/pyproject.toml

@@ -3,8 +3,8 @@ requires = ["setuptools>=61.0", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [project]
-name = "waveflowdb-client"                   # pip install name
-version = "0.0.1"
+name = "waveflowdb_client"                   # pip install name
+version = "0.0.2"
 description = "VectorLake SDK — Deterministic backend engine powering agent workflows"
 readme = "readme.md"
 requires-python = ">=3.8"

{waveflowdb_client-0.0.1 → waveflowdb_client-0.0.2}/readme.md

@@ -35,7 +35,7 @@ to interact with the Vector Lake API.
 ### 1. Install Dependencies
 
 ``` bash
-pip install waveflowdb-client
+pip install waveflowdb_client
 ```
 
 ### 2. Configure API Credentials

waveflowdb_client-0.0.2/waveflowdb_client/__init__.py

@@ -0,0 +1,18 @@
+__version__ = "1.0.0"
+
+from .client import VectorLakeClient
+from .config import Config
+from .exceptions import APIError, FileProcessingError
+from .models import DocumentInfo, ChatResponse, MatchingDocsResponse, HealthResponse, BatchResult
+
+__all__ = [
+    "VectorLakeClient",
+    "Config",
+    "APIError",
+    "FileProcessingError",
+    "DocumentInfo",
+    "ChatResponse",
+    "MatchingDocsResponse",
+    "HealthResponse",
+    "BatchResult",
+]

waveflowdb_client-0.0.2/waveflowdb_client/client.py

@@ -0,0 +1,297 @@
+import time
+import logging
+import json
+import requests
+import os
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import List, Optional, Dict, Any
+
+from .config import Config
+from .utils import FileProcessor, Logger, BatchManager
+from .exceptions import APIError
+from .models import ChatResponse, MatchingDocsResponse, HealthResponse, BatchResult
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+class VectorLakeClient:
+    def __init__(self, config: Optional[Config] = None, **kwargs):
+        if config is None:
+            config = Config(**kwargs)
+        logging.info(f"Initializing VectorLakeClient with base_url={config.base_url_query}")
+        self.config = config
+        self.logger = Logger(config.log_dir)
+        self.batch_manager = BatchManager(config.max_files_per_batch, config.max_batch_size_mb)
+        self.file_processor = FileProcessor()
+        self.perf_csv = "performance_logs.csv" 
+
+    def _get_headers(self) -> Dict[str, str]:
+        return {
+            'Content-Type': 'application/json',
+            'x-api-key': self.config.api_key
+        }
+
+    def _make_request(self, endpoint: str, payload: Dict[str, Any], operation: str = "", batch_num: int = 0) -> Dict[str, Any]:
+        headers = self._get_headers()
+        request_size = len(json.dumps(payload).encode('utf-8')) / 1024 if payload is not None else 0
+        for attempt in range(self.config.max_retries):
+            try:
+                start_time = time.time()
+                response = requests.post(endpoint, json=payload, headers=headers, timeout=self.config.timeout)
+                latency = (time.time() - start_time) * 1000
+                try:
+                    result = response.json()
+                except Exception:
+                    result = {"status_code": response.status_code, "text": response.text}
+
+                if operation:
+                    response_size = len(response.content) / 1024 if response.content is not None else 0
+                    result_count = len(result.get("results", [])) if isinstance(result, dict) else "N/A"
+                    self.logger.log_performance(operation, batch_num, latency, request_size, response_size, result_count)
+
+                if response.status_code >= 400:
+                    raise APIError(result.get('message', f'HTTP {response.status_code}'), status_code=response.status_code, response_text=response.text)
+
+                return result
+            except requests.exceptions.RequestException as e:
+                if attempt == self.config.max_retries - 1:
+                    error_msg = f"Request failed after {self.config.max_retries} attempts: {str(e)}"
+                    if operation:
+                        self.logger.log_api_error(operation, batch_num, error_msg)
+                    raise APIError(error_msg, getattr(e.response, 'status_code', None), getattr(e.response, 'text', None))
+                time.sleep(2 ** attempt)
+
+    def _read_files(self, filenames: List[str]) -> List[str]:
+        contents = []
+        for filename in filenames:
+            filepath = os.path.join(self.config.vector_lake_path, filename)
+            try:
+                if self.file_processor.is_supported_file(filename):
+                    content = self.file_processor.read_file_content(filepath)
+                    contents.append(content)
+                else:
+                    self.logger.log_skipped_file(filename, "Unsupported file type")
+                    contents.append("")
+            except Exception as e:
+                self.logger.log_skipped_file(filename, f"Read error: {str(e)}")
+                contents.append("")
+        return contents
+
+    def chat_with_docs(self,
+                       query: str,
+                       user_id: str,
+                       vector_lake_description: str,
+                       pattern: str = "static",
+                       session_id: Optional[str] = None,
+                       hybrid_filter: bool = False,
+                       top_docs: int = 3,
+                       threshold: float = 0.2,
+                       files: Optional[List[str]] = None) -> Dict[str, Any]:
+        endpoint = self.config.endpoints["chat_with_docs"]
+        payload = {
+            "session_id": session_id,
+            "user_id": user_id,
+            "vector_lake_description": vector_lake_description,
+            "query": query,
+            "hybrid_filter": hybrid_filter,
+            "top_docs": top_docs,
+            "threshold": threshold,
+            "pattern": pattern
+        }
+
+        if pattern == "dynamic" and files:
+            file_contents = self._read_files(files)
+            payload.update({
+                "files_name": files,
+                "files_data": file_contents
+            })
+
+        try:
+            result = self._make_request(endpoint, payload, "chat_with_docs")
+            return result
+        except Exception as e:
+            return ChatResponse(response=f"Error: {e}", query=query, session_id=session_id or "", user_id=user_id, timestamp=time.time())
+
+    def get_matching_docs(self,
+                          query: str,
+                          user_id: str,
+                          vector_lake_description: str,
+                          pattern: str = "static",
+                          session_id: Optional[str] = None,
+                          hybrid_filter: bool = False,
+                          top_docs: int = 10,
+                          threshold: float = 0.2,
+                          files: Optional[List[str]] = None,
+                          with_data: bool = False) -> Dict[str, Any]:
+        endpoint_key = "top_matching_docs_with_data" if with_data else "top_matching_docs"
+        endpoint = self.config.endpoints[endpoint_key]
+        payload = {
+            "session_id": session_id,
+            "user_id": user_id,
+            "vector_lake_description": vector_lake_description,
+            "query": query,
+            "hybrid_filter": hybrid_filter,
+            "top_docs": top_docs,
+            "threshold": threshold,
+            "pattern": pattern
+        }
+
+        if pattern == "dynamic" and files:
+            file_contents = self._read_files(files)
+            payload.update({
+                "files_name": files,
+                "files_data": file_contents
+            })
+
+        try:
+            raw_result = self._make_request(endpoint, payload, endpoint_key)
+            return raw_result
+        except Exception as e:
+            raise
+
+    def add_documents(self,
+                      user_id: str,
+                      vector_lake_description: str,
+                      start_from_batch=1,
+                      intelligent_segmentation: bool = True,
+                      session_id: Optional[str] = None,
+                      files: Optional[List[str]] = None,
+                      files_name: Optional[List[str]] = None,
+                      files_data: Optional[List[str]] = None,
+                      max_workers=5) -> List[BatchResult]:
+        # If user supplies file names and data directly, bypass batching
+        if files_name and files_data:
+            if len(files_name) != len(files_data):
+                raise ValueError("files_name and files_data must be same length")
+            payload = {
+                "session_id": session_id,
+                "user_id": user_id,
+                "vector_lake_description": vector_lake_description,
+                "files_name": files_name,
+                "files_data": files_data,
+                "intelligent_segmentation": intelligent_segmentation
+            }
+            endpoint = self.config.endpoints["add_docs"]
+            result = self._make_request(endpoint, payload, "add_docs", batch_num=1)
+            return [BatchResult(batch_number=1, response=result, files_processed=files_name, success=True)]
+
+        return self._process_files_in_batches(
+            "add_docs", user_id, vector_lake_description, start_from_batch, intelligent_segmentation, session_id, files, max_workers=max_workers
+        )
+
+    def refresh_documents(self,
+                          user_id: str,
+                          vector_lake_description: str,
+                          intelligent_segmentation: bool = True,
+                          session_id: Optional[str] = None,
+                          files: Optional[List[str]] = None,
+                          files_name: Optional[List[str]] = None,
+                          files_data: Optional[List[str]] = None) -> List[BatchResult]:
+        # If user supplies file names and data directly, bypass batching
+        if files_name and files_data:
+            if len(files_name) != len(files_data):
+                raise ValueError("files_name and files_data must be same length")
+            payload = {
+                "session_id": session_id,
+                "user_id": user_id,
+                "vector_lake_description": vector_lake_description,
+                "files_name": files_name,
+                "files_data": files_data,
+                "intelligent_segmentation": intelligent_segmentation
+            }
+            endpoint = self.config.endpoints["refresh_docs"]
+            result = self._make_request(endpoint, payload, "refresh_docs", batch_num=1)
+            return [BatchResult(batch_number=1, response=result, files_processed=files_name, success=True)]
+
+        return self._process_files_in_batches(
+            "refresh_docs", user_id, vector_lake_description, 1, intelligent_segmentation, session_id, files
+        )
+
+    def health_check(self, user_id: str, vector_lake_description: str, session_id: Optional[str] = None) -> Dict[str, Any]:
+        endpoint = self.config.endpoints["health"]
+        payload = {"session_id": session_id, "user_id": user_id, "vector_lake_description": vector_lake_description}
+        try:
+            result = self._make_request(endpoint, payload, "health")
+            return HealthResponse(status="success", message=result.get("message", "ok"), timestamp=time.time(), details=result)
+        except Exception as e:
+            return HealthResponse(status="error", message=str(e), timestamp=time.time())
+
+    def get_namespace_details(self, user_id: str, session_id: Optional[str] = None, vector_lake_description: Optional[str] = None) -> Dict[str, Any]:
+        endpoint = self.config.endpoints["get_namespace_details_by_userid"]
+        payload = {"session_id": session_id, "user_id": user_id}
+        if vector_lake_description:
+            payload["vector_lake_description"] = vector_lake_description
+        try:
+            result = self._make_request(endpoint, payload, "get_namespace_details")
+            return result
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    def get_docs_information(self, user_id: str, vector_lake_description: str, session_id: Optional[str] = None, keyword: Optional[str] = None, threshold: int = 70) -> Dict[str, Any]:
+        endpoint = self.config.endpoints["get_docs_information"]
+        payload = {"session_id": session_id, "user_id": user_id, "vector_lake_description": vector_lake_description, "threshold": threshold}
+        if keyword:
+            payload["keyword"] = keyword
+        try:
+            result = self._make_request(endpoint, payload, "get_docs_information")
+            return result
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    def full_corpus_search(self, user_id: str, vector_lake_description: str, keyword: str, session_id: Optional[str] = None, top_docs: int = 10) -> Dict[str, Any]:
+        endpoint = self.config.endpoints["full_corpus_search"]
+        payload = {"session_id": session_id, "user_id": user_id, "vector_lake_description": vector_lake_description, "keyword": keyword, "top_docs": top_docs}
+        try:
+            result = self._make_request(endpoint, payload, "full_corpus_search")
+            return result
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    def _make_request_with_backoff(self, endpoint, payload, operation, batch_num, retries=5, base_delay=1):
+        delay = base_delay
+        for attempt in range(retries):
+            try:
+                result = self._make_request(endpoint, payload, operation, batch_num)
+                return result
+            except APIError as e:
+                if getattr(e, "status_code", None) == 429:
+                    logging.warning(f"Batch {batch_num} throttled, retrying in {delay}s...")
+                    time.sleep(delay)
+                    delay *= 2
+                    continue
+                raise
+            except Exception:
+                raise
+
+    def _process_files_in_batches(self, operation: str, user_id: str, vector_lake_description: str, start_from_batch, intelligent_segmentation: bool = False, session_id: Optional[str] = None, files: Optional[List[str]] = None, max_workers: int = 1, batch_delay: float = 2):
+        if files is None:
+            files = [f for f in os.listdir(self.config.vector_lake_path) if os.path.isfile(os.path.join(self.config.vector_lake_path, f)) and self.file_processor.is_supported_file(f)]
+        batches = self.batch_manager.create_batches(files, self.config.vector_lake_path)
+        results = []
+        start_batch_index = start_from_batch - 1
+        if start_from_batch > 1:
+            logging.info(f"Resuming from batch {start_from_batch}, skipping first {start_from_batch - 1} batches")
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            futures = {}
+            for i, batch in enumerate(batches):
+                if i < start_batch_index:
+                    logging.info(f"Skipping batch {i + 1}")
+                    continue
+                batch_num = i + 1
+                file_contents = self._read_files(batch)
+                payload = {"session_id": session_id, "user_id": user_id, "vector_lake_description": vector_lake_description, "files_name": batch, "files_data": file_contents, "intelligent_segmentation": intelligent_segmentation}
+                endpoint = self.config.endpoints[operation]
+                futures[executor.submit(self._make_request_with_backoff, endpoint, payload, operation, batch_num)] = (batch_num, batch, time.time())
+                time.sleep(batch_delay)
+            for future in as_completed(futures):
+                batch_num, batch, start_time = futures[future]
+                try:
+                    result = future.result()
+                    processing_time = time.time() - start_time
+                    logging.info(f"Batch {batch_num} done")
+                    results.append(BatchResult(batch_number=batch_num, response=result, files_processed=batch, success=True, processing_time=processing_time))
+                except Exception as e:
+                    processing_time = time.time() - start_time
+                    logging.error(f"Batch {batch_num} failed: {str(e)}")
+                    results.append(BatchResult(batch_number=batch_num, response=str(e), files_processed=batch, success=False, error_message=str(e), processing_time=processing_time))
+        return results

waveflowdb_client-0.0.2/waveflowdb_client/config.py

@@ -0,0 +1,56 @@
+import os
+from typing import Optional, Dict
+
+class Config:
+    ALLOWED_EXTENSIONS = ["txt", "csv", "json", "py", "docx", "pdf"]
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        host: str = "https://waveflow-analytics.com",
+        timeout: int = 60,
+        max_retries: int = 2,
+        max_files_per_batch: int = 100,
+        max_batch_size_mb: int = 20,
+        vector_lake_path: str = "upload",
+        log_dir: str = "logs",
+    ):
+        self.api_key = api_key or os.getenv("VECTOR_LAKE_API_KEY")
+        self.host = host.rstrip("/")
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.max_files_per_batch = max_files_per_batch
+        self.max_batch_size_mb = max_batch_size_mb
+        self.vector_lake_path = vector_lake_path
+        self.log_dir = log_dir
+
+        if not self.api_key:
+            raise ValueError("API key is required. Provide api_key or set VECTOR_LAKE_API_KEY environment variable.")
+
+        os.makedirs(self.log_dir, exist_ok=True)
+        os.makedirs(self.vector_lake_path, exist_ok=True)
+
+    @property
+    def base_url_query(self) -> str:
+        return f"{self.host}/query"
+
+    @property
+    def base_url_upload(self) -> str:
+        return f"{self.host}/upload"
+
+    @property
+    def endpoints(self) -> Dict[str, str]:
+        return {
+            # Query service
+            "chat_with_docs": f"{self.base_url_query}/chat_with_docs",
+            "top_matching_docs": f"{self.base_url_query}/top_matching_docs",
+            "top_matching_docs_with_data": f"{self.base_url_query}/top_matching_docs_with_data",
+            "full_corpus_search": f"{self.base_url_query}/full_corpus_search",
+
+            # Upload service
+            "add_docs": f"{self.base_url_upload}/add_docs",
+            "refresh_docs": f"{self.base_url_upload}/refresh_docs",
+            "health": f"{self.base_url_upload}/health",
+            "get_namespace_details_by_userid": f"{self.base_url_upload}/get_namespace_details_by_userid",
+            "get_docs_information": f"{self.base_url_upload}/get_docs_information",
+        }

waveflowdb_client-0.0.2/waveflowdb_client/exceptions.py

@@ -0,0 +1,11 @@
+class VectorLakeError(Exception):
+    pass
+
+class APIError(VectorLakeError):
+    def __init__(self, message: str, status_code: int = None, response_text: str = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.response_text = response_text
+
+class FileProcessingError(VectorLakeError):
+    pass

waveflowdb_client-0.0.2/waveflowdb_client/models.py

@@ -0,0 +1,44 @@
+from dataclasses import dataclass
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+
+@dataclass
+class DocumentInfo:
+    filename: str
+    content: str
+    size: int
+    modified_time: Optional[datetime] = None
+
+@dataclass
+class ChatResponse:
+    response: str
+    query: str
+    session_id: str
+    user_id: str
+    timestamp: datetime
+
+@dataclass
+class MatchingDocsResponse:
+    status: str
+    query: str
+    response: str
+    with_data: bool
+    session_id: str
+    user_id: str
+    timestamp: datetime
+
+@dataclass
+class HealthResponse:
+    status: str
+    message: str
+    timestamp: datetime
+    details: Optional[Dict[str, Any]] = None
+
+@dataclass
+class BatchResult:
+    batch_number: int
+    response: Any
+    files_processed: List[str]
+    success: bool
+    error_message: Optional[str] = None
+    processing_time: Optional[float] = None

waveflowdb_client-0.0.2/waveflowdb_client/utils.py

@@ -0,0 +1,149 @@
+import os
+import csv
+import logging
+from pathlib import Path
+from datetime import datetime
+import json
+import traceback
+import time
+from typing import List
+# Heavy libs are imported at runtime when needed in real environments.
+
+from .exceptions import FileProcessingError
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+class FileProcessor:
+    SUPPORTED_EXTENSIONS = ['txt', 'csv', 'json', 'py', 'docx', 'pdf']
+
+    @staticmethod
+    def read_file_content(filepath: str) -> str:
+        ext = filepath.lower().split('.')[-1]
+        if ext in ['txt', 'csv', 'py', 'json']:
+            with open(filepath, encoding='utf-8') as f:
+                return f.read()
+        # Defer complex parsing to runtime imports to avoid import-time failures.
+        if ext == 'docx':
+            try:
+                from docx import Document
+            except Exception as e:
+                raise FileProcessingError(f"python-docx not available: {e}")
+            doc = Document(filepath)
+            return '\n'.join(p.text for p in doc.paragraphs)
+        if ext == 'pdf':
+            try:
+                import PyPDF2
+            except Exception as e:
+                raise FileProcessingError(f"PyPDF2 not available: {e}")
+            with open(filepath, 'rb') as f:
+                reader = PyPDF2.PdfReader(f)
+                return '\n'.join(p.extract_text() or '' for p in reader.pages)
+        raise FileProcessingError(f'Unsupported extension: {ext}')
+
+    @staticmethod
+    def get_file_size(filepath: str) -> int:
+        return os.path.getsize(filepath)
+
+    @staticmethod
+    def is_supported_file(filename: str) -> bool:
+        ext = filename.lower().split('.')[-1]
+        return ext in FileProcessor.SUPPORTED_EXTENSIONS
+
+class Logger:
+    def __init__(self, log_dir: str):
+        Path(log_dir).mkdir(parents=True, exist_ok=True)
+        self.skipped_log = Path(log_dir) / 'skipped_files_log.csv'
+        self.api_error_log = Path(log_dir) / 'api_error_log.csv'
+        self.performance_log = Path(log_dir) / 'api_performance_log.csv'
+
+    def _write_csv_log(self, path: Path, header: List[str], row: List):
+        exists = path.exists()
+        with open(path, 'a', newline='', encoding='utf-8') as f:
+            writer = csv.writer(f)
+            if not exists:
+                writer.writerow(header)
+            writer.writerow(row)
+
+    def log_skipped_file(self, filename: str, reason: str):
+        self._write_csv_log(self.skipped_log, ['ts', 'filename', 'reason'], [datetime.utcnow().isoformat(), filename, reason])
+
+    def log_api_error(self, operation: str, batch_num: int, error_message: str):
+        self._write_csv_log(self.api_error_log, ['ts', 'operation', 'batch_num', 'err'], [datetime.utcnow().isoformat(), operation, batch_num, error_message])
+
+    def log_performance(self, operation=None, batch_num=None, latency=None,
+                    request_size=None, response_size=None, result_count=None,
+                    files_processed=None, error: Exception = None):
+        """
+        SAFE CSV logger for all SDK operations.
+        It will never throw TypeError regardless of input type.
+        """
+
+        logfile = getattr(self, "perf_csv", "performance_logs.csv")
+
+        # --- Safe stringify for ANY type ---
+        def safe_str(value):
+            try:
+                if isinstance(value, (list, tuple, set)):
+                    return ",".join(str(v) for v in value)
+                return str(value) if value is not None else ""
+            except Exception:
+                return "UNSERIALIZABLE"
+
+        row = {
+            "timestamp": datetime.utcnow().isoformat(),
+            "operation": safe_str(operation),
+            "batch_num": safe_str(batch_num),
+            "latency_ms": safe_str(latency),
+            "request_size": safe_str(request_size),
+            "response_size": safe_str(response_size),
+            "result_count": safe_str(result_count),
+            "files_processed": safe_str(files_processed),
+            "error": safe_str(error),
+        }
+
+        try:
+            file_exists = os.path.isfile(logfile)
+
+            with open(logfile, mode="a", newline="", encoding="utf-8") as f:
+                writer = csv.DictWriter(f, fieldnames=row.keys())
+
+                if not file_exists:
+                    writer.writeheader()
+
+                writer.writerow(row)
+
+        except Exception:
+            print("[CSV LOGGING ERROR] Could not write performance log:")
+            print(traceback.format_exc())
+
+class BatchManager:
+    def __init__(self, max_files: int, max_size_mb: int):
+        self.max_files = max_files
+        self.max_bytes = max_size_mb * 1024 * 1024
+
+    def create_batches(self, files: List[str], base_path: str) -> List[List[str]]:
+        file_info = []
+        for f in files:
+            p = os.path.join(base_path, f)
+            try:
+                size = os.path.getsize(p)
+                if size <= self.max_bytes:
+                    file_info.append((f, size))
+            except Exception:
+                continue
+
+        batches = []
+        cur = []
+        cur_size = 0
+        for fname, size in file_info:
+            if len(cur) >= self.max_files or (cur_size + size) > self.max_bytes:
+                if cur:
+                    batches.append(cur)
+                cur = []
+                cur_size = 0
+            cur.append(fname)
+            cur_size += size
+        if cur:
+            batches.append(cur)
+        return batches

{waveflowdb_client-0.0.1 → waveflowdb_client-0.0.2}/waveflowdb_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
-Name: waveflowdb-client
-Version: 0.0.1
+Name: waveflowdb_client
+Version: 0.0.2
 Summary: VectorLake SDK — Deterministic backend engine powering agent workflows
 Author-email: "agentanalytics.ai" <nitin@agentanalytics.ai>
 License: MIT License
@@ -73,7 +73,7 @@ to interact with the Vector Lake API.
 ### 1. Install Dependencies
 
 ``` bash
-pip install waveflowdb-client
+pip install waveflowdb_client
 ```
 
 ### 2. Configure API Credentials

waveflowdb_client-0.0.2/waveflowdb_client.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+pyproject.toml
+readme.md
+waveflowdb_client/__init__.py
+waveflowdb_client/client.py
+waveflowdb_client/config.py
+waveflowdb_client/exceptions.py
+waveflowdb_client/models.py
+waveflowdb_client/utils.py
+waveflowdb_client.egg-info/PKG-INFO
+waveflowdb_client.egg-info/SOURCES.txt
+waveflowdb_client.egg-info/dependency_links.txt
+waveflowdb_client.egg-info/requires.txt
+waveflowdb_client.egg-info/top_level.txt

waveflowdb_client-0.0.2/waveflowdb_client.egg-info/top_level.txt

@@ -0,0 +1 @@
+waveflowdb_client

waveflowdb_client-0.0.1/starter.py

@@ -1,195 +0,0 @@
-"""
-run.py
-Simple launcher for Vector Lake SDK (v1.0.0)
-
-Allows you to:
-  - configure client (host, port, key)
-  - call ANY API: add, refresh, chat, match, health, namespace info, etc.
-"""
-
-from waveflowdb-client import Config, VectorLakeClient
-
-
-# -------------------------------------------------------
-# CONFIGURATION (EDIT THIS ONCE)
-# -------------------------------------------------------
-API_KEY = "<<>>"  # visit https://db.agentanalytics.ai/signup
-HOST = "https://waveflow-analytics.com"       # OR "http://localhost"
-VECTOR_LAKE_PATH = "<<>>"       # folder for path-based ingestion
-USER_ID = ""   ## your email id used for registratoin
-NAMESPACE = ""  ## database created via UI 
-
-
-# -------------------------------------------------------
-# INITIALIZE CLIENT
-# -------------------------------------------------------
-def get_client():
-    cfg = Config(
-        api_key=API_KEY,
-        host=HOST,
-        vector_lake_path=VECTOR_LAKE_PATH
-    )
-    return VectorLakeClient(cfg)
-
-
-client = get_client()
-
-
-# -------------------------------------------------------
-# READY-TO-USE ACTION FUNCTIONS
-# -------------------------------------------------------
-
-def run_health():
-    """Health check"""
-    print("\n--- HEALTH CHECK ---")
-    res = client.health_check(USER_ID, NAMESPACE)
-    print(res)
-
-
-def run_add_direct():
-    """Add docs using files_name + files_data"""
-    print("\n--- ADD DOCUMENTS (Direct Payload Mode) ---")
-    res = client.add_documents(
-        user_id=USER_ID,
-        vector_lake_description=NAMESPACE,
-        files_name=["test1.txt", "test2.txt"],
-        files_data=["hello world", "this is test doc 2"]
-    )
-    print(res)
-
-
-def run_add_path():
-    """Add docs by reading actual files from disk"""
-    print("\n--- ADD DOCUMENTS (Disk Path Mode) ---")
-    res = client.add_documents(
-        user_id=USER_ID,
-        vector_lake_description=NAMESPACE
-        # files=[""]   # must exist inside VECTOR_LAKE_PATH
-    )
-    print(res)
-
-
-def run_refresh_direct():
-    """Refresh docs using direct data (no disk read)"""
-    print("\n--- REFRESH DOCUMENTS (Direct Data Mode) ---")
-    res = client.refresh_documents(
-        user_id=USER_ID,
-        vector_lake_description=NAMESPACE,
-        files_name=["test1.txt"],
-        files_data=["UPDATED CONTENT FOR TEST1"]
-    )
-    print(res)
-
-
-def run_refresh_path():
-    """Refresh docs by reading actual files"""
-    print("\n--- REFRESH DOCUMENTS (Path Mode) ---")
-    res = client.refresh_documents(
-        user_id=USER_ID,
-        vector_lake_description=NAMESPACE
-        # files=["file1.pdf"]     # must exist
-    )
-    print(res)
-
-
-def run_chat_static(query):
-    """Chat with stored index"""
-    print("\n--- CHAT (STATIC MODE) ---")
-    res = client.chat_with_docs(
-        query=query,
-        user_id=USER_ID,
-        vector_lake_description=NAMESPACE,
-        pattern="static"
-    )
-    print(res)
-
-
-def run_chat_dynamic(query):
-    """Chat using temporary files (dynamic mode)"""
-    print("\n--- CHAT (DYNAMIC MODE) ---")
-    res = client.chat_with_docs(
-        query=query,
-        user_id=USER_ID,
-        vector_lake_description=NAMESPACE,
-        pattern="dynamic",
-        files_name=["dyn1.txt"],
-        files_data=["This is dynamic content to summarize."]
-    )
-    print(res)
-
-
-def run_match_static(query):
-    """Top matching docs (static mode)"""
-    print("\n--- TOP MATCHING DOCS (STATIC) ---")
-    res = client.get_matching_docs(
-        query=query,
-        user_id=USER_ID,
-        vector_lake_description=NAMESPACE,
-        pattern="static",
-        top_docs=5,
-        threshold=0.1
-    )
-    print(res)
-
-
-def run_match_dynamic(query):
-    """Top matching docs (dynamic mode)"""
-    print("\n--- TOP MATCHING DOCS (DYNAMIC) ---")
-    res = client.get_matching_docs(
-        query=query,
-        user_id=USER_ID,
-        vector_lake_description=NAMESPACE,
-        pattern="dynamic",
-        files_name=["temp.txt"],
-        files_data=["Sample dynamic content"]
-    )
-    print(res)
-
-
-def run_match_with_data(query):
-    """Top matching docs including chunk data"""
-    print("\n--- TOP MATCHING DOCS (WITH DATA) ---")
-    res = client.get_matching_docs(
-        query=query,
-        user_id=USER_ID,
-        vector_lake_description=NAMESPACE,
-        pattern="static",
-        top_docs=5,
-        with_data=True
-    )
-    print(res)
-
-
-def run_namespace_details():
-    """Get namespace information"""
-    print("\n--- GET NAMESPACE DETAILS ---")
-    res = client.get_namespace_details(USER_ID, vector_lake_description=NAMESPACE)
-    print(res)
-
-
-def run_docs_info():
-    """List all stored docs + info"""
-    print("\n--- GET DOCS INFORMATION ---")
-    res = client.get_docs_information(USER_ID, NAMESPACE)
-    print(res)
-
-
-# -------------------------------------------------------
-# MAIN SELECTOR – RUN ANY FUNCTION YOU WANT
-# -------------------------------------------------------
-if __name__ == "__main__":
-    query="<<>>"
-    # --- UNCOMMENT ANY ONE OF THESE TO RUN THAT OPERATION ---
-    # run_health()
-    # run_add_direct()
-    # run_add_path()
-    # run_refresh_direct()
-    # run_refresh_path()
-    # run_chat_static(query)
-    # run_chat_dynamic(query)
-    # run_match_static(query)
-    # run_match_dynamic(query)
-    # run_match_with_data(query)
-    run_namespace_details()
-    # run_docs_info()
-

waveflowdb_client-0.0.1/waveflowdb_client.egg-info/SOURCES.txt

@@ -1,9 +0,0 @@
-LICENSE
-pyproject.toml
-readme.md
-starter.py
-waveflowdb_client.egg-info/PKG-INFO
-waveflowdb_client.egg-info/SOURCES.txt
-waveflowdb_client.egg-info/dependency_links.txt
-waveflowdb_client.egg-info/requires.txt
-waveflowdb_client.egg-info/top_level.txt

waveflowdb_client-0.0.1/waveflowdb_client.egg-info/top_level.txt

@@ -1 +0,0 @@
-starter