vectorwave 0.2.0__tar.gz → 0.2.1__tar.gz

{vectorwave-0.2.0/src/vectorwave.egg-info → vectorwave-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectorwave
-Version: 0.2.0
+Version: 0.2.1
 Summary: VectorWave: Seamless Auto-Vectorization Framework
 Author-email: junyeonggim <junyeonggim5@gmail.com>
 License-Expression: MIT

{vectorwave-0.2.0 → vectorwave-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vectorwave"
-version = "0.2.0"
+version = "0.2.01"
 authors = [
     { name = "junyeonggim", email = "junyeonggim5@gmail.com" },
 ]

vectorwave-0.2.1/src/tests/core/llm/test_token_usage.py

@@ -0,0 +1,112 @@
+import pytest
+from unittest.mock import MagicMock, patch
+from vectorwave.core.llm.openai_client import VectorWaveOpenAIClient
+
+@pytest.fixture
+def mock_deps(monkeypatch):
+    """
+    Mocks the dependencies (BatchManager, OpenAI, Settings) of VectorWaveOpenAIClient.
+    """
+    # 1. Mock BatchManager (Target for verifying token usage persistence)
+    mock_batch = MagicMock()
+    mock_batch.add_object = MagicMock()
+    mock_get_batch = MagicMock(return_value=mock_batch)
+    monkeypatch.setattr("vectorwave.core.llm.openai_client.get_batch_manager", mock_get_batch)
+
+    # 2. Mock Settings (Bypasses API Key check)
+    mock_settings = MagicMock()
+    mock_settings.OPENAI_API_KEY = "sk-test-key"
+    mock_get_settings = MagicMock(return_value=mock_settings)
+    monkeypatch.setattr("vectorwave.core.llm.openai_client.get_weaviate_settings", mock_get_settings)
+
+    # 3. Mock OpenAI Class (Bypasses actual API calls)
+    mock_openai_cls = MagicMock()
+    monkeypatch.setattr("vectorwave.core.llm.openai_client.OpenAI", mock_openai_cls)
+
+    # Note: Clearing the lru_cache for the singleton instance is typically
+    # needed if the client is imported globally. We assume the current test
+    # setup allows for fresh initialization here.
+
+    return {
+        "batch": mock_batch,
+        "openai_cls": mock_openai_cls
+    }
+
+def test_chat_completion_logs_token_usage(mock_deps):
+    """
+    [Case 1] Verify that token usage is logged as 'generation' type during chat completion.
+    """
+    # Arrange
+    # Get the mock client instance returned when OpenAI() is called
+    mock_client_instance = mock_deps["openai_cls"].return_value
+
+    # Mock OpenAI Response structure
+    mock_response = MagicMock()
+    mock_response.choices = [MagicMock(message=MagicMock(content="Test response"))]
+    mock_response.usage.total_tokens = 123  # Token count to test
+    mock_client_instance.chat.completions.create.return_value = mock_response
+
+    # Act
+    # Create a new client instance for the test
+    client = VectorWaveOpenAIClient()
+    result = client.create_chat_completion(
+        messages=[{"role": "user", "content": "Hi"}],
+        model="gpt-4-test",
+        category="test_chat_category"
+    )
+
+    # Assert
+    # 1. Verify that the function returns the expected result
+    assert result == "Test response"
+
+    # 2. Verify that BatchManager.add_object was called (log saved)
+    mock_batch = mock_deps["batch"]
+    mock_batch.add_object.assert_called_once()
+
+    # 3. Verify the properties of the saved log entry
+    call_kwargs = mock_batch.add_object.call_args.kwargs
+    props = call_kwargs["properties"]
+
+    assert call_kwargs["collection"] == "VectorWaveTokenUsage"
+    assert props["tokens"] == 123
+    assert props["model"] == "gpt-4-test"
+    assert props["category"] == "test_chat_category"
+    assert props["usage_type"] == "generation"
+
+def test_create_embedding_logs_token_usage(mock_deps):
+    """
+    [Case 2] Verify that token usage is logged as 'embedding' type during embedding creation.
+    """
+    # Arrange
+    mock_client_instance = mock_deps["openai_cls"].return_value
+
+    # Mock OpenAI Response structure
+    mock_response = MagicMock()
+    mock_response.data = [MagicMock(embedding=[0.1, 0.2, 0.3])]
+    mock_response.usage.total_tokens = 45  # Token count to test
+    mock_client_instance.embeddings.create.return_value = mock_response
+
+    # Act
+    client = VectorWaveOpenAIClient()
+    result = client.create_embedding(
+        text="Test text",
+        model="text-embedding-3-small",
+        category="test_embed_category"
+    )
+
+    # Assert
+    # 1. Verify that the function returns the expected result
+    assert result == [0.1, 0.2, 0.3]
+
+    # 2. Verify that BatchManager.add_object was called
+    mock_batch = mock_deps["batch"]
+    mock_batch.add_object.assert_called_once()
+
+    # 3. Verify the properties of the saved log entry
+    call_kwargs = mock_batch.add_object.call_args.kwargs
+    props = call_kwargs["properties"]
+
+    assert call_kwargs["collection"] == "VectorWaveTokenUsage"
+    assert props["tokens"] == 45
+    assert props["usage_type"] == "embedding"
+    assert props["category"] == "test_embed_category"

{vectorwave-0.2.0 → vectorwave-0.2.1}/src/vectorwave/core/generator.py

@@ -7,6 +7,7 @@ from ..models.db_config import get_weaviate_settings
 from ..batch.batch import get_batch_manager
 from ..vectorizer.factory import get_vectorizer
 from .decorator import PENDING_FUNCTIONS
+from .llm.factory import get_llm_client
 
 logger = logging.getLogger(__name__)
 
@@ -15,20 +16,11 @@ try:
 except ImportError:
     OpenAI = None
 
-def _get_openai_client(settings):
-    if OpenAI is None:
-        logger.error("OpenAI library not installed. Install with 'pip install openai'.")
-        return None
-    if not settings.OPENAI_API_KEY:
-        logger.error("OPENAI_API_KEY is missing in .env.")
-        return None
-    return OpenAI(api_key=settings.OPENAI_API_KEY)
-
 
 def generate_metadata_via_llm(source_code: str, func_name: str) -> Optional[Dict[str, str]]:
     """Call LLM to generate description and narrative from source code."""
     settings = get_weaviate_settings()
-    client = _get_openai_client(settings)
+    client = get_llm_client()
     if not client:
         return None
 
@@ -47,17 +39,22 @@ def generate_metadata_via_llm(source_code: str, func_name: str) -> Optional[Dict
     """
 
     try:
-        response = client.chat.completions.create(
+        # Refactored to use BaseLLMClient interface
+        response_text = client.create_chat_completion(
             model="gpt-4o-mini",
             messages=[
                 {"role": "system", "content": "You are a technical documentation assistant. Output only JSON."},
                 {"role": "user", "content": prompt}
             ],
             temperature=0.0,
-            response_format={"type": "json_object"}
+            response_format={"type": "json_object"},
+            category="auto_doc"
         )
-        content = response.choices[0].message.content
-        return json.loads(content)
+
+        if response_text:
+            return json.loads(response_text)
+        return None
+
     except Exception as e:
         logger.error(f"LLM generation failed for '{func_name}': {e}")
         return None

vectorwave-0.2.1/src/vectorwave/core/llm/base.py

@@ -0,0 +1,47 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict, Optional
+
+class BaseLLMClient(ABC):
+    """
+    Abstract interface that all LLM Providers (OpenAI, Anthropic, etc.) must implement.
+    Implementations must handle internal token usage logging.
+    """
+
+    @abstractmethod
+    def create_embedding(self, text: str, model: str, category: str = "default") -> Optional[List[float]]:
+        """
+        Generates text embeddings.
+
+        Args:
+            text: The text to embed.
+            model: The name of the model to use.
+            category: Category for aggregating token usage (e.g., 'execution_log', 'auto_doc').
+
+        Returns:
+            The generated list of embedding vectors (None on failure).
+        """
+        pass
+
+    @abstractmethod
+    def create_chat_completion(
+            self,
+            messages: List[Dict],
+            model: str,
+            temperature: float = 0.1,
+            response_format: Optional[Dict] = None,
+            category: str = "default"
+    ) -> Optional[str]:
+        """
+        Generates a chat completion (response).
+
+        Args:
+            messages: List of conversation messages [{"role": "user", "content": "..."}].
+            model: The name of the model to use.
+            temperature: Parameter for controlling generation diversity.
+            response_format: Response format (e.g., {"type": "json_object"}).
+            category: Category for aggregating token usage (e.g., 'execution_log', 'auto_doc').
+
+        Returns:
+            The generated text response (None on failure).
+        """
+        pass

vectorwave-0.2.1/src/vectorwave/core/llm/factory.py

@@ -0,0 +1,13 @@
+from .base import BaseLLMClient
+from .openai_client import VectorWaveOpenAIClient
+
+_llm_instance: BaseLLMClient = None
+
+
+def get_llm_client() -> BaseLLMClient:
+    """Returns the singleton LLM client instance."""
+    global _llm_instance
+    if _llm_instance is None:
+        # Can be extended later to return different clients (Anthropic, etc.) based on settings (VECTORIZER, etc.)
+        _llm_instance = VectorWaveOpenAIClient()
+    return _llm_instance

vectorwave-0.2.1/src/vectorwave/core/llm/openai_client.py

@@ -0,0 +1,79 @@
+# src/vectorwave/core/llm/openai_client.py
+import logging
+from typing import List, Dict, Optional
+from datetime import datetime, timezone
+from ...models.db_config import get_weaviate_settings
+from ...batch.batch import get_batch_manager  # [추가]
+from .base import BaseLLMClient
+
+logger = logging.getLogger(__name__)
+
+try:
+    from openai import OpenAI
+except ImportError:
+    OpenAI = None
+
+
+class VectorWaveOpenAIClient(BaseLLMClient):
+    def __init__(self):
+        self.settings = get_weaviate_settings()
+        self.batch_manager = get_batch_manager()
+
+        if OpenAI is None or not self.settings.OPENAI_API_KEY:
+            self.client = None
+        else:
+            self.client = OpenAI(api_key=self.settings.OPENAI_API_KEY)
+
+    def _log_usage(self, tokens: int, model: str, usage_type: str, category: str):
+        if tokens > 0:
+            try:
+                self.batch_manager.add_object(
+                    collection="VectorWaveTokenUsage",
+                    properties={
+                        "timestamp_utc": datetime.now(timezone.utc).isoformat(),
+                        "model": model,
+                        "usage_type": usage_type,
+                        "category": category,
+                        "tokens": tokens
+                    }
+                )
+            except Exception as e:
+                logger.warning(f"Failed to log token usage: {e}")
+
+    def create_embedding(self, text: str, model: str = "text-embedding-3-small", category: str = "default") -> Optional[
+        List[float]]:
+        """
+        Returns: Vector list only (Tokens are logged internally)
+        """
+        if not self.client: return None
+        try:
+            text = text.replace("\n", " ")
+            res = self.client.embeddings.create(input=[text], model=model)
+
+            tokens = res.usage.total_tokens if res.usage else 0
+            self._log_usage(tokens, model, "embedding", category)
+
+            return res.data[0].embedding
+        except Exception as e:
+            logger.error(f"Embedding error: {e}")
+            return None
+
+    def create_chat_completion(self, messages: List[Dict], model: str = "gpt-4-turbo", temperature: float = 0.1,
+                               response_format=None, category: str = "default") -> Optional[str]:
+        """
+        Returns: Content string only (Tokens are logged internally)
+        """
+        if not self.client: return None
+        try:
+            kwargs = {"model": model, "messages": messages, "temperature": temperature}
+            if response_format: kwargs["response_format"] = response_format
+
+            res = self.client.chat.completions.create(**kwargs)
+
+            tokens = res.usage.total_tokens if res.usage else 0
+            self._log_usage(tokens, model, "generation", category)
+
+            return res.choices[0].message.content
+        except Exception as e:
+            logger.error(f"Completion error: {e}")
+            return None

{vectorwave-0.2.0 → vectorwave-0.2.1}/src/vectorwave/database/db.py

@@ -16,6 +16,7 @@ from weaviate.exceptions import WeaviateConnectionError as WeaviateClientConnect
 # Create module-level logger
 logger = logging.getLogger(__name__)
 
+
 # Code based on Weaviate v4 (latest) client.
 
 def get_weaviate_client(settings: WeaviateSettings) -> weaviate.WeaviateClient:
@@ -324,6 +325,36 @@ def create_execution_schema(client: weaviate.WeaviateClient, settings: WeaviateS
         raise SchemaCreationError(f"Error during execution schema creation: {e}")
 
 
+def create_usage_schema(client: weaviate.WeaviateClient, settings: WeaviateSettings):
+    """
+    API call token analysis schema
+    """
+    collection_name = "VectorWaveTokenUsage"
+
+    if client.collections.exists(collection_name):
+        return client.collections.get(collection_name)
+
+    logger.info("Creating collection '%s'", collection_name)
+
+    properties = [
+        wvc.Property(name="timestamp_utc", data_type=wvc.DataType.DATE),
+        wvc.Property(name="model", data_type=wvc.DataType.TEXT),
+        wvc.Property(name="usage_type", data_type=wvc.DataType.TEXT),  # "embedding", "generation" 등
+        wvc.Property(name="category", data_type=wvc.DataType.TEXT),  # "execution_log", "auto_doc" 등
+        wvc.Property(name="tokens", data_type=wvc.DataType.INT),
+    ]
+
+    try:
+        return client.collections.create(
+            name=collection_name,
+            properties=properties,
+            vectorizer_config=wvc.Configure.Vectorizer.none(),
+        )
+    except Exception as e:
+        logger.error(f"Error creating usage schema: {e}")
+        raise SchemaCreationError(f"Error during usage schema creation: {e}")
+
+
 def initialize_database():
     """
     Helper function to initialize both the client and the two schemas.
@@ -334,8 +365,8 @@ def initialize_database():
         if client:
             create_vectorwave_schema(client, settings)
             create_execution_schema(client, settings)
+            create_usage_schema(client, settings)
             return client
     except Exception as e:
         logger.error("Failed to initialize VectorWave database: %s", e)
         return None
-

{vectorwave-0.2.0 → vectorwave-0.2.1}/src/vectorwave/database/db_search.py

@@ -10,6 +10,7 @@ from ..models.db_config import get_weaviate_settings, WeaviateSettings
 from .db import get_cached_client
 from ..exception.exceptions import WeaviateConnectionError
 from ..vectorizer.factory import get_vectorizer
+from weaviate.classes.aggregate import Metrics
 
 import uuid
 from datetime import datetime
@@ -461,3 +462,34 @@ def simulate_drift_check(
     except Exception as e:
         logger.error(f"Simulation failed: {e}")
         return {"error": str(e)}
+
+
+def get_token_usage_stats() -> Dict[str, int]:
+    """VectorWaveTokenUsage collections based analysis"""
+    try:
+        client = get_cached_client()
+        if not client.collections.exists("VectorWaveTokenUsage"):
+            logger.warning("VectorWaveTokenUsage collection does not exist.")
+            return {"total_tokens": 0}
+
+        usage_col = client.collections.get("VectorWaveTokenUsage")
+
+        total_tokens = 0
+        stats = {}
+
+        for obj in usage_col.iterator():
+            props = obj.properties
+            tokens = int(props.get("tokens", 0))
+            category = props.get("category", "unknown")
+
+            total_tokens += tokens
+
+            cat_key = f"{category}_tokens"
+            stats[cat_key] = stats.get(cat_key, 0) + tokens
+
+        stats["total_tokens"] = total_tokens
+        return stats
+
+    except Exception as e:
+        logger.error(f"Stats error: {e}", exc_info=True)
+        return {}

{vectorwave-0.2.0 → vectorwave-0.2.1}/src/vectorwave/search/rag_search.py

@@ -3,6 +3,7 @@ import logging
 from ..database.db_search import search_functions
 from ..models.db_config import get_weaviate_settings
 from ..search.execution_search import find_by_trace_id
+from ..core.llm.factory import get_llm_client
 
 try:
     from openai import OpenAI
@@ -13,17 +14,7 @@ logger = logging.getLogger(__name__)
 
 
 def _get_openai_client():
-    """Loads the OpenAI client (includes configuration check)."""
-    if OpenAI is None:
-        logger.error("OpenAI library not found. Install with 'pip install openai'.")
-        return None
-
-    settings = get_weaviate_settings()
-    if not settings.OPENAI_API_KEY:
-        logger.error("OPENAI_API_KEY is missing in environment variables.")
-        return None
-
-    return OpenAI(api_key=settings.OPENAI_API_KEY)
+    return get_llm_client()
 
 
 def search_and_answer(query: str, model: str = "gpt-4-turbo", language: str = "en") -> str:
@@ -82,15 +73,16 @@ def search_and_answer(query: str, model: str = "gpt-4-turbo", language: str = "e
         return msg if language == 'en' else "❌ OpenAI 클라이언트를 초기화할 수 없습니다. (.env 설정 확인 필요)"
 
     try:
-        response = client.chat.completions.create(
+        response_text = client.create_chat_completion(
             model=model,
             messages=[
                 {"role": "system", "content": system_instruction},
                 {"role": "user", "content": user_message}
             ],
-            temperature=0.1
+            temperature=0.1,
+            category="rag_answer"
         )
-        return response.choices[0].message.content
+        return response_text if response_text else "❌ Failed to generate response."
 
     except Exception as e:
         logger.error(f"LLM generation failed: {e}")
@@ -146,15 +138,16 @@ def analyze_trace_log(trace_id: str, model: str = "gpt-4-turbo", language: str =
         return msg if language == 'en' else "❌ OpenAI 클라이언트 초기화 실패"
 
     try:
-        response = client.chat.completions.create(
+        response_text = client.create_chat_completion(
             model=model,
             messages=[
                 {"role": "system", "content": system_instruction},
                 {"role": "user", "content": log_summary}
             ],
-            temperature=0.1
+            temperature=0.1,
+            category="trace_analysis"
         )
-        return response.choices[0].message.content
+        return response_text if response_text else "❌ Failed to generate analysis."
 
     except Exception as e:
         error_msg = f"❌ Error during analysis: {e}"

{vectorwave-0.2.0 → vectorwave-0.2.1}/src/vectorwave/utils/healer.py

@@ -7,6 +7,7 @@ from datetime import datetime, timedelta, timezone
 from ..search.execution_search import find_executions
 from ..database.db_search import search_functions_hybrid
 from ..models.db_config import get_weaviate_settings
+from ..core.llm.factory import get_llm_client
 
 try:
     from openai import OpenAI
@@ -23,16 +24,7 @@ class VectorWaveHealer:
     def __init__(self, model: str = "gpt-4-turbo"):
         self.settings = get_weaviate_settings()
         self.model = model
-        self.client = self._init_openai()
-
-    def _init_openai(self) -> Optional[OpenAI]:
-        if OpenAI is None:
-            logger.error("'openai' library is not installed.")
-            return None
-        if not self.settings.OPENAI_API_KEY:
-            logger.error("OPENAI_API_KEY is not set.")
-            return None
-        return OpenAI(api_key=self.settings.OPENAI_API_KEY)
+        self.client = get_llm_client()
 
     def diagnose_and_heal(self, function_name: str, lookback_minutes: int = 60) -> str:
         """
@@ -85,15 +77,23 @@ class VectorWaveHealer:
         # 5. Call LLM
         print("🤖 Generating fix via LLM...")
         try:
-            response = self.client.chat.completions.create(
+            response_text = self.client.create_chat_completion(
                 model=self.model,
                 messages=[
-                    {"role": "system", "content": "You are an expert Python debugger. Analyze the code and errors provided, then generate a fixed version of the code."},
+                    {"role": "system", "content": "You are an expert Python debugger."
+                                                  " Analyze the code and errors provided,"
+                                                  " then generate a fixed version of the code."},
                     {"role": "user", "content": prompt_context}
                 ],
-                temperature=0.1
+                temperature=0.1,
+                category="healer"
             )
-            return response.choices[0].message.content
+
+            if response_text:
+                return response_text
+            else:
+                return "❌ LLM returned no response."
+
         except Exception as e:
             logger.error(f"LLM generation failed: {e}")
             return f"❌ Error occurred during LLM call: {e}"

{vectorwave-0.2.0 → vectorwave-0.2.1}/src/vectorwave/utils/replayer_semantic.py

@@ -6,6 +6,7 @@ import math
 import asyncio
 import inspect
 from typing import Any, Dict, List, Optional
+from ..core.llm.factory import get_llm_client
 
 import weaviate.classes.query as wvc_query
 
@@ -29,13 +30,7 @@ class SemanticReplayer(VectorWaveReplayer):
 
     def __init__(self):
         super().__init__()
-        self.openai_client = self._init_openai()
-
-    def _init_openai(self) -> Optional[Any]:
-        """Initialize OpenAI client if available and configured."""
-        if OpenAI and self.settings.OPENAI_API_KEY:
-            return OpenAI(api_key=self.settings.OPENAI_API_KEY)
-        return None
+        self.openai_client = get_llm_client()
 
     def replay(self,
                function_full_name: str,
@@ -136,7 +131,7 @@ class SemanticReplayer(VectorWaveReplayer):
                             "expected": expected_output,
                             "actual": actual_output,
                             "diff_html": diff_html,  # UI visualization field
-                            "reason": match_reason   # Semantic failure reason
+                            "reason": match_reason  # Semantic failure reason
                         })
                         logger.warning(f"UUID {obj.uuid}: FAILED ({match_reason})")
 
@@ -156,7 +151,8 @@ class SemanticReplayer(VectorWaveReplayer):
                     "traceback": traceback.format_exc()
                 })
 
-        logger.info(f"Replay Finished. Passed: {results['passed']}, Failed: {results['failed']}, Updated: {results['updated']}")
+        logger.info(
+            f"Replay Finished. Passed: {results['passed']}, Failed: {results['failed']}, Updated: {results['updated']}")
         return results
 
     def _compare_results_semantic(self, expected: Any, actual: Any,
@@ -203,6 +199,7 @@ class SemanticReplayer(VectorWaveReplayer):
             norm1 = math.sqrt(sum(a * a for a in v1))
             norm2 = math.sqrt(sum(b * b for b in v2))
             return dot / (norm1 * norm2) if norm1 and norm2 else 0.0
+
         except Exception:
             return 0.0
 
@@ -220,13 +217,19 @@ class SemanticReplayer(VectorWaveReplayer):
         Respond JSON: {{"equivalent": true}} or {{"equivalent": false}}
         """
         try:
-            res = self.openai_client.chat.completions.create(
+            # Refactored to use create_chat_completion
+            response_text = self.openai_client.create_chat_completion(
                 model="gpt-4-turbo",
                 messages=[{"role": "user", "content": prompt}],
                 response_format={"type": "json_object"},
-                temperature=0.0
+                temperature=0.0,
+                category="semantic_replay"
             )
-            return json.loads(res.choices[0].message.content).get("equivalent", False)
+
+            if response_text:
+                return json.loads(response_text).get("equivalent", False)
+            return False
+
         except Exception as e:
             logger.error(f"LLM Eval failed: {e}")
-            return False
+            return False

{vectorwave-0.2.0 → vectorwave-0.2.1}/src/vectorwave/vectorizer/openai_vectorizer.py

@@ -1,5 +1,6 @@
 from .base import BaseVectorizer
 from typing import List
+from ..core.llm.factory import get_llm_client
 import logging
 
 logger = logging.getLogger(__name__)
@@ -21,16 +22,25 @@ class OpenAIVectorizer(BaseVectorizer):
         if not api_key:
             raise ValueError("OpenAI API key is required for OpenAIVectorizer.")
 
-        self.client = OpenAI(api_key=api_key)
+        self.client = get_llm_client()
         self.model = model
         logger.info("OpenAIVectorizer initialized with model '%s'.", self.model)
 
     def embed(self, text: str) -> List[float]:
         text = text.replace("\n", " ")
-        response = self.client.embeddings.create(input=[text], model=self.model)
-        return response.data[0].embedding
+        vector = self.client.create_embedding(
+            text=text,
+            model=self.model,
+            category="embedding"
+        )
+        return vector if vector else []
 
     def embed_batch(self, texts: List[str]) -> List[List[float]]:
-        texts = [t.replace("\n", " ") for t in texts]
-        response = self.client.embeddings.create(input=texts, model=self.model)
-        return [d.embedding for d in response.data]
+        embeddings = []
+        for text in texts:
+            emb = self.embed(text)
+            if emb:
+                embeddings.append(emb)
+            else:
+                embeddings.append([])
+        return embeddings

{vectorwave-0.2.0 → vectorwave-0.2.1/src/vectorwave.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectorwave
-Version: 0.2.0
+Version: 0.2.1
 Summary: VectorWave: Seamless Auto-Vectorization Framework
 Author-email: junyeonggim <junyeonggim5@gmail.com>
 License-Expression: MIT

{vectorwave-0.2.0 → vectorwave-0.2.1}/src/vectorwave.egg-info/SOURCES.txt

@@ -10,6 +10,8 @@ src/tests/batch/test_batch.py
 src/tests/core/__init__.py
 src/tests/core/test_decorator.py
 src/tests/core/test_semantic_caching.py
+src/tests/core/llm/__init__.py
+src/tests/core/llm/test_token_usage.py
 src/tests/database/__init__.py
 src/tests/database/test_archiver.py
 src/tests/database/test_db.py
@@ -43,6 +45,10 @@ src/vectorwave/core/__init__.py
 src/vectorwave/core/core.py
 src/vectorwave/core/decorator.py
 src/vectorwave/core/generator.py
+src/vectorwave/core/llm/__init__.py
+src/vectorwave/core/llm/base.py
+src/vectorwave/core/llm/factory.py
+src/vectorwave/core/llm/openai_client.py
 src/vectorwave/database/__init__.py
 src/vectorwave/database/archiver.py
 src/vectorwave/database/db.py