feldera 0.131.0__py3-none-any.whl → 0.192.0__py3-none-any.whl

feldera/testutils_oidc.py

@@ -0,0 +1,368 @@
+"""
+OIDC Authentication Test Helper
+
+Utilities for testing OIDC authentication integration with remote providers.
+Provides token generation, validation helpers, and test configuration.
+"""
+
+import os
+import time
+import json
+import requests
+import jwt
+import logging
+from typing import Optional, Dict, Any
+from dataclasses import dataclass
+
+
+@dataclass
+class OidcTestConfig:
+    """Configuration for OIDC authentication tests using Resource Owner Password Flow"""
+
+    issuer: str
+    client_id: str
+    client_secret: str
+    username: str
+    password: str
+    scope: str = "openid profile email"
+
+    @classmethod
+    def from_environment(cls) -> Optional["OidcTestConfig"]:
+        """Load OIDC test configuration from environment variables"""
+        issuer = os.getenv("OIDC_TEST_ISSUER")
+        client_id = os.getenv("OIDC_TEST_CLIENT_ID")
+        client_secret = os.getenv("OIDC_TEST_CLIENT_SECRET")
+        username = os.getenv("OIDC_TEST_USERNAME")
+        password = os.getenv("OIDC_TEST_PASSWORD")
+
+        # All fields are required
+        if not all([issuer, client_id, client_secret, username, password]):
+            return None
+
+        return cls(
+            issuer=issuer,
+            client_id=client_id,
+            client_secret=client_secret,
+            username=username,
+            password=password,
+            scope=os.getenv("OIDC_TEST_SCOPE", "openid profile email"),
+        )
+
+
+class OidcTestHelper:
+    """Helper class for OIDC authentication testing"""
+
+    def __init__(self, config: OidcTestConfig):
+        self.config = config
+        self._discovery_doc = None
+        self._jwks = None
+        self._access_token = None
+        self._token_expires_at = 0
+
+    def get_discovery_document(self) -> Dict[str, Any]:
+        """Fetch and cache the OIDC discovery document"""
+        if self._discovery_doc is None:
+            discovery_url = (
+                f"{self.config.issuer.rstrip('/')}/.well-known/openid-configuration"
+            )
+            response = requests.get(discovery_url, timeout=30)
+            response.raise_for_status()
+            self._discovery_doc = response.json()
+        return self._discovery_doc
+
+    def get_jwks(self) -> Dict[str, Any]:
+        """Fetch and cache the JSON Web Key Set"""
+        if self._jwks is None:
+            discovery_doc = self.get_discovery_document()
+            jwks_uri = discovery_doc["jwks_uri"]
+            response = requests.get(jwks_uri, timeout=30)
+            response.raise_for_status()
+            self._jwks = response.json()
+        return self._jwks
+
+    def get_token_endpoint(self) -> str:
+        """Get the token endpoint URL from discovery document"""
+        discovery_doc = self.get_discovery_document()
+        token_endpoint = discovery_doc.get("token_endpoint")
+        if not token_endpoint:
+            raise ValueError("Token endpoint not found in OIDC discovery document")
+        return token_endpoint
+
+    def obtain_access_token(self, pytest_cache=None) -> str:
+        """
+        Obtain access token using environment variable set by pytest master node.
+
+        The actual token fetching is handled by pytest_configure hooks in conftest.py,
+        which guarantees only one auth request per test session across all workers.
+
+        If OIDC is configured but no token is available, this will fail fast.
+        """
+        logger = logging.getLogger(__name__)
+        current_time = time.time()
+
+        # Check environment variable for cross-process token sharing
+        token_data = get_cached_token_from_env()
+        if token_data:
+            logger.info("Using environment variable cached access token")
+            # Cache in instance for future calls to avoid repeated parsing
+            self._access_token = token_data["access_token"]
+            self._token_expires_at = token_data["expires_at"]
+            return token_data["access_token"]
+
+        # Fallback: Check instance cache
+        if self._access_token and current_time < self._token_expires_at - 30:
+            logger.info("Using instance cached access token")
+            return self._access_token
+
+        # If OIDC is configured but no token is available, this is a critical failure
+        raise RuntimeError(
+            "OIDC authentication is configured but no valid token is available. "
+            "This indicates the oidc_token_fixture failed to retrieve a token. "
+            "Check OIDC configuration and ensure pytest hooks ran properly."
+        )
+
+    def decode_token_claims(self, token: str) -> Dict[str, Any]:
+        """Decode JWT token claims without signature verification (for testing)"""
+        return jwt.decode(token, options={"verify_signature": False})
+
+    def is_token_expired(self, token: str) -> bool:
+        """Check if a JWT token is expired"""
+        try:
+            claims = self.decode_token_claims(token)
+            exp = claims.get("exp")
+            if exp is None:
+                return False  # No expiration claim
+            return time.time() > exp
+        except Exception:
+            return True  # Invalid token is considered expired
+
+    def validate_token_structure(self, token: str) -> bool:
+        """Validate that token has correct JWT structure"""
+        try:
+            # Just check if it can be decoded (ignoring signature)
+            self.decode_token_claims(token)
+            return True
+        except Exception:
+            return False
+
+    def create_authenticated_headers(self) -> Dict[str, str]:
+        """Create HTTP headers with valid authentication token"""
+        token = self.obtain_access_token()
+        return {"Accept": "application/json", "Authorization": f"Bearer {token}"}
+
+    def get_malformed_test_tokens(self) -> Dict[str, str]:
+        """Get various malformed tokens for negative testing"""
+        return {
+            "malformed_structure": "not.a.jwt",
+            "empty": "",
+            "malformed_header": "eyJhbGciOiJub25lIn0.eyJzdWIiOiJ0ZXN0In0.invalid",
+            "wrong_issuer": "eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJpc3MiOiJodHRwczovL3dyb25nLWlzc3Vlci5jb20iLCJhdWQiOiJ0ZXN0IiwiZXhwIjo5OTk5OTk5OTk5fQ.signature",
+        }
+
+
+def skip_if_oidc_not_configured():
+    """Decorator to skip tests if OIDC test environment is not configured"""
+    import pytest
+
+    config = OidcTestConfig.from_environment()
+    return pytest.mark.skipif(
+        config is None,
+        reason="OIDC test environment not configured. Set OIDC_TEST_ISSUER, OIDC_TEST_CLIENT_ID, OIDC_TEST_CLIENT_SECRET, OIDC_TEST_USERNAME, OIDC_TEST_PASSWORD",
+    )
+
+
+# Global test helper instance (lazy loaded)
+_test_helper = None
+
+
+def get_oidc_test_helper() -> Optional[OidcTestHelper]:
+    """Get global OIDC test helper instance"""
+    global _test_helper
+    if _test_helper is None:
+        config = OidcTestConfig.from_environment()
+        if config:
+            _test_helper = OidcTestHelper(config)
+    return _test_helper
+
+
+def parse_cached_token(env_token: str) -> Optional[Dict[str, Any]]:
+    """
+    Parse and validate a base64-encoded token from environment variable.
+
+    Args:
+        env_token: Base64-encoded JSON token data from environment variable
+
+    Returns:
+        Parsed token data dict if valid, None if invalid or expired
+    """
+    try:
+        import base64
+
+        token_json = base64.b64decode(env_token.encode()).decode()
+        token_data = json.loads(token_json)
+        return token_data
+    except Exception as e:
+        logging.getLogger(__name__).warning(f"Failed to parse cached token: {e}")
+        return None
+
+
+def is_token_valid(token_data: Dict[str, Any], buffer_seconds: int = 30) -> bool:
+    """
+    Check if token data is valid and not expired.
+
+    Args:
+        token_data: Dictionary containing token information
+        buffer_seconds: Safety buffer before expiration (default 30 seconds)
+
+    Returns:
+        True if token is valid and not expired, False otherwise
+    """
+    if not token_data:
+        return False
+
+    access_token = token_data.get("access_token")
+    expires_at = token_data.get("expires_at", 0)
+
+    if not access_token:
+        return False
+
+    current_time = time.time()
+    return current_time < expires_at - buffer_seconds
+
+
+def encode_token_for_env(token_data: Dict[str, Any]) -> str:
+    """
+    Encode token data as base64 for storage in environment variables.
+
+    Args:
+        token_data: Dictionary containing token information
+
+    Returns:
+        Base64-encoded JSON string suitable for environment variable storage
+    """
+    import base64
+
+    token_json = json.dumps(token_data)
+    return base64.b64encode(token_json.encode()).decode()
+
+
+def get_cached_token_from_env(
+    env_var_name: str = "FELDERA_PYTEST_OIDC_TOKEN",
+) -> Optional[Dict[str, Any]]:
+    """
+    Retrieve and validate cached token from environment variable.
+
+    Args:
+        env_var_name: Name of environment variable containing cached token
+
+    Returns:
+        Valid token data if available and not expired, None otherwise
+    """
+    import os
+
+    env_token = os.getenv(env_var_name)
+    if not env_token:
+        return None
+
+    token_data = parse_cached_token(env_token)
+    if token_data and is_token_valid(token_data):
+        return token_data
+
+    return None
+
+
+def setup_token_cache() -> Optional[Dict[str, Any]]:
+    """
+    Set up OIDC token cache in environment variable if not already present.
+
+    This function:
+    1. Checks if a valid token is already cached
+    2. If not, fetches a new token
+    3. Stores the token in environment variable for cross-process access
+
+    Used by both pytest hooks and demo runners to ensure consistent token caching.
+
+    Returns:
+        Token data if successfully cached, None if OIDC not configured
+    """
+    import os
+
+    # Check if token is already cached and still valid
+    cached_token = get_cached_token_from_env()
+    if cached_token:
+        print("🔐 AUTH: Using existing cached OIDC token")
+        return cached_token
+
+    # Fetch new token if needed
+    token_data = fetch_oidc_token()
+    if token_data:
+        # Store in environment variable for reuse by subsequent processes
+        token_b64 = encode_token_for_env(token_data)
+        os.environ["FELDERA_PYTEST_OIDC_TOKEN"] = token_b64
+        print("🔐 AUTH: Token cached in environment for cross-process access")
+        return token_data
+    else:
+        print("🔐 AUTH: No OIDC configuration found, using fallback authentication")
+        return None
+
+
+def fetch_oidc_token() -> Optional[Dict[str, Any]]:
+    """
+    Fetch OIDC token using Resource Owner Password Grant flow.
+
+    This function is used by both pytest hooks and demo runners to ensure
+    consistent token fetching behavior across the entire test infrastructure.
+
+    Returns:
+        Dict containing access_token, expires_at, and cached_at if successful,
+        None if OIDC is not configured.
+    """
+    oidc_helper = get_oidc_test_helper()
+    if oidc_helper is None:
+        return None
+
+    print("🔐 AUTH: Fetching OIDC token")
+
+    try:
+        token_endpoint = oidc_helper.get_token_endpoint()
+        data = {
+            "grant_type": "password",
+            "username": oidc_helper.config.username,
+            "password": oidc_helper.config.password,
+            "client_id": oidc_helper.config.client_id,
+            "client_secret": oidc_helper.config.client_secret,
+            "scope": oidc_helper.config.scope,
+            "audience": "feldera-api",
+        }
+
+        headers = {
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Accept": "application/json",
+        }
+
+        response = requests.post(token_endpoint, data=data, headers=headers, timeout=30)
+
+        if not response.ok:
+            print(f"🔐 AUTH: ❌ Token request FAILED: {response.status_code}")
+            raise Exception(
+                f"Token request failed: {response.status_code} - {response.text}"
+            )
+
+        token_response = response.json()
+        print("🔐 AUTH: ✅ Token request SUCCESS!")
+
+        access_token = token_response["access_token"]
+        expires_in = token_response.get("expires_in", 3600)
+        expires_at = time.time() + expires_in
+
+        return {
+            "access_token": access_token,
+            "expires_at": expires_at,
+            "cached_at": time.time(),
+        }
+
+    except Exception as e:
+        print(f"🔐 AUTH: CRITICAL FAILURE - Failed to fetch OIDC token: {e}")
+        raise RuntimeError(
+            f"OIDC authentication is configured but token retrieval failed: {e}"
+        ) from e

feldera-0.192.0.dist-info/METADATA

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: feldera
+Version: 0.192.0
+Summary: The feldera python client
+Author-email: Feldera Team <dev@feldera.com>
+License: MIT
+Project-URL: Homepage, https://www.feldera.com
+Project-URL: Documentation, https://docs.feldera.com/python
+Project-URL: Repository, https://github.com/feldera/feldera
+Project-URL: Issues, https://github.com/feldera/feldera/issues
+Keywords: feldera,python
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Requires-Dist: pandas>=2.1.2
+Requires-Dist: typing-extensions
+Requires-Dist: numpy>=2.2.4
+Requires-Dist: pretty-errors
+Requires-Dist: ruff>=0.6.9
+Requires-Dist: PyJWT>=2.8.0
+
+# Feldera Python SDK
+
+The `feldera` Python package is the Python client for the Feldera HTTP API.
+
+The Python SDK documentation is available at: https://docs.feldera.com/python
+
+## Getting started
+
+### Installation
+
+```bash
+uv pip install feldera
+```
+
+### Example usage
+
+The Python client interacts with the API server of the Feldera instance.
+
+```python
+# File: example.py
+from feldera import FelderaClient, PipelineBuilder, Pipeline
+
+# Instantiate client
+client = FelderaClient()  # Default: http://localhost:8080 without authentication
+# client = FelderaClient(url="https://localhost:8080", api_key="apikey:...", requests_verify="/path/to/tls.crt")
+
+# (Re)create pipeline
+name = "example"
+sql = """
+CREATE TABLE t1 (i1 INT) WITH ('materialized' = 'true');
+CREATE MATERIALIZED VIEW v1 AS SELECT * FROM t1;
+"""
+print("(Re)creating pipeline...")
+pipeline = PipelineBuilder(client, name, sql).create_or_replace()
+pipeline.start()
+print(f"Pipeline status: {pipeline.status()}")
+pipeline.pause()
+print(f"Pipeline status: {pipeline.status()}")
+pipeline.stop(force=True)
+
+# Find existing pipeline
+pipeline = Pipeline.get(name, client)
+pipeline.start()
+print(f"Pipeline status: {pipeline.status()}")
+pipeline.stop(force=True)
+pipeline.clear_storage()
+```
+
+Run using:
+```bash
+uv run python example.py
+```
+
+### Environment variables
+
+Some default parameter values in the Python SDK can be overridden via environment variables.
+
+**Environment variables for `FelderaClient(...)`**
+
+```bash
+export FELDERA_HOST="https://localhost:8080"  # Overrides default for `url`
+export FELDERA_API_KEY="apikey:..."  # Overrides default for `api_key`
+
+# The following together override default for `requests_verify`
+# export FELDERA_TLS_INSECURE="false"  # If set to "1", "true" or "yes" (all case-insensitive), disables TLS certificate verification
+# export FELDERA_HTTPS_TLS_CERT="/path/to/tls.crt"  # Custom TLS certificate
+```
+
+**Environment variables for `PipelineBuilder(...)`**
+
+```bash
+export FELDERA_RUNTIME_VERSION="..."  # Overrides default for `runtime_version`
+```
+
+## Development
+
+Development assumes you have cloned the Feldera code repository.
+
+### Installation
+
+```bash
+cd python
+# Optional: create and activate virtual environment if you don't have one
+uv venv
+source .venv/bin/activate
+# Install in editable mode
+uv pip install -e .
+```
+
+### Formatting
+
+Formatting requires the `ruff` package: `uv pip install ruff`
+
+```bash
+cd python
+ruff check
+ruff format
+```
+
+### Tests
+
+Running the test requires the `pytest` package: `uv pip install pytest`
+
+```bash
+# All tests
+cd python
+uv run python -m pytest tests/
+
+# Specific tests directory
+uv run python -m pytest tests/platform/
+
+# Specific test file
+uv run python -m pytest tests/platform/test_pipeline_crud.py
+```
+
+For further information about the tests, please see `tests/README.md`.
+
+### Documentation
+
+Building documentation requires the `sphinx` package: `uv pip install sphinx`
+
+```bash
+cd python/docs
+sphinx-apidoc -o . ../feldera
+make html
+make clean  # Cleanup afterwards
+```
+
+### Installation from GitHub
+
+Latest `main` branch:
+```bash
+uv pip install git+https://github.com/feldera/feldera#subdirectory=python
+```
+
+Different branch (replace `BRANCH_NAME`):
+```bash
+uv pip install git+https://github.com/feldera/feldera@BRANCH_NAME#subdirectory=python
+```

feldera-0.192.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+feldera/__init__.py,sha256=ynWeVeHQ0Rsocte8P8Tso1l9z50uTCojY5jJxmgmVeQ,398
+feldera/_callback_runner.py,sha256=cTYbUxSILZDcTrjsWWPiTFdMDlQ9FPoWiMqPfnvQGDg,3226
+feldera/_helpers.py,sha256=wQX2d-C4an7xGXTg6VKo9VMBROXN7TUrS90LITFKQEw,3262
+feldera/enums.py,sha256=p11z4PgdcL4UQLnaPPnZBB_dHTBpNaJLqsT7qJ-R0QA,8835
+feldera/output_handler.py,sha256=VvDkPSfhllH3nEwg3nPkPk-uXGAXs0fdrZ0mrMqijJI,2229
+feldera/pipeline.py,sha256=dDKu-RPjFx0PMpZet0_vaZh4FfuGNoIKP4xB3eM59mo,51855
+feldera/pipeline_builder.py,sha256=qrXaQz0HGGNMo0wPJJSH-gooTVSlm1XODaK9643eoL8,4620
+feldera/runtime_config.py,sha256=w6rPkZyijca9jY1G8PKeqP8txXjnn5MPJYmM7B8iE3U,4602
+feldera/stats.py,sha256=YeDQwE_CixTMb2DjBCgt5jTaJAZRsrHtG-3pYuuII-8,5256
+feldera/testutils.py,sha256=_mfue_AZhedodNOdN_fNkFTBDiB_fqv8XuvvfkDPAIY,12343
+feldera/testutils_oidc.py,sha256=hv0IQAcVOt4uysWW3iE-5p46ZGfL1X7Vt7PjRefkXz8,12552
+feldera/rest/__init__.py,sha256=Eg-EKUU3RSTDcdxTR_7wNDnCly8VpXEzsZCQUmf-y2M,308
+feldera/rest/_helpers.py,sha256=thq5FBb9bmkbzuyXbRzHI2SxUCwyIN4poHsQyw2Hzr8,1139
+feldera/rest/_httprequests.py,sha256=-g9Luo8KwFNSb4tOxJTMTAosbUANqQmsLiuNNcrCyes,13760
+feldera/rest/config.py,sha256=fTn8gMLzxKB3CJYkQ6HdDH_gDktda3oFaXpEHVVZdSA,1740
+feldera/rest/errors.py,sha256=wKWwlL5WI3SVXC8rQTy3rS3wQ9Hjjn_EY7iRHXZFIVE,2341
+feldera/rest/feldera_client.py,sha256=JMXmY4fKwcPMOUtucgJ4Du9msEOhmm975t38N2pjh5E,45760
+feldera/rest/feldera_config.py,sha256=1pnGbLFMSLvp7Qh_OlPLALSKCSHIktNWKvx6gYU00U4,1374
+feldera/rest/pipeline.py,sha256=Q6TM44a7-SYRhLWbBGQMriCOcMRDk4WVKjfxd8vumys,3696
+feldera/rest/sql_table.py,sha256=qrw-YwMzx5T81zDefNO1KOx7EyypFz1vPwGBzSUB7kc,652
+feldera/rest/sql_view.py,sha256=hN12mPM0mvwLCIPYywpb12s9Hd2Ws31IlTMXPriMisw,644
+feldera/tests/test_datafusionize.py,sha256=NGriTaTWf_WnXFud1wmpFwLFa_-XGjfCh6La3dWc3QA,1337
+feldera-0.192.0.dist-info/METADATA,sha256=qXUiHPr6lgByIWQN0srw1WWt3NQxJmbZAglflvYAomo,4122
+feldera-0.192.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+feldera-0.192.0.dist-info/top_level.txt,sha256=fB6yTqrQiO6RCbY1xP2T_mpPoTjDFtJvkJJodiee7d0,8
+feldera-0.192.0.dist-info/RECORD,,

feldera-0.131.0.dist-info/METADATA

@@ -1,102 +0,0 @@
-Metadata-Version: 2.4
-Name: feldera
-Version: 0.131.0
-Summary: The feldera python client
-Author-email: Feldera Team <dev@feldera.com>
-License: MIT
-Project-URL: Homepage, https://www.feldera.com
-Project-URL: Documentation, https://docs.feldera.com/python
-Project-URL: Repository, https://github.com/feldera/feldera
-Project-URL: Issues, https://github.com/feldera/feldera/issues
-Keywords: feldera,python
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-Requires-Dist: requests
-Requires-Dist: pandas>=2.1.2
-Requires-Dist: typing-extensions
-Requires-Dist: numpy>=2.2.4
-Requires-Dist: pretty-errors
-Requires-Dist: ruff>=0.6.9
-
-# Feldera Python SDK
-
-Feldera Python is the Feldera SDK for Python developers.
-
-## Installation
-
-```bash
-uv pip install feldera
-```
-
-### Installing from Github
-
-```bash
-uv pip install git+https://github.com/feldera/feldera#subdirectory=python
-```
-
-Similarly, to install from a specific branch:
-
-```bash
-uv pip install git+https://github.com/feldera/feldera@{BRANCH_NAME}#subdirectory=python
-```
-
-Replace `{BRANCH_NAME}` with the name of the branch you want to install from.
-
-### Installing from Local Directory
-
-If you have cloned the Feldera repo, you can install the python SDK as follows:
-
-```bash
-# the Feldera Python SDK is present inside the python/ directory
-cd python
-# If you don't have a virtual environment, create one
-uv venv
-source .venv/activate
-# Install the SDK in editable mode
-uv pip install .
-```
-
-You also have to install the `pytest` module:
-
-```bash
-python3 -m pip install pytest
-```
-
-## Documentation
-
-The Python SDK documentation is available at
-[Feldera Python SDK Docs](https://docs.feldera.com/python).
-
-To build the html documentation run:
-
-Ensure that you have sphinx installed. If not, install it using `uv pip install sphinx`.
-
-Then run the following commands:
-
-```bash
-cd docs
-sphinx-apidoc -o . ../feldera
-make html
-```
-
-To clean the build, run `make clean`.
-
-## Linting and formatting
-
-Use [Ruff] to run the lint checks that will be executed by the
-precommit hook when a PR is submitted:
-
-```bash
-ruff check python/
-```
-
-To reformat the code in the same way as the precommit hook:
-
-```bash
-ruff format
-```
-
-[Ruff]: https://github.com/astral-sh/ruff

feldera-0.131.0.dist-info/RECORD

@@ -1,23 +0,0 @@
-feldera/__init__.py,sha256=EiY3bTj_mnfNhCGrZo6J__brfovIJ-YYAdy77PyaEoo,378
-feldera/_callback_runner.py,sha256=-2hYG70cEkvz4BiOfUTARaH-2Rlv0Qcz-ilvodgyK10,4797
-feldera/_helpers.py,sha256=rN0WuGSCCQlXWFMimZUQrgs-LJAfUo074d79sLElncQ,3023
-feldera/enums.py,sha256=MTHBojVANsdRnjbrzCyIOniDIUaH8nTYRfxB7QvajEE,9570
-feldera/output_handler.py,sha256=64J3ljhOaKIhxdjOKYi-BUz_HnMwROfmN8eE-btYygU,1930
-feldera/pipeline.py,sha256=yhUGKbagA--_D-vB8k8Mm9rZFhc7NbcpXh1OK8zPmBo,41742
-feldera/pipeline_builder.py,sha256=a750hp5SgTmlyrobTHFh1fTaK9Ed4A5qnXaYRctRM-8,4250
-feldera/runtime_config.py,sha256=MuYJPd5G_hnu_eDz4ge4BfYvSBSOvOEtv4NYh5sEwqU,4452
-feldera/stats.py,sha256=1qDlWhI-ORx3FktxH3b93mXWwtCOb4XuP0iJePHJTrE,5030
-feldera/rest/__init__.py,sha256=Eg-EKUU3RSTDcdxTR_7wNDnCly8VpXEzsZCQUmf-y2M,308
-feldera/rest/_helpers.py,sha256=q7jWInKp9IiIli8N5o31lDG3hNUbcsJqufZXYHG04ps,222
-feldera/rest/_httprequests.py,sha256=WbMeFodRV0ZHjA4LhcsbGUtVO-j8HQ98SRfgogOFA8A,8074
-feldera/rest/config.py,sha256=ag8Vh1Ul0wmo--3kvfwL_vUfu4CHESnn07xUuIJRbv4,1213
-feldera/rest/errors.py,sha256=b4i2JjrbSmej7jdko_FL8UeXklLKenSipwMT80jowaM,1720
-feldera/rest/feldera_client.py,sha256=Crt0WHBucC4YiRZi2M0GKQ1isdMjCm_Y-_fElOjoK3o,37095
-feldera/rest/feldera_config.py,sha256=1pnGbLFMSLvp7Qh_OlPLALSKCSHIktNWKvx6gYU00U4,1374
-feldera/rest/pipeline.py,sha256=Rmbflbwjvd86iZ5aSJ5b_bTSs6vgvEKQFwMZDtm0nxE,2835
-feldera/rest/sql_table.py,sha256=qrw-YwMzx5T81zDefNO1KOx7EyypFz1vPwGBzSUB7kc,652
-feldera/rest/sql_view.py,sha256=hN12mPM0mvwLCIPYywpb12s9Hd2Ws31IlTMXPriMisw,644
-feldera-0.131.0.dist-info/METADATA,sha256=wqRKF-g1N0ZL6INiAWfBxw5BVyZzBzcroTzoUXSAaN8,2368
-feldera-0.131.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-feldera-0.131.0.dist-info/top_level.txt,sha256=fB6yTqrQiO6RCbY1xP2T_mpPoTjDFtJvkJJodiee7d0,8
-feldera-0.131.0.dist-info/RECORD,,