polydata-client 0.1.0__tar.gz → 0.1.2__tar.gz

{polydata_client-0.1.0 → polydata_client-0.1.2}/CHANGELOG.md

@@ -5,6 +5,21 @@ All notable changes to the Polydata Python client will be documented in this fil
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.2] - 2026-07-23
+
+### Added
+
+- `create_or_update_view()` adds `allow_delete_then_create` option, which helps creators who change their column names.
+- `create_or_update_view()` also adds `dependent_views` which are dropped and rebuilt around the recreate.
+
+## [0.1.1] - 2026-01-27
+
+### Added
+
+- Added utilities to manage and update the cache
+  - `client.get_cache_stats()` Gets the Redis cache statistics.
+  - `client.clear_hub_cache()` Clears all cached data app pages for a Hub.
+
 ## [0.1.0] - 2026-01-16
 
 ### Added

{polydata_client-0.1.0 → polydata_client-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polydata-client
-Version: 0.1.0
+Version: 0.1.2
 Summary: Official Python client for Polydata API
 Author-email: Polydata <support@polydata.co>
 Maintainer-email: Polydata <support@polydata.co>

polydata_client-0.1.2/polydata/__init__.py

@@ -0,0 +1,8 @@
+from .client import PolydataClient
+from .common import (
+    create_or_update_endpoint,
+    create_or_update_ticker,
+    create_or_update_view,
+)
+
+__version__ = "0.1.0"

{polydata_client-0.1.0 → polydata_client-0.1.2}/polydata/client.py

@@ -266,6 +266,30 @@ class PolydataClient:
         )
         return True
 
+    def delete_data_view(self, hub_schema: str, view_name: str) -> bool:
+        """
+        Delete an existing data view using the API endpoint.
+
+        Drops both the physical Postgres view and its hub_views metadata
+        record.
+
+        Args:
+          hub_schema: The hub schema name
+          view_name: Name of the view to delete
+
+        Returns:
+          bool: True if successful, False otherwise
+        """
+        response = self.session.delete(
+            f"{self.base_url}/data/views/{hub_schema}/{view_name}",
+        )
+        self._handle_response(
+            response,
+            success_message=f"✓ Deleted data view: {view_name}",
+            error_context=f"Delete view {view_name}",
+        )
+        return True
+
     def get_data_view(
         self, hub_schema: str, view_name: str, include_data: bool = True
     ) -> pd.DataFrame:
@@ -664,3 +688,59 @@ class PolydataClient:
         df = pd.DataFrame(endpoints_list)
         print(f"✓ Retrieved {len(df)} endpoints for hub: {hub_schema}")
         return df
+
+    def get_cache_stats(self) -> dict:
+        """
+        Get Redis cache statistics.
+
+        Returns:
+        Dict: Cache statistics including total keys and memory usage
+
+        Raises:
+        Exception: If retrieval fails
+        """
+        response = self.session.get(f"{self.base_url}/cache/stats")
+        response_data = self._handle_response(
+            response, error_context="Get cache stats"
+        )
+        stats = response_data.get("data", {})
+        total_keys = stats.get("total_keys", 0)
+        print(f"✓ Cache stats retrieved: {total_keys} total keys")
+        return response_data
+
+    def clear_hub_cache(
+        self, hub_schema_name: str, entity_type: str = "data_app_page"
+    ) -> bool:
+        """
+        Clear all cached pages for a hub.
+
+        This is useful after uploading new data to ensure users see fresh data
+        without having to rebuild the entire app.
+
+        Args:
+        hub_schema_name: The hub schema name (e.g., "football_player_ratings")
+
+        Returns:
+        bool: True if successful, False otherwise
+
+        Raises:
+        Exception: If cache clear fails
+        """
+        response = self.session.delete(
+            f"{self.base_url}/cache/{hub_schema_name}/{entity_type}"
+        )
+        response_data = self._handle_response(
+            response,
+            success_message=f"✓ Cleared cache for hub: {hub_schema_name}",
+            error_context=f"Clear cache for hub {hub_schema_name}",
+        )
+
+        data = response_data.get("data", {})
+        deleted = data.get("deleted_count", 0)
+        total = data.get("total_pages_in_hub", 0)
+        cached = data.get("cached_pages", 0)
+        print(
+            f"  - Cleared {deleted} cached pages out of {cached} that were cached ({total} total pages)"
+        )
+
+        return True

{polydata_client-0.1.0 → polydata_client-0.1.2}/polydata/common.py

@@ -30,6 +30,8 @@ def create_or_update_view(
     view_name: str,
     view_query: str,
     hub_views_df: pd.DataFrame,
+    allow_delete_then_create: bool = False,
+    dependent_views: dict | None = None,
 ):
     """
     Create or update a data view based on whether it exists.
@@ -43,6 +45,20 @@ def create_or_update_view(
         view_name: View name (without schema prefix)
         view_query: SQL query for the view
         hub_views_df: DataFrame from client.list_data_views(hub_schema=hub_schema)
+        allow_delete_then_create: If True and an in-place update fails, fall back
+            to deleting and recreating the view. The update uses CREATE OR
+            REPLACE VIEW, which cannot rename or reorder existing columns; enable
+            this when a query change alters the view's column set. Off by default
+            because delete-then-create is more destructive. When False, an update
+            failure propagates unchanged.
+        dependent_views: Mapping of {view_name: view_query} for views that
+            depend on this view and would block its DROP. Only consulted on the
+            delete-then-create fallback: dependents are deleted first (in the
+            given order) so the main view can be dropped without CASCADE, then
+            recreated from the provided queries (in reverse order) once the
+            main view is rebuilt. Pass each dependent's current query if it is
+            unchanged — but note it must still be valid against the NEW main
+            view definition.
 
     Example:
         ```python
@@ -63,18 +79,51 @@ def create_or_update_view(
     """
     full_view_name = f"{hub_schema}.{view_name}"
 
-    if hub_view_exists(full_view_name, hub_views_df):
+    if not hub_view_exists(full_view_name, hub_views_df):
+        client.create_data_view(
+            hub_schema=hub_schema,
+            view_name=view_name,
+            view_query=view_query,
+        )
+        return
+
+    try:
         client.update_data_view(
             hub_schema=hub_schema,
             view_name=view_name,
             view_query=view_query,
         )
-    else:
+    except Exception:
+        if not allow_delete_then_create:
+            raise
+        # In-place update failed (e.g. the query renames/reorders columns,
+        # which CREATE OR REPLACE VIEW forbids). Rebuild from scratch:
+        # dependents are knocked out first so the plain (non-CASCADE) DROP of
+        # the main view succeeds, then restored once it is rebuilt.
+        dependent_views = dependent_views or {}
+        for dependent_name in dependent_views:
+            if hub_view_exists(f"{hub_schema}.{dependent_name}", hub_views_df):
+                client.delete_data_view(
+                    hub_schema=hub_schema,
+                    view_name=dependent_name,
+                )
+        client.delete_data_view(
+            hub_schema=hub_schema,
+            view_name=view_name,
+        )
         client.create_data_view(
             hub_schema=hub_schema,
             view_name=view_name,
             view_query=view_query,
         )
+        for dependent_name, dependent_query in reversed(
+            list(dependent_views.items())
+        ):
+            client.create_data_view(
+                hub_schema=hub_schema,
+                view_name=dependent_name,
+                view_query=dependent_query,
+            )
 
 
 def ticker_exists(ticker_name: str, hub_tickers_df: pd.DataFrame) -> bool:
@@ -161,6 +210,90 @@ def create_or_update_ticker(
         )
 
 
+def endpoint_exists(endpoint_name: str, hub_endpoints_df: pd.DataFrame) -> bool:
+    """
+    Check if an endpoint exists in the hub.
+
+    Args:
+        endpoint_name: Endpoint name to check
+        hub_endpoints_df: DataFrame from client.list_endpoints()
+
+    Returns:
+        True if the endpoint exists, False otherwise
+    """
+    if hub_endpoints_df.empty:
+        return False
+    return endpoint_name in hub_endpoints_df["hub_endpoint_name"].values
+
+
+def create_or_update_endpoint(
+    client,
+    hub_schema: str,
+    endpoint_name: str,
+    view_name: str,
+    params_config: dict,
+    hub_views_df: pd.DataFrame,
+    hub_endpoints_df: pd.DataFrame,
+    subscription_plan_type_name: str = "enterprise",
+):
+    """
+    Create or update an endpoint based on whether it exists.
+
+    Mirrors create_or_update_view: checks hub_endpoints_df and calls either
+    client.update_endpoint() or client.create_endpoint() (resolving the backing
+    view's id from hub_views_df) accordingly.
+
+    Args:
+        client: PolydataClient instance
+        hub_schema: Schema name
+        endpoint_name: Human-readable endpoint name
+        view_name: Backing view name (without schema prefix)
+        params_config: Endpoint params config (allowed_params/allowed_columns)
+        hub_views_df: DataFrame from client.list_data_views()
+        hub_endpoints_df: DataFrame from client.list_endpoints()
+        subscription_plan_type_name: Plan required when creating the endpoint
+            (default: "enterprise"); ignored on update
+
+    Example:
+        ```python
+        from polydata import PolydataClient
+        from polydata.common import create_or_update_endpoint
+
+        client = PolydataClient(api_key="...", base_url="...")
+        hub_views_df = client.list_data_views(hub_schema="my_schema")
+        hub_endpoints_df = client.list_endpoints(hub_schema="my_schema")
+
+        create_or_update_endpoint(
+            client=client,
+            hub_schema="my_schema",
+            endpoint_name="Available Leagues",
+            view_name="available_leagues",
+            params_config={...},
+            hub_views_df=hub_views_df,
+            hub_endpoints_df=hub_endpoints_df,
+        )
+        ```
+    """
+    if endpoint_exists(endpoint_name, hub_endpoints_df):
+        client.update_endpoint(
+            hub_schema=hub_schema,
+            hub_endpoint_name=endpoint_name,
+            params_config=params_config,
+        )
+    else:
+        full_view_name = f"{hub_schema}.{view_name}"
+        matching = hub_views_df[hub_views_df["view_name"] == full_view_name]
+        if matching.empty:
+            raise ValueError(f"Could not find view {full_view_name}")
+        client.create_endpoint(
+            hub_schema=hub_schema,
+            hub_view_id=int(matching.iloc[0]["hub_view_id"]),
+            hub_endpoint_name=endpoint_name,
+            subscription_plan_type_name=subscription_plan_type_name,
+            params_config=params_config,
+        )
+
+
 def upload_large_csv_in_batches(
     client,
     file_path: str,
@@ -299,7 +432,6 @@ def upload_large_csv_in_batches(
                 time.sleep(delay_between_chunks)
 
     finally:
-        # Clean up temporary directory
         try:
             os.rmdir(temp_dir)
             print("\n   🧹 Cleaned up temporary directory")

{polydata_client-0.1.0 → polydata_client-0.1.2}/polydata_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polydata-client
-Version: 0.1.0
+Version: 0.1.2
 Summary: Official Python client for Polydata API
 Author-email: Polydata <support@polydata.co>
 Maintainer-email: Polydata <support@polydata.co>

{polydata_client-0.1.0 → polydata_client-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "polydata-client"
-version = "0.1.0"
+version = "0.1.2"
 description = "Official Python client for Polydata API"
 readme = "README.md"
 requires-python = ">=3.8"

polydata_client-0.1.0/polydata/__init__.py

@@ -1,4 +0,0 @@
-from .client import PolydataClient
-from .common import create_or_update_ticker, create_or_update_view
-
-__version__ = "0.1.0"