fleet-python 0.2.66b2__py3-none-any.whl → 0.2.105__py3-none-any.whl

tests/test_sqlite_resource_dual_mode.py

@@ -0,0 +1,263 @@
+"""Unit tests for SQLiteResource dual-mode functionality."""
+
+import pytest
+import tempfile
+import sqlite3
+import os
+from fleet.resources.sqlite import SQLiteResource
+from fleet.instance.models import (
+    Resource as ResourceModel,
+    ResourceType,
+    ResourceMode,
+    QueryResponse,
+    DescribeResponse,
+)
+
+
+class TestSQLiteResourceDirectMode:
+    """Test SQLiteResource in direct (local file) mode."""
+
+    @pytest.fixture
+    def temp_db(self):
+        """Create a temporary SQLite database for testing."""
+        fd, path = tempfile.mkstemp(suffix=".db")
+        os.close(fd)
+
+        # Initialize with test data
+        conn = sqlite3.connect(path)
+        cursor = conn.cursor()
+        cursor.execute("""
+            CREATE TABLE users (
+                id INTEGER PRIMARY KEY,
+                name TEXT NOT NULL,
+                email TEXT,
+                age INTEGER
+            )
+        """)
+        cursor.execute(
+            "INSERT INTO users (id, name, email, age) VALUES (?, ?, ?, ?)",
+            (1, "Alice", "alice@example.com", 30),
+        )
+        cursor.execute(
+            "INSERT INTO users (id, name, email, age) VALUES (?, ?, ?, ?)",
+            (2, "Bob", "bob@example.com", 25),
+        )
+        conn.commit()
+        conn.close()
+
+        yield path
+
+        # Cleanup
+        if os.path.exists(path):
+            os.remove(path)
+
+    @pytest.fixture
+    def resource(self, temp_db):
+        """Create a SQLiteResource in direct mode."""
+        resource_model = ResourceModel(
+            name="test_db",
+            type=ResourceType.db,
+            mode=ResourceMode.rw,
+        )
+        return SQLiteResource(resource_model, client=None, db_path=temp_db)
+
+    def test_mode_property(self, resource):
+        """Test that mode property returns 'direct'."""
+        assert resource.mode == "direct"
+
+    def test_query_select(self, resource):
+        """Test SELECT query in direct mode."""
+        response = resource.query("SELECT * FROM users ORDER BY id")
+
+        assert response.success is True
+        assert response.columns == ["id", "name", "email", "age"]
+        assert len(response.rows) == 2
+        # Rows can be either tuples or lists depending on the implementation
+        assert list(response.rows[0]) == [1, "Alice", "alice@example.com", 30]
+        assert list(response.rows[1]) == [2, "Bob", "bob@example.com", 25]
+
+    def test_query_with_params(self, resource):
+        """Test query with parameters."""
+        response = resource.query("SELECT * FROM users WHERE id = ?", [1])
+
+        assert response.success is True
+        assert len(response.rows) == 1
+        assert response.rows[0][1] == "Alice"
+
+    def test_exec_insert(self, resource):
+        """Test INSERT operation in direct mode."""
+        response = resource.exec(
+            "INSERT INTO users (id, name, email, age) VALUES (?, ?, ?, ?)",
+            [3, "Charlie", "charlie@example.com", 35],
+        )
+
+        assert response.success is True
+        assert response.rows_affected == 1
+        assert response.last_insert_id == 3
+
+        # Verify the insert
+        check = resource.query("SELECT * FROM users WHERE id = 3")
+        assert len(check.rows) == 1
+        assert check.rows[0][1] == "Charlie"
+
+    def test_exec_update(self, resource):
+        """Test UPDATE operation in direct mode."""
+        response = resource.exec("UPDATE users SET age = ? WHERE id = ?", [31, 1])
+
+        assert response.success is True
+        assert response.rows_affected == 1
+
+        # Verify the update
+        check = resource.query("SELECT age FROM users WHERE id = 1")
+        assert check.rows[0][0] == 31
+
+    def test_exec_delete(self, resource):
+        """Test DELETE operation in direct mode."""
+        response = resource.exec("DELETE FROM users WHERE id = ?", [2])
+
+        assert response.success is True
+        assert response.rows_affected == 1
+
+        # Verify the delete
+        check = resource.query("SELECT * FROM users")
+        assert len(check.rows) == 1
+
+    def test_describe(self, resource):
+        """Test describe() in direct mode."""
+        response = resource.describe()
+
+        assert response.success is True
+        assert response.resource_name == "test_db"
+        assert len(response.tables) == 1
+
+        table = response.tables[0]
+        assert table.name == "users"
+        assert table.sql is not None
+        assert len(table.columns) == 4
+
+        # Check column details
+        columns = {col["name"]: col for col in table.columns}
+        assert "id" in columns
+        assert columns["id"]["primary_key"] is True
+        assert "name" in columns
+        assert columns["name"]["notnull"] is True
+
+    def test_table_query_builder(self, resource):
+        """Test table() query builder in direct mode."""
+        users = resource.table("users").all()
+
+        assert len(users) == 2
+        assert users[0]["name"] == "Alice"
+        assert users[1]["name"] == "Bob"
+
+    def test_query_builder_eq(self, resource):
+        """Test query builder eq() filter."""
+        user = resource.table("users").eq("name", "Alice").first()
+
+        assert user is not None
+        assert user["name"] == "Alice"
+        assert user["email"] == "alice@example.com"
+
+    def test_query_builder_count(self, resource):
+        """Test query builder count()."""
+        count = resource.table("users").count()
+        assert count == 2
+
+        count_filtered = resource.table("users").eq("age", 30).count()
+        assert count_filtered == 1
+
+    def test_query_builder_where(self, resource):
+        """Test query builder where() with multiple conditions."""
+        users = resource.table("users").where(age=25).all()
+
+        assert len(users) == 1
+        assert users[0]["name"] == "Bob"
+
+    def test_query_builder_limit(self, resource):
+        """Test query builder limit()."""
+        users = resource.table("users").limit(1).all()
+
+        assert len(users) == 1
+
+    def test_query_error_handling(self, resource):
+        """Test error handling for invalid queries."""
+        response = resource.query("SELECT * FROM nonexistent_table")
+
+        assert response.success is False
+        assert response.error is not None
+        assert "nonexistent_table" in response.error.lower() or "no such table" in response.error.lower()
+
+
+class TestSQLiteResourceHTTPMode:
+    """Test SQLiteResource in HTTP (remote) mode."""
+
+    @pytest.fixture
+    def mock_client(self, mocker):
+        """Create a mock HTTP client."""
+        return mocker.Mock()
+
+    @pytest.fixture
+    def resource(self, mock_client):
+        """Create a SQLiteResource in HTTP mode."""
+        resource_model = ResourceModel(
+            name="remote_db",
+            type=ResourceType.db,
+            mode=ResourceMode.rw,
+        )
+        return SQLiteResource(resource_model, client=mock_client, db_path=None)
+
+    def test_mode_property(self, resource):
+        """Test that mode property returns 'http'."""
+        assert resource.mode == "http"
+
+    def test_query_http(self, resource, mock_client, mocker):
+        """Test that query() calls HTTP client."""
+        # Mock the HTTP response
+        mock_response = mocker.Mock()
+        mock_response.json.return_value = {
+            "success": True,
+            "columns": ["id", "name"],
+            "rows": [[1, "Alice"]],
+            "message": "Query successful",
+        }
+        mock_client.request.return_value = mock_response
+
+        response = resource.query("SELECT * FROM users")
+
+        # Verify HTTP client was called
+        mock_client.request.assert_called_once()
+        call_args = mock_client.request.call_args
+        assert call_args[0][0] == "POST"
+        assert "/query" in call_args[0][1]
+
+        # Verify response
+        assert response.success is True
+        assert response.columns == ["id", "name"]
+
+    def test_describe_http(self, resource, mock_client, mocker):
+        """Test that describe() calls HTTP client."""
+        # Mock the HTTP response
+        mock_response = mocker.Mock()
+        mock_response.json.return_value = {
+            "success": True,
+            "resource_name": "remote_db",
+            "tables": [],
+            "message": "Schema retrieved",
+        }
+        mock_client.request.return_value = mock_response
+
+        response = resource.describe()
+
+        # Verify HTTP client was called
+        mock_client.request.assert_called_once()
+        call_args = mock_client.request.call_args
+        assert call_args[0][0] == "GET"
+        assert "/describe" in call_args[0][1]
+
+        # Verify response
+        assert response.success is True
+        assert response.resource_name == "remote_db"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

tests/test_sqlite_shared_memory_behavior.py

@@ -0,0 +1,117 @@
+"""Verification tests for SQLite shared memory behavior.
+
+These tests verify how SQLite's shared memory databases work to ensure
+our implementation assumptions are correct.
+"""
+
+import sqlite3
+import pytest
+
+
+def test_plain_memory_no_sharing():
+    """Verify that plain :memory: databases don't share data."""
+    conn1 = sqlite3.connect(':memory:')
+    conn1.execute("CREATE TABLE test (id INT)")
+    conn1.execute("INSERT INTO test VALUES (1)")
+
+    # Second connection to :memory: creates a SEPARATE database
+    conn2 = sqlite3.connect(':memory:')
+
+    with pytest.raises(sqlite3.OperationalError, match="no such table"):
+        conn2.execute("SELECT * FROM test")
+
+    conn1.close()
+    conn2.close()
+
+
+def test_shared_memory_uri_sharing():
+    """Verify that shared memory URIs DO share data."""
+    conn1 = sqlite3.connect('file:testdb?mode=memory&cache=shared', uri=True)
+    conn1.execute("CREATE TABLE test (id INT)")
+    conn1.execute("INSERT INTO test VALUES (1)")
+    conn1.commit()  # Commit so other connections can see changes
+
+    # Second connection to same URI shares the database
+    conn2 = sqlite3.connect('file:testdb?mode=memory&cache=shared', uri=True)
+    result = conn2.execute("SELECT * FROM test").fetchall()
+
+    assert result == [(1,)]
+
+    conn1.close()
+    conn2.close()
+
+
+def test_different_namespaces_isolated():
+    """Verify that different shared memory namespaces are isolated."""
+    conn1 = sqlite3.connect('file:db1?mode=memory&cache=shared', uri=True)
+    conn1.execute("CREATE TABLE test (id INT)")
+    conn1.execute("INSERT INTO test VALUES (1)")
+
+    conn2 = sqlite3.connect('file:db2?mode=memory&cache=shared', uri=True)
+
+    # db2 should not have the test table from db1
+    with pytest.raises(sqlite3.OperationalError, match="no such table"):
+        conn2.execute("SELECT * FROM test")
+
+    conn1.close()
+    conn2.close()
+
+
+def test_data_lost_when_all_connections_close():
+    """Verify that shared memory data is lost when all connections close."""
+    conn1 = sqlite3.connect('file:tempdb?mode=memory&cache=shared', uri=True)
+    conn1.execute("CREATE TABLE test (id INT)")
+    conn1.execute("INSERT INTO test VALUES (1)")
+    conn1.commit()  # Commit so other connections can see changes
+
+    conn2 = sqlite3.connect('file:tempdb?mode=memory&cache=shared', uri=True)
+    result = conn2.execute("SELECT * FROM test").fetchall()
+    assert result == [(1,)]
+
+    # Close all connections
+    conn1.close()
+    conn2.close()
+
+    # Open new connection - database is recreated empty
+    conn3 = sqlite3.connect('file:tempdb?mode=memory&cache=shared', uri=True)
+
+    with pytest.raises(sqlite3.OperationalError, match="no such table"):
+        conn3.execute("SELECT * FROM test")
+
+    conn3.close()
+
+
+def test_anchor_connection_keeps_data_alive():
+    """Verify that keeping one connection open preserves the data."""
+    # Create anchor connection
+    anchor = sqlite3.connect('file:persistent?mode=memory&cache=shared', uri=True)
+    # Drop table if it exists from a previous test run
+    anchor.execute("DROP TABLE IF EXISTS test")
+    anchor.execute("CREATE TABLE test (id INT)")
+    anchor.execute("INSERT INTO test VALUES (1)")
+    anchor.commit()  # Commit so other connections can see changes
+
+    # Open and close other connections
+    conn1 = sqlite3.connect('file:persistent?mode=memory&cache=shared', uri=True)
+    result = conn1.execute("SELECT * FROM test").fetchall()
+    assert result == [(1,)]
+    conn1.close()
+
+    # Even after conn1 closes, data is still there because anchor is open
+    conn2 = sqlite3.connect('file:persistent?mode=memory&cache=shared', uri=True)
+    result = conn2.execute("SELECT * FROM test").fetchall()
+    assert result == [(1,)]
+    conn2.close()
+
+    # Close anchor
+    anchor.close()
+
+    # Now data is gone
+    conn3 = sqlite3.connect('file:persistent?mode=memory&cache=shared', uri=True)
+    with pytest.raises(sqlite3.OperationalError, match="no such table"):
+        conn3.execute("SELECT * FROM test")
+    conn3.close()
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

fleet_python-0.2.66b2.dist-info/RECORD

@@ -1,81 +0,0 @@
-examples/diff_example.py,sha256=iLlpBW_NBjzXBqlvYwjx74uxYZkMGJfea6s3tJhvuNY,5684
-examples/dsl_example.py,sha256=yFLgM-Was4-w575xJgPk9DIBmXa34hLJsIB4XwTADOE,7252
-examples/example.py,sha256=yn9mqS2yJ6896s25btnJx9-_SLLbyS-Fu-SIcas6jok,1081
-examples/exampleResume.py,sha256=hzdL9QfYtwlje5geWS2cgWgjcnLX4UtXSAd-92F66Lw,7044
-examples/example_account.py,sha256=t5_Tnr7DcLYfNpEAbuBySQIqsqiQQGySuiItIghCjAM,225
-examples/example_action_log.py,sha256=pwvLro_Fkrw4DII002bHGuWfoZ6QRvUMDD9BnMqJgLQ,622
-examples/example_client.py,sha256=M9Mfi1FcD2LtSDVk89R_-tgG98swvDYy4qx2zVayJ-0,1025
-examples/example_mcp_anthropic.py,sha256=WzQipN6ryPYuiGcvYmaTget4Hn421ijMS6xDYWwrVyE,2619
-examples/example_mcp_openai.py,sha256=xhqJd2-mnQs4-ZmydGrX7pPs7_X5i-YFqkO1cr3L-5g,480
-examples/example_sync.py,sha256=EkuWmUzB1ZsBJQk6ZRflB793rKsuRHeSg5HJZHVhBB0,975
-examples/example_task.py,sha256=dhG6STAkNsTdHs9cO1RFH9WfuvRmq5bRC211hTeFrk8,7088
-examples/example_tasks.py,sha256=xTL8UWVAuolSX6swskfrAcmDrLIzn45dJ7YPWCwoEBU,514
-examples/example_verifier.py,sha256=0vwNITIG3m4CkSPwIxNXcGx9TqrxEsCGqK2A8keKZMM,2392
-examples/export_tasks.py,sha256=cJ_8xND7Q3IOM1JfJPR-DH3aLfHo_KmKJeO-1IVUFrQ,3237
-examples/gemini_example.py,sha256=qj9WDazQTYNiRHNeUg9Tjkp33lJMwbx8gDfpFe1sDQo,16180
-examples/import_tasks.py,sha256=Duh7T0HUuqsYUZ6LK2AXF3eP0zfSj1izkI5-1p09d9w,11041
-examples/json_tasks_example.py,sha256=CYPESGGtOo0fmsDdLidujTfsE4QlJHw7rOhyVqPJ_Ls,5329
-examples/nova_act_example.py,sha256=rH23Lp74Okf0rn8ynMdWjK2aviEf5NLPH4k_53Pyxho,831
-examples/openai_example.py,sha256=dEWERrTEP5xBiGkLkQjBQGd2NqoxX6gcW6XteBPsWFQ,8231
-examples/openai_simple_example.py,sha256=HmiufucrAZne7tHq9uoEsDWlEhjNC265bQAyIGBRU2o,1745
-examples/query_builder_example.py,sha256=-cOMfWGNifYfYEt_Ds73XpwATZvFDL6F4KTkVxdMjzg,3951
-examples/quickstart.py,sha256=1VT39IRRhemsJgxi0O0gprdpcw7HB4pYO97GAYagIcg,3788
-examples/test_cdp_logging.py,sha256=AkCwQCgOTQEI8w3v0knWK_4eXMph7L9x07wj9yIYM10,2836
-fleet/__init__.py,sha256=yC4HIcbtPAPOgI0lLri3l8nbXkNee9JOihKAc7SXYkY,4201
-fleet/base.py,sha256=bc-340sTpq_DJs7yQ9d2pDWnmJFmA1SwDB9Lagvqtb4,9182
-fleet/client.py,sha256=3fcUTBOB8z6nwL07HMXSjajSH_pb2_3gvo2KdGxzxdo,32579
-fleet/config.py,sha256=uY02ZKxVoXqVDta-0IMWaYJeE1CTXF_fA9NI6QUutmU,319
-fleet/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
-fleet/global_client.py,sha256=frrDAFNM2ywN0JHLtlm9qbE1dQpnQJsavJpb7xSR_bU,1072
-fleet/models.py,sha256=AuSApLRN6aIDTOuJ4mGUyS1K1oLG9Q2AzjIE0Zj61MY,13586
-fleet/tasks.py,sha256=j14T6aoKDu3NghtQEr0vP-YDW_r8FxdDAazWe-6PQj0,17423
-fleet/types.py,sha256=L4Y82xICf1tzyCLqhLYUgEoaIIS5h9T05TyFNHSWs3s,652
-fleet/_async/__init__.py,sha256=5oOTmh16UsPWL2gDKKWkj2j5WGNeUhMzbQFWjX21jsc,8310
-fleet/_async/base.py,sha256=oisVTQsx0M_yTmyQJc3oij63uKZ97MHz-xYFsWXxQE8,9202
-fleet/_async/client.py,sha256=w_g0aOLfyyK_OojjGVe3TgyQQsWxnybJRFMLOtsb0p8,33027
-fleet/_async/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
-fleet/_async/global_client.py,sha256=4WskpLHbsDEgWW7hXMD09W-brkp4euy8w2ZJ88594rQ,1103
-fleet/_async/models.py,sha256=6WMN--LJFV-A5L2jW8Y6q7HQfub7qGxGoVkPQhvS_jw,13358
-fleet/_async/tasks.py,sha256=653T8m41i6ea-YCfr5EOsAD7CIi9ystcExMepxhSiA0,17442
-fleet/_async/env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fleet/_async/env/client.py,sha256=hUwrKTAkTAbO94_pDaAH8LyvlS9q-7oT7ZRrNo03LNs,1309
-fleet/_async/instance/__init__.py,sha256=PtmJq8J8bh0SOQ2V55QURz5GJfobozwtQoqhaOk3_tI,515
-fleet/_async/instance/base.py,sha256=3qUBuUR8OVS36LzdP6KyZzngtwPKYO09HoY6Ekxp-KA,1625
-fleet/_async/instance/client.py,sha256=kcrmLZciQxvPSfTtbEq5LIbhscwDHg6WIiNcPyM4L9w,6085
-fleet/_async/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fleet/_async/resources/base.py,sha256=UfrenxUqcpL8SgYGOo8o8HgRvv2-ZO5G2Cdo91ofEdg,664
-fleet/_async/resources/browser.py,sha256=oldoSiymJ1lJkADhpUG81ViOBDNyppX1jSoEwe9-W94,1369
-fleet/_async/resources/mcp.py,sha256=TLEsLiFhfVfZFs0Fu_uDPm-h4FPdvqgQblYqs-PTHhc,1720
-fleet/_async/resources/sqlite.py,sha256=up_umepfyX9PDFsnmEMJLjsj7bLa6a3wizZOgMGkK1Q,27409
-fleet/_async/verifiers/__init__.py,sha256=1WTlCNq4tIFbbXaQu5Bf2WppZq0A8suhtZbxMTSOwxI,465
-fleet/_async/verifiers/bundler.py,sha256=Sq0KkqEhM5Ng2x8R6Z4puXvQ8FMlEO7D3-ldBLktPi4,26205
-fleet/_async/verifiers/verifier.py,sha256=IiHX028s6ux0kb2FR0Z5zJangl_IDh6cemXsUN2ktUU,14152
-fleet/env/__init__.py,sha256=cS9zCYobM5jypppDMZIQMYd6hOg5f4sgqRXEQ67pckk,676
-fleet/env/client.py,sha256=Lu0pGia3Rcull83BFhB1nccAHXbUEGFKl3BUSkoKbr4,1143
-fleet/instance/__init__.py,sha256=CyWUkbGAK-DBPw4DC4AnCW-MqqheGhZMA5QSRVu-ws4,479
-fleet/instance/base.py,sha256=OYqzBwZFfTX9wlBGSG5gljqj98NbiJeKIfFJ3uj5I4s,1587
-fleet/instance/client.py,sha256=XM_Qmd7pUzC3-dCMTh6orTEsGeWJXbKueBlvcWcSUuI,5897
-fleet/instance/models.py,sha256=ZTiue0YOuhuwX8jYfJAoCzGfqjLqqXRLqK1LVFhq6rQ,4183
-fleet/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fleet/resources/base.py,sha256=AXZzT0_yWHkT497q3yekfr0xsD4cPGMCC6y7C43TIkk,663
-fleet/resources/browser.py,sha256=hRNM0YMsVQUAraZGNi_B-KXxLpuddy4ntoEDFSw7czU,1295
-fleet/resources/mcp.py,sha256=c6O4vVJnXANuHMGMe4IPxgp4zBEbFaGm6_d9e6j8Myc,1695
-fleet/resources/sqlite.py,sha256=bR6d1zYQ4cMAlmZIJ7jqmY9-N-GokXaDhUyGKTWHsfY,26811
-fleet/verifiers/__init__.py,sha256=GntS8qc3xv8mm-cku1t3xjvOll5jcc5FuiVqQgR4Y6Q,458
-fleet/verifiers/bundler.py,sha256=Sq0KkqEhM5Ng2x8R6Z4puXvQ8FMlEO7D3-ldBLktPi4,26205
-fleet/verifiers/code.py,sha256=A1i_UabZspbyj1awzKVQ_HRxgMO3fU7NbkxYyTrp7So,48
-fleet/verifiers/db.py,sha256=LAh1HambBInH_D9q9E2Z41YNkCOI9JJfpWPFqztjpfQ,27922
-fleet/verifiers/decorator.py,sha256=nAP3O8szXu7md_kpwpz91hGSUNEVLYjwZQZTkQlV1DM,3260
-fleet/verifiers/parse.py,sha256=qz9AfJrTbjlg-LU-lE8Ciqi7Yt2a8-cs17FdpjTLhMk,8550
-fleet/verifiers/sql_differ.py,sha256=TqTLWyK3uOyLbitT6HYzYEzuSFC39wcyhgk3rcm__k8,6525
-fleet/verifiers/verifier.py,sha256=_lcxXVm8e0xRrK2gNJy9up7pW1zOkPRY5n5lQ85S8jg,14197
-fleet_python-0.2.66b2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-scripts/fix_sync_imports.py,sha256=X9fWLTpiPGkSHsjyQUDepOJkxOqw1DPj7nd8wFlFqLQ,8368
-scripts/unasync.py,sha256=vWVQxRWX8SRZO5cmzEhpvnG_REhCWXpidIGIpWmEcvI,696
-tests/__init__.py,sha256=Re1SdyxH8NfyL1kjhi7SQkGP1mYeWB-D6UALqdIMd8I,35
-tests/test_verifier_from_string.py,sha256=Lxi3TpFHFb-hG4-UhLKZJkqo84ax9YJY8G6beO-1erM,13581
-tests/test_verifier_security.py,sha256=AvjWTVV-VlWaysNkHcRz1_UZxjYZYlr4ynM6uy2o9eM,12821
-fleet_python-0.2.66b2.dist-info/METADATA,sha256=9mVNEaeW1-l9zc2kbm49kU9vzkzFqnEc_IEyyXml6hc,3306
-fleet_python-0.2.66b2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fleet_python-0.2.66b2.dist-info/top_level.txt,sha256=qb1zIbtEktyhRFZdqVytwg54l64qtoZL0wjHB4bUg3c,29
-fleet_python-0.2.66b2.dist-info/RECORD,,