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

weaviate_cli-3.2.1/.github/workflows/main.yaml

@@ -0,0 +1,132 @@
+name: Main
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+jobs:
+  lint-and-format:
+    name: Run Linter and Formatter
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - run: pip install -r requirements-dev.txt
+      - name: "Black"
+        run: black --check cli.py weaviate_cli test
+      - name: "Check release for pypi"
+        run: |
+          python -m build
+          python -m twine check dist/*
+
+  unit-tests:
+    name: Run Unit Tests
+    needs: [lint-and-format]
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        version: [ "3.9", "3.10", "3.11", "3.12", "3.13" ]
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.version }}
+    - run: pip install -e .
+    - name: Run unit tests with pytest
+      run: |
+        pip install pytest-html
+        pytest test/unittests --html=test-report-${{ matrix.version }}.html --self-contained-html
+    - name: Upload test results
+      if: always()
+      uses: actions/upload-artifact@v4
+      with:
+        name: test-results-${{ matrix.version }}
+        path: test-report-${{ matrix.version }}.html
+
+  get-latest-weaviate-version:
+    runs-on: ubuntu-latest
+    needs: [unit-tests]
+    name: Get latest Weaviate version
+    outputs:
+      LATEST_WEAVIATE_VERSION: ${{ steps.latest-version.outputs.latest_weaviate_version }}
+    steps:
+      - name: Retrieve latest Weaviate version
+        id: latest-version
+        uses: weaviate/github-common-actions/.github/actions/get-latest-weaviate-version@main
+
+  integration-tests:
+    needs: [unit-tests, get-latest-weaviate-version]
+    env:
+      WEAVIATE_VERSION: ${{ needs.get-latest-weaviate-version.outputs.LATEST_WEAVIATE_VERSION }}
+      MODULES: "text2vec-transformers,text2vec-contextionary"
+    name: Run Integration Tests
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        version: [ "3.9", "3.10", "3.11", "3.12", "3.13" ]
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.version }}
+    - run: pip install -e .
+    - name: Start up Weaviate cluster
+      uses: weaviate/weaviate-local-k8s@v2
+      with:
+        workers: 1
+        replicas: 1
+        weaviate-version: ${{ env.WEAVIATE_VERSION }}
+        modules: ${{ env.MODULES }}
+        enable-backup: true
+        dynamic-users: true
+    - name: Run integration tests with pytest
+      run: |
+        pip install pytest-html
+        pytest test/integration/test_integration.py --html=test-report-${{ matrix.version }}.html --self-contained-html
+  integration-auth-tests:
+    needs: [unit-tests, get-latest-weaviate-version]
+    env:
+      WEAVIATE_VERSION: ${{ needs.get-latest-weaviate-version.outputs.LATEST_WEAVIATE_VERSION }}
+      MODULES: "text2vec-transformers,text2vec-contextionary"
+    name: Run Integration Tests Auth
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        version: [ "3.9", "3.10", "3.11", "3.12", "3.13" ]
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.version }}
+    - run: pip install -e .
+    - name: Start up Weaviate cluster
+      uses: weaviate/weaviate-local-k8s@v2
+      with:
+        workers: 1
+        replicas: 1
+        weaviate-version: ${{ env.WEAVIATE_VERSION }}
+        modules: ${{ env.MODULES }}
+        enable-backup: true
+        rbac: true
+        dynamic-users: true
+    - name: Create config directory
+      run: mkdir -p ~/.config/weaviate
+    - name: Create config file
+      run: |
+        echo '{
+          "host": "localhost",
+          "http_port": "8080",
+          "grpc_port": "50051",
+          "auth": {
+              "type": "api_key",
+              "api_key": "admin-key"
+          }
+        }' > ~/.config/weaviate/config.json
+    - name: Run integration auth tests with pytest
+      run: |
+        pip install pytest-html
+        pytest test/integration/test_auth_integration.py --html=test-auth-report-${{ matrix.version }}.html --self-contained-html

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: weaviate-cli
-Version: 3.1.4
+Version: 3.2.1
 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,13 +28,15 @@ Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: weaviate-client>=4.11.0
+Requires-Dist: weaviate-client>=4.14.3
 Requires-Dist: click==8.1.7
 Requires-Dist: semver>=3.0.2
 Requires-Dist: numpy>=1.24.0
 Requires-Dist: importlib-resources>=5.0.0
 Requires-Dist: prettytable>=3.1.0
+Requires-Dist: faker>=20.0.0
 Dynamic: download-url
+Dynamic: license-file
 
 # Weaviate CLI
 
@@ -118,6 +120,7 @@ The configuration file should be a JSON file with the following structure:
     "host": "your-weaviate-host",
     "http_port": "your-http-port",
     "grpc_port": "your-grpc-port",
+    "grpc_host": "your-grpc-host",
     "auth": {
         "type": "api_key",
         "api_key": "your-api-key"

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

@@ -80,6 +80,7 @@ The configuration file should be a JSON file with the following structure:
     "host": "your-weaviate-host",
     "http_port": "your-http-port",
     "grpc_port": "your-grpc-port",
+    "grpc_host": "your-grpc-host",
     "auth": {
         "type": "api_key",
         "api_key": "your-api-key"

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

@@ -1,4 +1,4 @@
-weaviate-client>=4.11.0
+weaviate-client>=4.14.3
 click==8.1.7
 twine
 pytest
@@ -12,3 +12,4 @@ setuptools_scm
 black==24.3.0
 pre-commit==3.6.2
 prettytable>=3.1.0
+faker>=20.0.0

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

@@ -36,12 +36,13 @@ classifiers =
 include_package_data = True
 python_requires = >=3.9
 install_requires = 
-	weaviate-client>=4.11.0
+	weaviate-client>=4.14.3
 	click==8.1.7
 	semver>=3.0.2
 	numpy>=1.24.0
 	importlib-resources>=5.0.0
 	prettytable>=3.1.0
+	faker>=20.0.0
 setup_requires = 
 	pip
 	setuptools

weaviate_cli-3.2.1/test/integration/test_auth_integration.py

@@ -0,0 +1,56 @@
+import pytest
+import weaviate
+import click
+from click.testing import CliRunner
+from weaviate_cli.managers.collection_manager import CollectionManager
+from weaviate_cli.managers.config_manager import ConfigManager
+from weaviate_cli.managers.user_manager import UserManager
+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 user_manager(client: weaviate.Client) -> UserManager:
+    return UserManager(client)
+
+
+def test_user_lifecycle(user_manager: UserManager):
+    try:
+        user_name = "test_user"
+        # Create user
+        api_key = user_manager.create_user(user_name=user_name)
+        assert user_name in [user.user_id for user in user_manager.get_all_users()]
+        assert api_key is not None
+
+        # Update user
+        new_api_key = user_manager.update_user(user_name=user_name, rotate_api_key=True)
+        assert new_api_key is not None
+        assert new_api_key != api_key
+
+        # Deactivate user
+        user_manager.update_user(user_name=user_name, deactivate=True)
+        user = user_manager.get_user(user_name=user_name)
+        assert not user.active
+
+        # Activate user
+        user_manager.update_user(user_name=user_name, activate=True)
+        user = user_manager.get_user(user_name=user_name)
+        assert user.active
+
+        # Print user
+        user_manager.print_user(user=user_name)
+
+    finally:
+        # Delete user
+        user_manager.delete_user(user_name=user_name)
+        assert user_name not in [user.user_id for user in user_manager.get_all_users()]

{weaviate_cli-3.1.4 → weaviate_cli-3.2.1}/test/integration/test_integration.py

@@ -1,6 +1,5 @@
 import pytest
 import weaviate
-import click
 from click.testing import CliRunner
 from weaviate_cli.managers.collection_manager import CollectionManager
 from weaviate_cli.managers.config_manager import ConfigManager
@@ -12,11 +11,7 @@ import weaviate.classes.config as wvc
 @pytest.fixture
 def client() -> weaviate.Client:
     config = ConfigManager()
-    return weaviate.connect_to_local(
-        host=config.config["host"],
-        port=int(config.config["http_port"]),
-        grpc_port=int(config.config["grpc_port"]),
-    )
+    return config.get_client()
 
 
 @pytest.fixture

{weaviate_cli-3.1.4 → weaviate_cli-3.2.1}/test/unittests/test_defaults.py

@@ -92,7 +92,7 @@ def test_create_tenants_defaults(runner):
     mock_collection.tenants.get.return_value = empty_tenants
 
     mock_tenants = {
-        f"{CreateTenantsDefaults.tenant_suffix}{i}": MagicMock(
+        f"{CreateTenantsDefaults.tenant_suffix}-{i}": MagicMock(
             activity_status=TenantActivityStatus.ACTIVE
         )
         for i in range(CreateTenantsDefaults.number_tenants)
@@ -134,7 +134,19 @@ def test_create_data_defaults(runner):
     # Create mock context with config
     ctx = click.Context(create_data_cli)
     ctx.obj = {"config": MagicMock()}
-    ctx.obj["config"].get_client = MagicMock()
+    mock_client = MagicMock()
+    mock_client.collections.exists.return_value = True
+
+    # Mock collection object
+    mock_collection = MagicMock()
+    mock_client.collections.get.return_value = mock_collection
+
+    # Mock multi-tenancy config
+    mock_config = MagicMock()
+    mock_config.multi_tenancy_config.enabled = False
+    mock_collection.config.get.return_value = mock_config
+
+    ctx.obj["config"].get_client.return_value = mock_client
 
     result = runner.invoke(create_data_cli, obj=ctx.obj)
     assert result.exit_code == 0, result.output
@@ -179,7 +191,7 @@ def test_delete_tenants_defaults(runner):
 
     # Mock tenants with side effect to return different values on subsequent calls
     mock_tenants = {
-        f"{DeleteTenantsDefaults.tenant_suffix}{i}": MagicMock()
+        f"{DeleteTenantsDefaults.tenant_suffix}-{i}": MagicMock()
         for i in range(1, DeleteTenantsDefaults.number_tenants + 1)
     }
     empty_tenants = {}
@@ -365,7 +377,7 @@ def test_update_tenants_defaults(runner):
 
     # Mock tenants with side effect to return different values on subsequent calls
     mock_tenants = {
-        f"{UpdateTenantsDefaults.tenant_suffix}{i}": MagicMock(
+        f"{UpdateTenantsDefaults.tenant_suffix}-{i}": MagicMock(
             activity_status=TenantActivityStatus.ACTIVE
         )
         for i in range(UpdateTenantsDefaults.number_tenants)
@@ -373,7 +385,7 @@ def test_update_tenants_defaults(runner):
     mock_collection.tenants.get.return_value = mock_tenants
 
     updated_tenants = {
-        f"{UpdateTenantsDefaults.tenant_suffix}{i}": MagicMock(
+        f"{UpdateTenantsDefaults.tenant_suffix}-{i}": MagicMock(
             activity_status=TenantActivityStatus.ACTIVE
         )
         for i in range(UpdateTenantsDefaults.number_tenants)

{weaviate_cli-3.1.4 → weaviate_cli-3.2.1}/test/unittests/test_managers/test_collection_manager.py

@@ -146,6 +146,7 @@ def test_update_collection(mock_client):
         description="Updated description",
         vector_index="hnsw",
         async_enabled=True,
+        replication_factor=5,
         auto_tenant_creation=True,
         auto_tenant_activation=True,
         replication_deletion_strategy="delete_on_conflict",
@@ -157,7 +158,7 @@ def test_update_collection(mock_client):
         == "Updated description"
     )
     assert (
-        mock_collection.config.update.call_args.kwargs["replication_config"].factor == 3
+        mock_collection.config.update.call_args.kwargs["replication_config"].factor == 5
     )
     assert (
         mock_collection.config.update.call_args.kwargs[

weaviate_cli-3.2.1/test/unittests/test_managers/test_config_manager.py

@@ -0,0 +1,264 @@
+import socket
+import pytest
+import weaviate
+from unittest.mock import MagicMock, mock_open, patch
+from weaviate_cli.managers.config_manager import ConfigManager
+import json
+
+
+def test_init_with_config_file():
+    config_data = {"host": "localhost", "http_port": "8080", "grpc_port": "50051"}
+
+    with patch("builtins.open", mock_open(read_data=json.dumps(config_data))):
+        with patch("os.path.isfile") as mock_isfile:
+            mock_isfile.return_value = True
+            config = ConfigManager(config_file="test_config.json")
+            assert config.config == config_data
+
+
+def test_create_default_config():
+    with patch("pathlib.Path.exists") as mock_exists:
+        mock_exists.return_value = False
+        config = ConfigManager()
+        assert config.config["host"] == "localhost"
+        assert config.config["http_port"] == "8080"
+        assert config.config["grpc_port"] == "50051"
+
+
+@patch("socket.create_connection")
+def test_check_host_docker_internal(mock_socket):
+    config = ConfigManager()
+
+    # Test successful connection
+    mock_socket.return_value = MagicMock()
+    assert config._ConfigManager__check_host_docker_internal() == True
+
+
+@patch("socket.create_connection")
+def test_check_host_docker_internal_failed(mock_socket):
+    config = ConfigManager()
+
+    # Test failed connection
+    mock_socket.side_effect = socket.error()
+    assert config._ConfigManager__check_host_docker_internal() == False
+
+
+def test_init_with_user():
+    config_data = {
+        "host": "localhost",
+        "http_port": "8080",
+        "grpc_port": "50051",
+        "auth": {"type": "user", "admin": "admin-key", "jose": "jose-key"},
+    }
+
+    with patch("builtins.open", mock_open(read_data=json.dumps(config_data))):
+        with patch("os.path.isfile") as mock_isfile:
+            mock_isfile.return_value = True
+            config = ConfigManager(config_file="test_config.json", user="jose")
+            assert config.user == "jose"
+            assert config.config == config_data
+
+
+def test_get_client_with_user_auth():
+    config_data = {
+        "host": "localhost",
+        "http_port": "8080",
+        "grpc_port": "50051",
+        "auth": {"type": "user", "admin": "admin-key", "jose": "jose-key"},
+    }
+
+    with patch("builtins.open", mock_open(read_data=json.dumps(config_data))):
+        with patch("os.path.isfile") as mock_isfile:
+            mock_isfile.return_value = True
+            with patch("weaviate.connect_to_local") as mock_connect:
+                config = ConfigManager(config_file="test_config.json", user="jose")
+                config.get_client()
+
+                mock_connect.assert_called_once()
+                call_kwargs = mock_connect.call_args.kwargs
+                assert isinstance(
+                    call_kwargs["auth_credentials"], weaviate.auth.AuthApiKey
+                )
+                assert call_kwargs["auth_credentials"].api_key == "jose-key"
+
+
+def test_get_client_with_invalid_user():
+    config_data = {
+        "host": "localhost",
+        "http_port": "8080",
+        "grpc_port": "50051",
+        "auth": {"type": "user", "admin": "admin-key"},
+    }
+
+    with patch("builtins.open", mock_open(read_data=json.dumps(config_data))):
+        with patch("os.path.isfile") as mock_isfile:
+            mock_isfile.return_value = True
+            config = ConfigManager(config_file="test_config.json", user="jose")
+            with pytest.raises(Exception) as exc_info:
+                config.get_client()
+            assert str(exc_info.value) == "User 'jose' not found in config file"
+
+
+def test_get_client_missing_user():
+    config_data = {
+        "host": "localhost",
+        "http_port": "8080",
+        "grpc_port": "50051",
+        "auth": {"type": "user", "admin": "admin-key"},
+    }
+
+    with patch("builtins.open", mock_open(read_data=json.dumps(config_data))):
+        with patch("os.path.isfile") as mock_isfile:
+            mock_isfile.return_value = True
+            config = ConfigManager(config_file="test_config.json")
+            with pytest.raises(Exception) as exc_info:
+                config.get_client()
+            assert (
+                str(exc_info.value) == "User must be specified when auth type is 'user'"
+            )
+
+
+def test_get_client_with_api_key_auth():
+    config_data = {
+        "host": "localhost",
+        "http_port": "8080",
+        "grpc_port": "50051",
+        "auth": {"type": "api_key", "api_key": "test-key"},
+    }
+
+    with patch("builtins.open", mock_open(read_data=json.dumps(config_data))):
+        with patch("os.path.isfile") as mock_isfile:
+            mock_isfile.return_value = True
+            with patch("weaviate.connect_to_local") as mock_connect:
+                config = ConfigManager(config_file="test_config.json")
+                config.get_client()
+
+                mock_connect.assert_called_once()
+                call_kwargs = mock_connect.call_args.kwargs
+                assert isinstance(
+                    call_kwargs["auth_credentials"], weaviate.auth.AuthApiKey
+                )
+                assert call_kwargs["auth_credentials"].api_key == "test-key"
+
+
+def test_get_client_with_ip_address():
+    config_data = {
+        "host": "127.0.0.1",
+        "grpc_host": "127.0.0.1",
+        "http_port": 8080,
+        "grpc_port": 50051,
+    }
+
+    with patch("builtins.open", mock_open(read_data=json.dumps(config_data))):
+        with patch("os.path.isfile") as mock_isfile:
+            mock_isfile.return_value = True
+            with patch("weaviate.connect_to_custom") as mock_connect:
+                config = ConfigManager(config_file="test_config.json")
+                config.get_client()
+
+                mock_connect.assert_called_once()
+                call_kwargs = mock_connect.call_args.kwargs
+                assert call_kwargs["http_host"] == "127.0.0.1"
+                assert call_kwargs["grpc_host"] == "127.0.0.1"
+                assert call_kwargs["http_port"] == 8080
+                assert call_kwargs["grpc_port"] == 50051
+                assert call_kwargs["http_secure"] == False
+                assert call_kwargs["grpc_secure"] == False
+
+
+def test_get_client_with_ip_address_and_secure_ports():
+    config_data = {
+        "host": "127.0.0.1",
+        "grpc_host": "127.0.0.1",
+        "http_port": 443,
+        "grpc_port": 443,
+    }
+
+    with patch("builtins.open", mock_open(read_data=json.dumps(config_data))):
+        with patch("os.path.isfile") as mock_isfile:
+            mock_isfile.return_value = True
+            with patch("weaviate.connect_to_custom") as mock_connect:
+                config = ConfigManager(config_file="test_config.json")
+                config.get_client()
+
+                mock_connect.assert_called_once()
+                call_kwargs = mock_connect.call_args.kwargs
+                assert call_kwargs["http_host"] == "127.0.0.1"
+                assert call_kwargs["grpc_host"] == "127.0.0.1"
+                assert call_kwargs["http_port"] == 443
+                assert call_kwargs["grpc_port"] == 443
+                assert call_kwargs["http_secure"] == True
+                assert call_kwargs["grpc_secure"] == True
+
+
+def test_get_client_with_ip_address_with_https():
+    config_data = {
+        "host": "https://85.10.20.30",
+        "grpc_host": "https://85.10.20.31",
+        "http_port": 443,
+        "grpc_port": 443,
+    }
+
+    with patch("builtins.open", mock_open(read_data=json.dumps(config_data))):
+        with patch("os.path.isfile") as mock_isfile:
+            mock_isfile.return_value = True
+            with patch("weaviate.connect_to_custom") as mock_connect:
+                config = ConfigManager(config_file="test_config.json")
+                config.get_client()
+
+                mock_connect.assert_called_once()
+                call_kwargs = mock_connect.call_args.kwargs
+                assert call_kwargs["http_host"] == "85.10.20.30"
+                assert call_kwargs["grpc_host"] == "85.10.20.31"
+                assert call_kwargs["http_port"] == 443
+                assert call_kwargs["grpc_port"] == 443
+                assert call_kwargs["http_secure"] == True
+                assert call_kwargs["grpc_secure"] == True
+
+
+def test_get_client_with_host_and_custom():
+    config_data = {
+        "host": "https://weaviate.google.my-cloud.com",
+        "grpc_host": "https://grpc.weaviate.google.my-cloud.com",
+    }
+
+    with patch("builtins.open", mock_open(read_data=json.dumps(config_data))):
+        with patch("os.path.isfile") as mock_isfile:
+            mock_isfile.return_value = True
+            with patch("weaviate.connect_to_custom") as mock_connect:
+                config = ConfigManager(config_file="test_config.json")
+                config.get_client()
+
+                mock_connect.assert_called_once()
+                call_kwargs = mock_connect.call_args.kwargs
+                assert call_kwargs["http_host"] == "weaviate.google.my-cloud.com"
+                assert call_kwargs["grpc_host"] == "grpc.weaviate.google.my-cloud.com"
+                assert call_kwargs["http_port"] == 443
+                assert call_kwargs["grpc_port"] == 443
+                assert call_kwargs["http_secure"] == True
+                assert call_kwargs["grpc_secure"] == True
+
+
+def test_get_client_with_host_and_custom_with_ports():
+    config_data = {
+        "host": "https://weaviate.google.my-cloud.com",
+        "grpc_host": "https://grpc.weaviate.google.my-cloud.com",
+        "http_port": 8080,
+        "grpc_port": 8080,
+    }
+
+    with patch("builtins.open", mock_open(read_data=json.dumps(config_data))):
+        with patch("os.path.isfile") as mock_isfile:
+            mock_isfile.return_value = True
+            with patch("weaviate.connect_to_custom") as mock_connect:
+                config = ConfigManager(config_file="test_config.json")
+                config.get_client()
+
+                mock_connect.assert_called_once()
+                call_kwargs = mock_connect.call_args.kwargs
+                assert call_kwargs["http_host"] == "weaviate.google.my-cloud.com"
+                assert call_kwargs["grpc_host"] == "grpc.weaviate.google.my-cloud.com"
+                assert call_kwargs["http_port"] == 8080
+                assert call_kwargs["grpc_port"] == 8080
+                assert call_kwargs["http_secure"] == True  # URL contains https
+                assert call_kwargs["grpc_secure"] == True  # URL contains https

{weaviate_cli-3.1.4 → weaviate_cli-3.2.1}/test/unittests/test_managers/test_data_manager.py

@@ -22,6 +22,7 @@ def test_ingest_data(mock_client):
         collection="TestCollection",
         limit=100,
         randomize=True,
+        auto_tenants=10,
     )
 
     mock_client.collections.get.assert_called_once_with("TestCollection")