roksta 0.2.7__cp311-cp311-win_amd64.whl → 0.3.2__cp311-cp311-win_amd64.whl

tests/functions/test_utils.py

@@ -0,0 +1,484 @@
+import importlib.util
+import os
+import sys
+import types
+import json
+import base64
+import uuid
+import pytest
+
+
+# Helper to create simple module stubs
+def _make_fake_firebase_functions():
+    fake_https = types.ModuleType('firebase_functions.https_fn')
+
+    class FakeResponse:
+        def __init__(self, response=None, mimetype=None, status=200, **kwargs):
+            # Mirror the small subset of the real Response API used by the code/tests
+            self.status_code = status
+            if isinstance(response, bytes):
+                self._text = response.decode('utf-8')
+            else:
+                # If a non-string is passed (unlikely), coerce to JSON text for assertions
+                self._text = response if isinstance(response, str) else (json.dumps(response) if response is not None else '')
+            self.mimetype = mimetype
+            self.headers = {'Content-Type': mimetype} if mimetype else {}
+
+        def get_data(self, as_text=False):
+            return self._text if as_text else self._text.encode('utf-8')
+
+    fake_https.Response = FakeResponse
+    # Provide a Request attribute used in type annotations in the module under test
+    fake_https.Request = types.SimpleNamespace
+
+    fake_root = types.ModuleType('firebase_functions')
+    fake_root.https_fn = fake_https
+    return fake_root, fake_https
+
+
+def _make_fake_firebase_admin():
+    fake = types.ModuleType('firebase_admin')
+    # Minimal auth object so import succeeds; tests here don't rely on actual auth behaviour
+    fake.auth = types.SimpleNamespace(verify_id_token=lambda token: {'uid': 'test'})
+    return fake
+
+
+def _make_fake_google_secretmanager():
+    google = types.ModuleType('google')
+    google_cloud = types.ModuleType('google.cloud')
+    secretmanager = types.ModuleType('google.cloud.secretmanager')
+
+    class FakeClient:
+        def access_secret_version(self, request):
+            raise RuntimeError("SecretManager should not be called in these tests")
+
+    secretmanager.SecretManagerServiceClient = FakeClient
+    google_cloud.secretmanager = secretmanager
+    google.cloud = google_cloud
+    return google, google_cloud, secretmanager
+
+
+def _load_utils_module(monkeypatch):
+    """Load a fresh copy of functions/utils.py as an isolated module.
+
+    This helper inserts necessary fake modules into sys.modules via the
+    provided monkeypatch fixture before loading the module so its import-time
+    dependencies succeed and are controllable by the tests.
+    """
+    repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
+    utils_path = os.path.join(repo_root, 'functions', 'utils.py')
+    assert os.path.exists(utils_path), f"Expected functions/utils.py to exist at {utils_path}"
+
+    # Prepare and register lightweight stubs needed at import time
+    fake_firebase_root, fake_https = _make_fake_firebase_functions()
+    monkeypatch.setitem(sys.modules, 'firebase_functions', fake_firebase_root)
+    monkeypatch.setitem(sys.modules, 'firebase_functions.https_fn', fake_https)
+
+    fake_firebase_admin = _make_fake_firebase_admin()
+    monkeypatch.setitem(sys.modules, 'firebase_admin', fake_firebase_admin)
+
+    google, google_cloud, secretmanager = _make_fake_google_secretmanager()
+    monkeypatch.setitem(sys.modules, 'google', google)
+    monkeypatch.setitem(sys.modules, 'google.cloud', google_cloud)
+    monkeypatch.setitem(sys.modules, 'google.cloud.secretmanager', secretmanager)
+
+    # Create a unique module name so each test gets a fresh module object
+    module_name = f"tests.utils_isolated_{uuid.uuid4().hex}"
+    spec = importlib.util.spec_from_file_location(module_name, utils_path)
+    module = importlib.util.module_from_spec(spec)
+    # Ensure the new module is discoverable under its name during execution
+    monkeypatch.setitem(sys.modules, module_name, module)
+    spec.loader.exec_module(module)
+    return module
+
+
+def test_create_json_response_returns_expected_json_and_status(monkeypatch):
+    mod = _load_utils_module(monkeypatch)
+
+    resp = mod.create_json_response(True, {"alpha": 1}, 201)
+
+    assert hasattr(resp, 'status_code')
+    assert resp.status_code == 201
+
+    body_text = resp.get_data(as_text=True)
+    parsed = json.loads(body_text)
+    assert parsed == {"success": True, "payload": {"alpha": 1}}
+
+
+def test_get_sealedbox_private_key_raises_when_pynacl_privatekey_missing(monkeypatch):
+    # Ensure a nacl.public module exists but does NOT expose PrivateKey so the
+    # import inside get_sealedbox_private_key raises and the function reports
+    # that encryption support is unavailable.
+    nacl_mod = types.ModuleType('nacl')
+    nacl_public = types.ModuleType('nacl.public')
+
+    # Provide PublicKey/SealedBox but omit PrivateKey to trigger the import error
+    class PublicKeyStub:
+        def __init__(self, data):
+            self._data = bytes(data)
+
+    class SealedBoxStub:
+        def __init__(self, key):
+            pass
+
+    nacl_public.PublicKey = PublicKeyStub
+    nacl_public.SealedBox = SealedBoxStub
+
+    monkeypatch.setitem(sys.modules, 'nacl', nacl_mod)
+    monkeypatch.setitem(sys.modules, 'nacl.public', nacl_public)
+
+    mod = _load_utils_module(monkeypatch)
+
+    with pytest.raises(Exception) as excinfo:
+        mod.get_sealedbox_private_key()
+
+    assert 'Encryption support is unavailable' in str(excinfo.value)
+
+
+def test_get_sealedbox_private_key_initializes_and_caches_private_key(monkeypatch):
+    # Provide a PrivateKey implementation and stub get_secret_key to return
+    # a valid 32-byte base64-encoded secret. Verify the value is cached and
+    # the secret fetch is only performed once.
+    key_bytes = b"\x02" * 32
+
+    nacl_mod = types.ModuleType('nacl')
+    nacl_public = types.ModuleType('nacl.public')
+
+    class PrivateKeyStub:
+        def __init__(self, data):
+            # Accept bytes-like input
+            self._data = bytes(data)
+
+        def __repr__(self):
+            return f"PrivateKeyStub(len={len(self._data)})"
+
+    nacl_public.PrivateKey = PrivateKeyStub
+    monkeypatch.setitem(sys.modules, 'nacl', nacl_mod)
+    monkeypatch.setitem(sys.modules, 'nacl.public', nacl_public)
+
+    mod = _load_utils_module(monkeypatch)
+
+    calls = {'count': 0}
+
+    def fake_get_secret_key(name):
+        calls['count'] += 1
+        return base64.b64encode(key_bytes).decode('ascii')
+
+    # Replace the module-level get_secret_key with our fake
+    mod.get_secret_key = fake_get_secret_key
+
+    # Ensure fresh start
+    mod._SEALEDBOX_PRIVATE_KEY = None
+
+    first = mod.get_sealedbox_private_key()
+    second = mod.get_sealedbox_private_key()
+
+    assert first is second
+    assert calls['count'] == 1
+    assert hasattr(first, '_data') and first._data == key_bytes
+
+
+def test_get_sealedbox_private_key_invalid_length_does_not_cache_and_raises(monkeypatch):
+    # Provide PrivateKey but have the secret manager return an invalid-length key
+    invalid_key = b"\x03" * 16
+
+    nacl_mod = types.ModuleType('nacl')
+    nacl_public = types.ModuleType('nacl.public')
+
+    class PrivateKeyStub:
+        def __init__(self, data):
+            self._data = bytes(data)
+
+    nacl_public.PrivateKey = PrivateKeyStub
+    monkeypatch.setitem(sys.modules, 'nacl', nacl_mod)
+    monkeypatch.setitem(sys.modules, 'nacl.public', nacl_public)
+
+    mod = _load_utils_module(monkeypatch)
+
+    def fake_get_secret_key(name):
+        return base64.b64encode(invalid_key).decode('ascii')
+
+    mod.get_secret_key = fake_get_secret_key
+
+    # Ensure fresh start
+    mod._SEALEDBOX_PRIVATE_KEY = None
+
+    with pytest.raises(Exception) as excinfo:
+        mod.get_sealedbox_private_key()
+
+    assert 'Failed to initialize sealed-box private key' in str(excinfo.value)
+    # Failure should not be cached
+    assert mod._SEALEDBOX_PRIVATE_KEY is None
+
+
+# ------------------------- Additional tests to improve coverage -------------------------
+
+def test_get_secret_key_returns_secret_on_success(monkeypatch):
+    mod = _load_utils_module(monkeypatch)
+
+    fake_payload = types.SimpleNamespace(data=b'secret-value')
+    fake_response = types.SimpleNamespace(payload=fake_payload)
+
+    class FakeClient:
+        def access_secret_version(self, request):
+            return fake_response
+
+    # Patch the SecretManager client on the imported module
+    monkeypatch.setattr(mod.secretmanager, 'SecretManagerServiceClient', FakeClient, raising=True)
+
+    result = mod.get_secret_key('my-secret')
+    assert result == 'secret-value'
+
+
+def test_get_secret_key_raises_on_backend_error(monkeypatch):
+    mod = _load_utils_module(monkeypatch)
+
+    class FakeClient:
+        def access_secret_version(self, request):
+            raise RuntimeError('boom')
+
+    monkeypatch.setattr(mod.secretmanager, 'SecretManagerServiceClient', FakeClient, raising=True)
+
+    with pytest.raises(Exception) as excinfo:
+        mod.get_secret_key('does-not-matter')
+    assert 'Failed to retrieve secret key from Secret Manager' in str(excinfo.value)
+
+
+def test_verify_firebase_token_success(monkeypatch):
+    mod = _load_utils_module(monkeypatch)
+    req = types.SimpleNamespace(headers={'Authorization': 'Bearer SOME_TOKEN'})
+
+    res = mod.verify_firebase_token(req)
+    assert res == {'uid': 'test'}
+
+
+def test_verify_firebase_token_missing_or_invalid_header_raises(monkeypatch):
+    mod = _load_utils_module(monkeypatch)
+    req = types.SimpleNamespace(headers={})
+
+    with pytest.raises(Exception) as excinfo:
+        mod.verify_firebase_token(req)
+    # The implementation wraps the underlying message, but the cause should be present
+    assert 'Missing or invalid Authorization' in str(excinfo.value)
+
+
+def test_verify_firebase_token_verify_id_token_failure_raises(monkeypatch):
+    mod = _load_utils_module(monkeypatch)
+
+    def fake_verify(token):
+        raise ValueError('invalid token')
+
+    # Replace the verifier with one that raises
+    mod.auth.verify_id_token = fake_verify
+
+    req = types.SimpleNamespace(headers={'Authorization': 'Bearer x'})
+    with pytest.raises(Exception) as excinfo:
+        mod.verify_firebase_token(req)
+    assert 'invalid token' in str(excinfo.value)
+
+
+def test_get_api_key_delegates_to_get_secret_key(monkeypatch):
+    mod = _load_utils_module(monkeypatch)
+
+    called = {}
+
+    def fake_get_secret_key(name):
+        called['name'] = name
+        return 'X'
+
+    mod.get_secret_key = fake_get_secret_key
+
+    result = mod.get_api_key(mod.LlmFamily.OPENAI)
+    assert result == 'X'
+    assert called['name'] == 'openai-api-key'
+
+
+def test_get_request_json_plaintext_returns_parsed_json(monkeypatch):
+    mod = _load_utils_module(monkeypatch)
+
+    def get_json(silent=False):
+        return {'a': 1}
+
+    req = types.SimpleNamespace(headers={}, get_json=get_json)
+    result = mod.get_request_json(req, strict=False)
+    assert result == {'a': 1}
+
+
+def test_get_request_json_plaintext_strict_raises_on_get_json_error(monkeypatch):
+    mod = _load_utils_module(monkeypatch)
+
+    def get_json(silent=False):
+        raise ValueError('bad json')
+
+    req = types.SimpleNamespace(headers={}, get_json=get_json)
+    with pytest.raises(Exception):
+        mod.get_request_json(req, strict=True)
+
+
+def test_get_request_json_plaintext_non_strict_returns_none_on_get_json_error(monkeypatch):
+    mod = _load_utils_module(monkeypatch)
+
+    def get_json(silent=False):
+        raise ValueError('bad json')
+
+    req = types.SimpleNamespace(headers={}, get_json=get_json)
+    result = mod.get_request_json(req, strict=False)
+    assert result is None
+
+
+def _install_sealedbox_stub(monkeypatch, decrypt_behavior):
+    """Helper: install a nacl.public.SealedBox stub whose decrypt returns or throws.
+
+    decrypt_behavior may be either:
+      - a bytes object to return from decrypt(), or
+      - a callable that accepts ciphertext and returns bytes / raises.
+    """
+    nacl_mod = types.ModuleType('nacl')
+    nacl_public = types.ModuleType('nacl.public')
+
+    class SealedBox:
+        def __init__(self, key):
+            self._key = key
+
+        def decrypt(self, ciphertext):
+            if callable(decrypt_behavior):
+                return decrypt_behavior(ciphertext)
+            return decrypt_behavior
+
+    nacl_public.SealedBox = SealedBox
+    nacl_mod.public = nacl_public
+
+    # Ensure both module paths exist in sys.modules so `from nacl.public import SealedBox` works
+    monkeypatch.setitem(sys.modules, 'nacl', nacl_mod)
+    monkeypatch.setitem(sys.modules, 'nacl.public', nacl_public)
+
+
+def test_get_request_json_encrypted_success_using_get_data(monkeypatch):
+    mod = _load_utils_module(monkeypatch)
+
+    plaintext = b'{"ok": true}'
+    ciphertext = b'FAKECIPHERTEXT'
+    body_b64 = base64.b64encode(ciphertext)
+
+    # Request exposes get_data(as_text=False)
+    def get_data(as_text=False):
+        return body_b64
+
+    req = types.SimpleNamespace(headers={mod.ENCRYPTION_HEADER_NAME: 'true'}, get_data=get_data)
+
+    # SealedBox.decrypt will return the plaintext regardless of ciphertext
+    _install_sealedbox_stub(monkeypatch, plaintext)
+    # Stub the private key loader so it doesn't call Secret Manager
+    monkeypatch.setattr(mod, 'get_sealedbox_private_key', lambda: 'DUMMY', raising=False)
+
+    res = mod.get_request_json(req, strict=True)
+    assert res == {"ok": True}
+
+
+def test_get_request_json_encrypted_fallback_when_get_data_rejects_as_text_arg(monkeypatch):
+    mod = _load_utils_module(monkeypatch)
+
+    plaintext = b'{"ok": 1}'
+    ciphertext = b'CT'
+    body_b64 = base64.b64encode(ciphertext)
+
+    def get_data(*args, **kwargs):
+        # Simulate a stub that raises when given the as_text kwarg
+        if 'as_text' in kwargs:
+            raise TypeError('no as_text')
+        return body_b64
+
+    req = types.SimpleNamespace(headers={mod.ENCRYPTION_HEADER_NAME: 'true'}, get_data=get_data)
+
+    _install_sealedbox_stub(monkeypatch, plaintext)
+    monkeypatch.setattr(mod, 'get_sealedbox_private_key', lambda: 'DUMMY', raising=False)
+
+    res = mod.get_request_json(req, strict=True)
+    assert res == {"ok": 1}
+
+
+def test_get_request_json_encrypted_uses_data_attribute_if_no_get_data(monkeypatch):
+    mod = _load_utils_module(monkeypatch)
+
+    plaintext = b'{"v": 42}'
+    ciphertext = b'CT2'
+    body_b64 = base64.b64encode(ciphertext)
+
+    req = types.SimpleNamespace(headers={mod.ENCRYPTION_HEADER_NAME: 'true'}, data=body_b64)
+
+    _install_sealedbox_stub(monkeypatch, plaintext)
+    monkeypatch.setattr(mod, 'get_sealedbox_private_key', lambda: 'DUMMY', raising=False)
+
+    res = mod.get_request_json(req, strict=True)
+    assert res == {"v": 42}
+
+
+def test_get_request_json_encrypted_invalid_base64(monkeypatch):
+    mod = _load_utils_module(monkeypatch)
+
+    # Make b64 decoder throw to exercise that error path deterministically
+    def fake_b64decode(_):
+        raise Exception('bad base64')
+
+    monkeypatch.setattr(mod.base64, 'b64decode', fake_b64decode, raising=True)
+
+    def get_data(as_text=False):
+        return b'NOT-BASE64'
+
+    req = types.SimpleNamespace(headers={mod.ENCRYPTION_HEADER_NAME: 'true'}, get_data=get_data)
+
+    # Non-strict should return None
+    res = mod.get_request_json(req, strict=False)
+    assert res is None
+
+    # Strict should raise
+    with pytest.raises(Exception):
+        mod.get_request_json(req, strict=True)
+
+
+def test_get_request_json_encrypted_decrypt_failure(monkeypatch):
+    mod = _load_utils_module(monkeypatch)
+
+    ciphertext = b'CT'
+    body_b64 = base64.b64encode(ciphertext)
+
+    # SealedBox.decrypt will raise to simulate decryption failure
+    def raise_on_decrypt(_):
+        raise RuntimeError('bad decrypt')
+
+    _install_sealedbox_stub(monkeypatch, raise_on_decrypt)
+    monkeypatch.setattr(mod, 'get_sealedbox_private_key', lambda: 'DUMMY', raising=False)
+
+    def get_data(as_text=False):
+        return body_b64
+
+    req = types.SimpleNamespace(headers={mod.ENCRYPTION_HEADER_NAME: 'true'}, get_data=get_data)
+
+    # Non-strict returns None
+    assert mod.get_request_json(req, strict=False) is None
+
+    # Strict raises
+    with pytest.raises(Exception):
+        mod.get_request_json(req, strict=True)
+
+
+def test_get_request_json_encrypted_invalid_json_after_decrypt(monkeypatch):
+    mod = _load_utils_module(monkeypatch)
+
+    # Decrypt returns bytes that are not valid JSON
+    _install_sealedbox_stub(monkeypatch, b'not-json')
+    monkeypatch.setattr(mod, 'get_sealedbox_private_key', lambda: 'DUMMY', raising=False)
+
+    body_b64 = base64.b64encode(b'CT')
+
+    def get_data(as_text=False):
+        return body_b64
+
+    req = types.SimpleNamespace(headers={mod.ENCRYPTION_HEADER_NAME: 'true'}, get_data=get_data)
+
+    assert mod.get_request_json(req, strict=False) is None
+    with pytest.raises(Exception):
+        mod.get_request_json(req, strict=True)
+
+
+# End of additional tests

roksta-0.2.7.dist-info/RECORD

@@ -1,78 +0,0 @@
-roksta/__init__.cp311-win_amd64.pyd,sha256=kVtuv-PimTcT9vr5kce0a4sQHSyWzVVIk42ONQ9N5v4,15872
-roksta/analytics.cp311-win_amd64.pyd,sha256=2XHICx3rn9iES7mTqAJyXZhzi7pLU8f-L9l8CL5CTXY,94208
-roksta/balance.cp311-win_amd64.pyd,sha256=Z2UcWIfBHDFtxjkYpDjFGJv7GvlgH_mktRytzHcSzBU,117760
-roksta/build_project.cp311-win_amd64.pyd,sha256=z7NYvpSpH2QF4wrdLNfKAzjEcY7Kqbhn70-4FcwZIBo,59904
-roksta/chat_workflow.cp311-win_amd64.pyd,sha256=X19X2pWTyiCFfcL6NpPf4lpVlrqWxAceLMf8xbuIXrc,89088
-roksta/check_for_updates.cp311-win_amd64.pyd,sha256=2axLsEHwPJYjJQgpuMrRfxLUsIYlfuOtxKFxoBq2jIQ,98304
-roksta/checkpoints.cp311-win_amd64.pyd,sha256=6koOtWXwyrb5G3oJEgIBNWOoLfeRgi0UjgmtRChcDwU,81408
-roksta/clarify_goal.cp311-win_amd64.pyd,sha256=cUqeOGWnxrspubfzdKmoMOrFBVqxlJq-NO23w__CxLI,64000
-roksta/codebase_listing.cp311-win_amd64.pyd,sha256=ynCpvL-zd4O2fw3qyKAB8iu9uKlMWk30dz9YYz06jGI,46592
-roksta/command_handlers.cp311-win_amd64.pyd,sha256=kKPBP_5eDEPA2jBpItGUs1qFGaS8VfOtO-_wEpxIAKM,371712
-roksta/create_default_config.cp311-win_amd64.pyd,sha256=v-SMG_c2f_g12fQ9ZZgVn8a__W5LC3v4vc2MRdMsGGg,31744
-roksta/default_config.cp311-win_amd64.pyd,sha256=Bg0FTTNQt6sAngtqstC3U_rLDZ7W2s68bQZcUA7nFO4,30720
-roksta/enums.cp311-win_amd64.pyd,sha256=dCSJFLTD84hz3IJe7YQSW-yrg1K1V5kHdbs9WeoVO8o,135168
-roksta/env.cp311-win_amd64.pyd,sha256=HPJCHScUJCyQOrH-QyuRVziU6NG9wT4ShgUmqu3v4d8,27136
-roksta/extended_text_area.cp311-win_amd64.pyd,sha256=lAmxRNGVF9h3y-mG1F4a9QjadUmjbipvfMb7McpIL54,107520
-roksta/firebase.cp311-win_amd64.pyd,sha256=078BGjj0iHa95XELZWytI4BOLIl9m6ittzltlwW_5VQ,167936
-roksta/firebase_auth_web.cp311-win_amd64.pyd,sha256=CIhBCcxx36uyxlNdrPEcHRQWsZ3yhJ23XDvq-_82LTc,170496
-roksta/firebase_config.cp311-win_amd64.pyd,sha256=hHOvz3BmakHGBliexJNzBw-byuwM38IUhO4u3lEIkOY,21504
-roksta/fix_tests.cp311-win_amd64.pyd,sha256=CAC80fQe_6_YuKfzzhKvotq2q9P9EFFzxJpsRz2FD2c,73728
-roksta/gen_codebase_summaries.cp311-win_amd64.pyd,sha256=XzQrevEOTTFk_HJAwqMiZjSKDvRnIU89-1d2wGUhmP8,230400
-roksta/gen_one_line_goal.cp311-win_amd64.pyd,sha256=9CocGZ0tTtWb6l55qxzhMHQ5gDjr7eNA6EbyChFrNVs,63488
-roksta/get_codebase_structure.cp311-win_amd64.pyd,sha256=SLvOIr4SOr2-KZYIC5xg9Fsrt6rRo8sstVMw6T4qXFI,66048
-roksta/get_failing_tests.cp311-win_amd64.pyd,sha256=aGW-VctMCU1bX1k5kYdYaIfzgudROegtt0Dd7zouKxI,69120
-roksta/goal_workflow.cp311-win_amd64.pyd,sha256=dhj1Ls513lO0m9NrITl_fxLw18gDHrfjEOE38_wE0o8,189952
-roksta/init_codebase.cp311-win_amd64.pyd,sha256=Oi5zfTn5Acde8_QIfTbbJSq9Z6VBV0WOP5VDvNzcXh4,95744
-roksta/lint_code.cp311-win_amd64.pyd,sha256=ry6JtopCzFif6ocjAlJs-7wtILoHPuHyMDBfmzKRLh8,69632
-roksta/logger.cp311-win_amd64.pyd,sha256=gpKI2DjQpSnFg1EkeZ36fBLS2BtU4WmosYQQ0YrR1RA,38400
-roksta/main.cp311-win_amd64.pyd,sha256=d_q43_dTcAzGLXlU8Bj-MLMlLnLBe1Dc-bBqfG66dQU,38912
-roksta/make_issue.cp311-win_amd64.pyd,sha256=5jUZHdcw0NGTPCL0O58VkKHO0qBpvivKXkT9k-xUwto,69632
-roksta/new_features.cp311-win_amd64.pyd,sha256=nWGmfU_RbX6bkb2rURiLP0ytLhIlsC0bv4Kh8uYtTpc,16384
-roksta/parse_readme.cp311-win_amd64.pyd,sha256=qOO2SK9Zg_l88Gy5jU4WBY-ndUp_BobIhybRKZo9O1E,61952
-roksta/propose_solution.cp311-win_amd64.pyd,sha256=hMni5zUGAoWgbW5AEsnXPcZ7ZY4_f4wFXewisXLU98k,61440
-roksta/response_formats.cp311-win_amd64.pyd,sha256=hQivV6gt6s6X2lo-uzyjojEzBzD0Z3IAzeQfuP1LZYQ,41984
-roksta/rewrite_goal.cp311-win_amd64.pyd,sha256=EVGA8xj3NhBE6QaPAwZ77keaiblDxhtzJGj1Jy53L2M,55808
-roksta/roksta.cp311-win_amd64.pyd,sha256=hRwYVSkwrKElbkFG7yy-DbrbH_xwJQ1hOaQlWQy7DOI,229376
-roksta/run_cli_goal.cp311-win_amd64.pyd,sha256=8HFka6AWgw-7s16UKKDNrOmIyv71QesEzY5cZcb5ui0,69120
-roksta/select_files.cp311-win_amd64.pyd,sha256=C6iY011nQT9ix_itXnBFqB2fdvkKEjXWr97mTfI5qfM,66048
-roksta/tips.cp311-win_amd64.pyd,sha256=r9aphvYXXqwyfAFlbAzRvamjOOW5jEfrFcx2gGCjP1U,20992
-roksta/utils.cp311-win_amd64.pyd,sha256=xQHjBcggSNyuxboxhcadqUH3hNGt52zFWGRDX6kLExM,221184
-roksta/write_code.cp311-win_amd64.pyd,sha256=8WWdjkVhGyIL4jyKMvsNvvR8z7-ZJPr5EhiCCisdMDQ,58880
-roksta/ai/__init__.cp311-win_amd64.pyd,sha256=2Bfwj4T5oOMgbXo-SE4fkp2t8qXvrUtcjihnZgIImQE,15872
-roksta/ai/call_ai.cp311-win_amd64.pyd,sha256=yl4gtbx9Qjm8KusVdO1786UKK1xcRlyyHf3KEz75Ha0,72192
-roksta/ai/gemini.cp311-win_amd64.pyd,sha256=gB25h3r7Akjg5kahw5MHLy0JQGdz07JTEVnSr_8AEJw,143872
-roksta/ai/generic.cp311-win_amd64.pyd,sha256=DvL70EWE2alGSCxSzlnuEjFqsi8tVv_ZsLH0k4R4WZg,105984
-roksta/ai/llm.cp311-win_amd64.pyd,sha256=-LFfN8JbjDz5HtSF0z_eLi67k34rBft0Ljt9YEFBmjI,92160
-roksta/ai/openai.cp311-win_amd64.pyd,sha256=MpnTcmY51RZpNaEwtUuroJIreZprW9g_wlYpxl0ZrBk,103424
-roksta/ai/tools.cp311-win_amd64.pyd,sha256=vRxuWnZkiZMEYYzcSUpQOdcdwqi-tX4dNAQaBZX5x2E,231936
-tests/__init__.py,sha256=meQjVtD2zimtDw3tIP6nNWHGDQVC42as-c_y038cYnk,126
-tests/conftest.py,sha256=auOTmcnUGIgvlQsVEOhchjLgUtQmnzMtCc5N3Sr79Cw,6464
-tests/functions/__init__.py,sha256=msAiuVOA8jfqVxichPYYyfBFCVEFB_xRvj4lrSpKK1w,97
-tests/functions/test_auth.py,sha256=SNzmpkoxknrxx6cTE91MM2kN3F08GB1pRuupP5IrQs0,1016
-tests/functions/test_main_functions.py,sha256=LgWLAOtSfDXNfHhAAr-j9Peb5JBLFtQ0eKAWqTxLNDU,2648
-tests/functions/test_utils_functions.py,sha256=2x4W2JGnnKabTSTNKQ_DdcZl7K9HVF0N4kudTL05b3Y,7590
-tests/functions/api_v0_01/__init__.py,sha256=6EY0sGI3Jkmk4BGjNzSgyLGxFIGy06vwD76KDKAHh4g,126
-tests/functions/api_v0_01/test__analytics.py,sha256=d0zfl_ydtFc8cxlaL5GV76Rz2P7XsHoqEp2rYdN1zk0,16224
-tests/functions/api_v0_01/test__gemini_proxy.py,sha256=BuT2IWS0NHCa1FzEN8YPf6t00TOjWbpF-SYSOZMWPCg,11459
-tests/functions/api_v0_01/test__generic_proxy.py,sha256=2CSQ8OYUM0Ertq9PYueWDBWgPmz5bpRO8YICAwA_ZUc,16589
-tests/functions/api_v0_01/test__get_payment_details.py,sha256=wvhH5xliVIkU6GvvWFKF-lAV8mSZfj0HCT284BjDYCw,14091
-tests/functions/api_v0_01/test__openai_proxy.py,sha256=tXAz-Ukl3FD1Zdv083xczoQzG-dOS53uL2gBjB-Wcx8,16174
-tests/functions/api_v0_01/test__redeem_credit_code.py,sha256=xDzTWQxcIztksCWpTNibNgZ2ZPT2gqgdtljZiE8wMlU,6514
-tests/functions/api_v0_01/test__sync_emails.py,sha256=5nH4wxcqHqowc4C-pNShF4eWS52Pw6hZxsaOTn7f66I,13022
-tests/functions/api_v0_01/test__take_payment.py,sha256=NFoIw4RVMT63c7diZ7gt6N03dp26vVlognZBchpWRLY,18513
-tests/functions/api_v0_01/test__use_activation_code.py,sha256=3XS-N-fL7UIOev2kzphlDy-2ukykQLzb_0kmlkCr1gQ,17396
-tests/functions/api_v1_00/__init__.py,sha256=VdV5Oy6FRVT4S1xK34YodylJ7FY6jqvjujkS2Qvbyt0,126
-tests/functions/api_v1_00/test__analytics.py,sha256=s_pK4ySr86PC4ZBr7Y7bCHOEuFj36amaWrianBZ_QbU,16222
-tests/functions/api_v1_00/test__gemini_proxy.py,sha256=ZNYBQ9agPyNYGAVYlWPY6IF8wP_5IQ4nbHOpY8TnKEw,13696
-tests/functions/api_v1_00/test__generic_proxy.py,sha256=f2KjO8v_mh4nBwdkFXJLYfFUBpJS_RDtQNfn0ltE2oM,18101
-tests/functions/api_v1_00/test__get_payment_details.py,sha256=GRMAn8WR-07EBZ0IkeVE4MARFUbDdDhEHO2dITRxnVA,14091
-tests/functions/api_v1_00/test__openai_proxy.py,sha256=i1f7S8IFgWiG6WGG-YYptjTCOjSudujEMyhP16BVlW0,18175
-tests/functions/api_v1_00/test__redeem_credit_code.py,sha256=A5WwuSXBX5TiZPdYrDRkUmpppBXG00lcP0LmRz0gNr0,6514
-tests/functions/api_v1_00/test__sync_emails.py,sha256=e0rb637Ois25t__1G8Yp7Pj8WgC-R1I9SUgS6bK1dsU,13024
-tests/functions/api_v1_00/test__take_payment.py,sha256=RQBUHcgN3-XOoPtAjca_72q4BaZxr_L3G_Nss5-gb2g,18513
-tests/functions/api_v1_00/test__use_activation_code.py,sha256=ZOCwXHzenH0l1WhmZP8s8vaXIk58lHpKJ0igx0VEDwY,17398
-roksta-0.2.7.dist-info/METADATA,sha256=tqdrCdR2ZSh1KSc_8dkuQ8tXOVkASKraZpUqAQgptjU,1466
-roksta-0.2.7.dist-info/WHEEL,sha256=JLOMsP7F5qtkAkINx5UnzbFguf8CqZeraV8o04b0I8I,101
-roksta-0.2.7.dist-info/entry_points.txt,sha256=mzRdYg_DlzZRwjxYUt9-gyoRCkM1QBTeTbwETgiTdGw,44
-roksta-0.2.7.dist-info/top_level.txt,sha256=lvciNZQ1dPGXpiCLdWVXK03n9fKHjbQdwjqQbnUjeYM,13
-roksta-0.2.7.dist-info/RECORD,,