weaviate-cli 3.2.1__tar.gz → 3.2.3__tar.gz

{weaviate_cli-3.2.1 → weaviate_cli-3.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weaviate-cli
-Version: 3.2.1
+Version: 3.2.3
 Summary: Command line interface to interact with weaviate
 Home-page: https://github.com/weaviate/weaviate-cli
 Download-URL: https://github.com/weaviate/weaviate-cli
@@ -28,7 +28,7 @@ Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: weaviate-client>=4.14.3
+Requires-Dist: weaviate-client>=4.16.0
 Requires-Dist: click==8.1.7
 Requires-Dist: semver>=3.0.2
 Requires-Dist: numpy>=1.24.0
@@ -86,10 +86,10 @@ weaviate-cli query data --collection movies --search-type hybrid --query "action
 
 ## Core Commands
 
-- **create**: Create collections, tenants, backups or import data
-- **delete**: Remove collections, tenants or data
+- **create**: Create collections, tenants, backups, replications or import data
+- **delete**: Remove collections, tenants, replications or data
 - **update**: Modify collection settings, tenant states or data
-- **get**: Retrieve collection info, tenant details or shard status
+- **get**: Retrieve collection info, tenant details, replication operations or shard status
 - **query**: Search data using various methods
 - **restore**: Restore backups from supported backends
 - **assign**: Assign roles and permissions to users

{weaviate_cli-3.2.1 → weaviate_cli-3.2.3}/README.md

@@ -46,10 +46,10 @@ weaviate-cli query data --collection movies --search-type hybrid --query "action
 
 ## Core Commands
 
-- **create**: Create collections, tenants, backups or import data
-- **delete**: Remove collections, tenants or data
+- **create**: Create collections, tenants, backups, replications or import data
+- **delete**: Remove collections, tenants, replications or data
 - **update**: Modify collection settings, tenant states or data
-- **get**: Retrieve collection info, tenant details or shard status
+- **get**: Retrieve collection info, tenant details, replication operations or shard status
 - **query**: Search data using various methods
 - **restore**: Restore backups from supported backends
 - **assign**: Assign roles and permissions to users

{weaviate_cli-3.2.1 → weaviate_cli-3.2.3}/cli.py

@@ -1,3 +1,17 @@
+import warnings
+
+warnings.filterwarnings(
+    "ignore", message="pkg_resources is deprecated as an API.", category=UserWarning
+)
+warnings.filterwarnings(
+    "ignore",
+    message=(
+        r"Protobuf gencode version [\d\.]+ is exactly one major version older than the runtime version [\d\.]+ at v1/tenants\.proto\. "
+        r"Please update the gencode to avoid compatibility violations in the next runtime release\."
+    ),
+    category=UserWarning,
+)
+
 from typing import Optional
 import click
 import sys

{weaviate_cli-3.2.1 → weaviate_cli-3.2.3}/requirements-dev.txt

@@ -1,4 +1,4 @@
-weaviate-client>=4.14.3
+weaviate-client>=4.16.0
 click==8.1.7
 twine
 pytest

{weaviate_cli-3.2.1 → weaviate_cli-3.2.3}/setup.cfg

@@ -36,7 +36,7 @@ classifiers =
 include_package_data = True
 python_requires = >=3.9
 install_requires = 
-	weaviate-client>=4.14.3
+	weaviate-client>=4.16.0
 	click==8.1.7
 	semver>=3.0.2
 	numpy>=1.24.0

weaviate_cli-3.2.3/test/integration/test_data_integration.py

@@ -0,0 +1,391 @@
+import pytest
+import weaviate
+import numpy as np
+from weaviate_cli.managers.collection_manager import CollectionManager
+from weaviate_cli.managers.config_manager import ConfigManager
+from weaviate_cli.managers.data_manager import DataManager
+import weaviate.classes.config as wvc
+
+
+@pytest.fixture
+def client() -> weaviate.Client:
+    config = ConfigManager()
+    return config.get_client()
+
+
+@pytest.fixture
+def collection_manager(client: weaviate.Client) -> CollectionManager:
+    return CollectionManager(client)
+
+
+@pytest.fixture
+def data_manager(client: weaviate.Client) -> DataManager:
+    return DataManager(client)
+
+
+@pytest.mark.parametrize("randomize", [False, True])
+@pytest.mark.parametrize("vectorizer", ["transformers", "contextionary"])
+def test_data_creation_with_different_configs(
+    collection_manager: CollectionManager,
+    data_manager: DataManager,
+    randomize: bool,
+    vectorizer: str,
+):
+    """Test data creation with different randomize and vectorizer configurations."""
+    collection_name = f"TestData{randomize}{vectorizer.capitalize()[:7]}"
+    # Contextionary does not know the word "contextionary", therefore we truncate it to "context" [0:7]
+
+    try:
+        # Create collection with specified vectorizer
+        collection_manager.create_collection(
+            collection=collection_name,
+            vectorizer=vectorizer,
+            replication_factor=1,
+            training_limit=1000,
+            async_enabled=True,
+        )
+
+        # Verify collection exists
+        assert collection_manager.client.collections.exists(collection_name)
+
+        # Create data with specified randomize setting
+        data_manager.create_data(
+            collection=collection_name,
+            limit=50,
+            consistency_level="one",
+            randomize=randomize,
+            skip_seed=True,
+        )
+
+        # Get the collection and verify data was created
+        collection = collection_manager.client.collections.get(collection_name)
+
+        # Wait for indexing to complete
+        collection.batch.wait_for_vector_indexing()
+
+        # Query objects to verify they have content and vectors
+        objects = collection.query.fetch_objects(limit=50, include_vector=True)
+
+        # Verify we got the expected number of objects
+        assert len(objects.objects) == 50
+
+        # Verify each object has content and vectors
+        for obj in objects.objects:
+            # Check that object has properties
+            assert hasattr(obj, "properties")
+            assert obj.properties is not None
+
+            # Check that object has a title (required field)
+            assert "title" in obj.properties
+            assert obj.properties["title"] is not None
+            assert len(obj.properties["title"]) > 0
+
+            # Check that object has genres
+            assert "genres" in obj.properties
+            assert obj.properties["genres"] is not None
+
+            # Check that object has keywords
+            assert "keywords" in obj.properties
+            assert obj.properties["keywords"] is not None
+
+            # Verify vector was created
+            assert hasattr(obj, "vector")
+            assert obj.vector is not None
+
+            vector_dimensions = {
+                "transformers": 384,
+                "contextionary": 300,
+            }
+
+            # Check vector dimensions (should be 1536 for default)
+            assert len(obj.vector["default"]) == vector_dimensions[vectorizer]
+
+            # Verify vector is not all zeros (should have meaningful values)
+            assert not np.allclose(
+                obj.vector["default"], np.zeros(vector_dimensions[vectorizer])
+            )
+
+            # Verify vector has finite values
+            assert np.all(np.isfinite(obj.vector["default"]))
+
+    finally:
+        # Clean up
+        if collection_manager.client.collections.exists(collection_name):
+            collection_manager.delete_collection(collection=collection_name)
+
+
+@pytest.mark.parametrize("vectorizer", ["transformers", "none"])
+@pytest.mark.parametrize(
+    "named_vector_name", ["custom_vector", "movie_embedding", "content_vector"]
+)
+def test_data_creation_with_named_vectors(
+    collection_manager: CollectionManager,
+    data_manager: DataManager,
+    named_vector_name: str,
+    vectorizer: str,
+):
+    """Test data creation with named vectors and verify the correct vector name is set."""
+    collection_name = f"TestNamedVector{named_vector_name}{vectorizer.capitalize()}"
+
+    try:
+        # Create collection with named vector
+        collection_manager.create_collection(
+            collection=collection_name,
+            vectorizer=vectorizer,
+            replication_factor=1,
+            training_limit=1000,
+            async_enabled=True,
+            named_vector=True,
+            named_vector_name=named_vector_name,
+        )
+
+        # Verify collection exists
+        assert collection_manager.client.collections.exists(collection_name)
+
+        # Create data
+        data_manager.create_data(
+            collection=collection_name,
+            limit=30,
+            consistency_level="one",
+            vector_dimensions=384 if vectorizer == "none" else None,
+            randomize=True,
+            skip_seed=True,
+        )
+
+        # Get the collection and verify data was created
+        collection = collection_manager.client.collections.get(collection_name)
+
+        # Wait for indexing to complete
+        collection.batch.wait_for_vector_indexing()
+
+        # Query objects to verify they have content and named vectors
+        objects = collection.query.fetch_objects(limit=30, include_vector=True)
+
+        # Verify we got the expected number of objects
+        assert len(objects.objects) == 30
+
+        # Verify each object has content and the correct named vector
+        for obj in objects.objects:
+            # Check that object has properties
+            assert hasattr(obj, "properties")
+            assert obj.properties is not None
+
+            # Check that object has a title
+            assert "title" in obj.properties
+            assert obj.properties["title"] is not None
+
+            # Check that object has genres
+            assert "genres" in obj.properties
+            assert obj.properties["genres"] is not None
+
+            # Check that object has keywords
+            assert "keywords" in obj.properties
+            assert obj.properties["keywords"] is not None
+
+            # Verify named vector was created with correct name
+            assert hasattr(obj, "vector")
+            assert obj.vector is not None
+
+            # Check that the named vector exists
+            assert named_vector_name in obj.vector
+
+            # Get the named vector
+            named_vector = obj.vector[named_vector_name]
+            assert named_vector is not None
+
+            # Check vector dimensions (should be 768 for transformers)
+            assert len(named_vector) == 384
+
+            # Verify vector is not all zeros
+            assert not np.allclose(named_vector, np.zeros(384))
+
+            # Verify vector has finite values
+            assert np.all(np.isfinite(named_vector))
+
+    finally:
+        # Clean up
+        if collection_manager.client.collections.exists(collection_name):
+            collection_manager.delete_collection(collection=collection_name)
+
+
+def test_data_creation_with_multi_vector(
+    collection_manager: CollectionManager,
+    data_manager: DataManager,
+):
+    """Test data creation with multi-vector enabled."""
+    collection_name = "TestMultiVector"
+
+    try:
+        # Create collection
+        collection_manager.create_collection(
+            collection=collection_name,
+            vectorizer="none",
+            replication_factor=1,
+            training_limit=1000,
+            async_enabled=True,
+            vector_index="hnsw_multivector",
+            named_vector=True,
+        )
+
+        # Verify collection exists
+        assert collection_manager.client.collections.exists(collection_name)
+
+        # Create data with multi-vector enabled
+        data_manager.create_data(
+            collection=collection_name,
+            limit=25,
+            consistency_level="one",
+            randomize=True,
+            skip_seed=True,
+            multi_vector=True,
+            vector_dimensions=1536,
+        )
+
+        # Get the collection and verify data was created
+        collection = collection_manager.client.collections.get(collection_name)
+
+        # Wait for indexing to complete
+        collection.batch.wait_for_vector_indexing()
+
+        # Query objects to verify they have content and vectors
+        objects = collection.query.fetch_objects(limit=25, include_vector=True)
+
+        # Verify we got the expected number of objects
+        assert len(objects.objects) == 25
+
+        # Verify each object has content and vectors
+        for obj in objects.objects:
+            # Check that object has properties
+            assert hasattr(obj, "properties")
+            assert obj.properties is not None
+
+            # Check that object has a title
+            assert "title" in obj.properties
+            assert obj.properties["title"] is not None
+
+            # Check that object has genres
+            assert "genres" in obj.properties
+            assert obj.properties["genres"] is not None
+
+            # Check that object has keywords
+            assert "keywords" in obj.properties
+            assert obj.properties["keywords"] is not None
+
+            # Verify vector was created
+            assert hasattr(obj, "vector")
+            assert obj.vector is not None
+
+            # Check vector dimensions
+            for vector in obj.vector["default"]:
+                assert len(vector) == 1536
+
+            # Verify vector is not all zeros
+            for vector in obj.vector["default"]:
+                assert not np.allclose(vector, np.zeros(1536))
+
+            # Verify vector has finite values
+            for vector in obj.vector["default"]:
+                assert np.all(np.isfinite(vector))
+
+    finally:
+        # Clean up
+        if collection_manager.client.collections.exists(collection_name):
+            collection_manager.delete_collection(collection=collection_name)
+
+
+def test_data_creation_with_custom_vector_dimensions(
+    collection_manager: CollectionManager,
+    data_manager: DataManager,
+):
+    """Test data creation with custom vector dimensions."""
+    collection_name = "TestCustomDimensions"
+    custom_dimensions = 768  # Different from default 1536
+
+    try:
+        # Create collection
+        collection_manager.create_collection(
+            collection=collection_name,
+            vectorizer="none",
+            replication_factor=1,
+            training_limit=1000,
+            async_enabled=True,
+        )
+
+        # Verify collection exists
+        assert collection_manager.client.collections.exists(collection_name)
+
+        # Create data with custom vector dimensions
+        data_manager.create_data(
+            collection=collection_name,
+            limit=20,
+            consistency_level="one",
+            randomize=True,
+            skip_seed=True,
+            vector_dimensions=custom_dimensions,
+        )
+
+        # Get the collection and verify data was created
+        collection = collection_manager.client.collections.get(collection_name)
+
+        # Wait for indexing to complete
+        collection.batch.wait_for_vector_indexing()
+
+        # Query objects to verify they have content and vectors with custom dimensions
+        objects = collection.query.fetch_objects(limit=20, include_vector=True)
+
+        # Verify we got the expected number of objects
+        assert len(objects.objects) == 20
+
+        # Verify each object has content and vectors with correct dimensions
+        for obj in objects.objects:
+            # Check that object has properties
+            assert hasattr(obj, "properties")
+            assert obj.properties is not None
+
+            # Check that object has a title
+            assert "title" in obj.properties
+            assert obj.properties["title"] is not None
+
+            # Check that object has genres
+            assert "genres" in obj.properties
+            assert obj.properties["genres"] is not None
+
+            # Check that object has keywords
+            assert "keywords" in obj.properties
+            assert obj.properties["keywords"] is not None
+
+            # Verify vector was created with custom dimensions
+            assert hasattr(obj, "vector")
+            assert obj.vector is not None
+
+            # Check vector dimensions (should be custom_dimensions)
+            assert len(obj.vector["default"]) == custom_dimensions
+
+            # Verify vector is not all zeros
+            assert not np.allclose(obj.vector["default"], np.zeros(custom_dimensions))
+
+            # Verify vector has finite values
+            assert np.all(np.isfinite(obj.vector["default"]))
+
+    finally:
+        # Clean up
+        if collection_manager.client.collections.exists(collection_name):
+            collection_manager.delete_collection(collection=collection_name)
+
+
+def test_data_creation_error_handling(
+    collection_manager: CollectionManager,
+    data_manager: DataManager,
+):
+    """Test error handling when creating data in non-existent collection."""
+
+    # Try to create data in non-existent collection
+    with pytest.raises(Exception) as exc_info:
+        data_manager.create_data(
+            collection="NonExistentCollection",
+            limit=10,
+            consistency_level="one",
+        )
+
+    # Verify error message
+    assert "does not exist in Weaviate" in str(exc_info.value)

weaviate_cli-3.2.3/test/unittests/test_managers/test_alias_manager.py

@@ -0,0 +1,209 @@
+import pytest
+from unittest.mock import MagicMock
+from weaviate.aliases.alias import AliasReturn
+
+from weaviate_cli.managers.alias_manager import AliasManager
+
+
+@pytest.fixture
+def alias_manager(mock_client: MagicMock) -> AliasManager:
+    """
+    Returns an AliasManager instance with a mocked WeaviateClient.
+    """
+    mock_client.alias = MagicMock()
+    return AliasManager(mock_client)
+
+
+def test_create_alias_success(
+    alias_manager: AliasManager, mock_client: MagicMock
+) -> None:
+    """
+    Test successful alias creation.
+    """
+    alias_name = "test_alias"
+    collection_name = "TestCollection"
+
+    alias_manager.create_alias(alias_name, collection_name)
+
+    mock_client.alias.create.assert_called_once_with(
+        alias_name=alias_name, target_collection=collection_name
+    )
+
+
+def test_create_alias_error(
+    alias_manager: AliasManager, mock_client: MagicMock
+) -> None:
+    """
+    Test alias creation with an exception.
+    """
+    alias_name = "test_alias"
+    collection_name = "TestCollection"
+    error_message = "Failed to create"
+    mock_client.alias.create.side_effect = Exception(error_message)
+
+    with pytest.raises(Exception) as exc_info:
+        alias_manager.create_alias(alias_name, collection_name)
+
+    assert f"Error creating alias '{alias_name}': {error_message}" in str(
+        exc_info.value
+    )
+
+
+def test_update_alias_success(
+    alias_manager: AliasManager, mock_client: MagicMock
+) -> None:
+    """
+    Test successful alias update.
+    """
+    alias_name = "test_alias"
+    collection_name = "NewTestCollection"
+
+    alias_manager.update_alias(alias_name, collection_name)
+
+    mock_client.alias.update.assert_called_once_with(
+        alias_name=alias_name, new_target_collection=collection_name
+    )
+
+
+def test_update_alias_error(
+    alias_manager: AliasManager, mock_client: MagicMock
+) -> None:
+    """
+    Test alias update with an exception.
+    """
+    alias_name = "test_alias"
+    collection_name = "NewTestCollection"
+    error_message = "Failed to update"
+    mock_client.alias.update.side_effect = Exception(error_message)
+
+    with pytest.raises(Exception) as exc_info:
+        alias_manager.update_alias(alias_name, collection_name)
+
+    assert f"Error updating alias '{alias_name}': {error_message}" in str(
+        exc_info.value
+    )
+
+
+def test_get_alias_success(alias_manager: AliasManager, mock_client: MagicMock) -> None:
+    """
+    Test successful alias retrieval.
+    """
+    alias_name = "test_alias"
+    expected_alias = AliasReturn(alias=alias_name, collection="SomeCollection")
+    mock_client.alias.get.return_value = expected_alias
+
+    result = alias_manager.get_alias(alias_name)
+
+    assert result == expected_alias
+    mock_client.alias.get.assert_called_once_with(alias_name=alias_name)
+
+
+def test_get_alias_error(alias_manager: AliasManager, mock_client: MagicMock) -> None:
+    """
+    Test alias retrieval with an exception.
+    """
+    alias_name = "test_alias"
+    error_message = "Failed to get"
+    mock_client.alias.get.side_effect = Exception(error_message)
+
+    with pytest.raises(Exception) as exc_info:
+        alias_manager.get_alias(alias_name)
+
+    assert f"Error getting alias '{alias_name}': {error_message}" in str(exc_info.value)
+
+
+def test_delete_alias_success(
+    alias_manager: AliasManager, mock_client: MagicMock
+) -> None:
+    """
+    Test successful alias deletion.
+    """
+    alias_name = "test_alias"
+
+    alias_manager.delete_alias(alias_name)
+
+    mock_client.alias.delete.assert_called_once_with(alias_name=alias_name)
+
+
+def test_delete_alias_error(
+    alias_manager: AliasManager, mock_client: MagicMock
+) -> None:
+    """
+    Test alias deletion with an exception.
+    """
+    alias_name = "test_alias"
+    error_message = "Failed to delete"
+    mock_client.alias.delete.side_effect = Exception(error_message)
+
+    with pytest.raises(Exception) as exc_info:
+        alias_manager.delete_alias(alias_name)
+
+    assert f"Error deleting alias '{alias_name}': {error_message}" in str(
+        exc_info.value
+    )
+
+
+def test_list_aliases_all_success(
+    alias_manager: AliasManager, mock_client: MagicMock
+) -> None:
+    """
+    Test successful listing of all aliases.
+    """
+    expected_aliases = {
+        "alias1": AliasReturn(alias="alias1", collection="collection1"),
+        "alias2": AliasReturn(alias="alias2", collection="collection2"),
+    }
+    mock_client.alias.list_all.return_value = expected_aliases
+
+    result = alias_manager.list_aliases()
+
+    assert result == expected_aliases
+    mock_client.alias.list_all.assert_called_once_with(collection=None)
+
+
+def test_list_aliases_for_collection_success(
+    alias_manager: AliasManager, mock_client: MagicMock
+) -> None:
+    """
+    Test successful listing of aliases for a specific collection.
+    """
+    collection_name = "TestCollection"
+    expected_aliases = {
+        "alias1": AliasReturn(alias="alias1", collection="TestCollection"),
+        "alias2": AliasReturn(alias="alias2", collection="TestCollection"),
+    }
+    mock_client.alias.list_all.return_value = expected_aliases
+
+    result = alias_manager.list_aliases(collection=collection_name)
+
+    assert result == expected_aliases
+    mock_client.alias.list_all.assert_called_once_with(collection=collection_name)
+
+
+def test_list_aliases_error(
+    alias_manager: AliasManager, mock_client: MagicMock
+) -> None:
+    """
+    Test listing aliases with an exception.
+    """
+    error_message = "Failed to list"
+    mock_client.alias.list_all.side_effect = Exception(error_message)
+
+    with pytest.raises(Exception) as exc_info:
+        alias_manager.list_aliases()
+
+    assert f"Error listing aliases: {error_message}" in str(exc_info.value)
+
+
+def test_print_alias(alias_manager: AliasManager, capsys) -> None:
+    """
+    Test the output of the print_alias method.
+    """
+    alias_name = "my_alias"
+    collection_name = "MyCollection"
+    alias = AliasReturn(alias=alias_name, collection=collection_name)
+
+    alias_manager.print_alias(alias)
+
+    captured = capsys.readouterr()
+    assert captured.out == f"Alias: {alias_name} -> {collection_name}\n"