jupyterlite-simple-cors-proxy 0.1.8__tar.gz → 0.1.10__tar.gz

{jupyterlite_simple_cors_proxy-0.1.8 → jupyterlite_simple_cors_proxy-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jupyterlite-simple-cors-proxy
-Version: 0.1.8
+Version: 0.1.10
 Summary: A simple CORS proxy utility with requests-like response
 Home-page: https://github.com/innovationOUtside/jupyterlite-simple-cors-proxy
 Author: Tony Hirst
@@ -65,3 +65,51 @@ The `robust_get_request()` will first try a simple request, then a proxied reque
 - Simple CORS proxy wrapper
 - Requests response object
 - Support for URL parameters
+
+## `fastf1` cors proxy
+
+A monkey patch for `fastf1` is provided as:
+
+```python
+import fast f1
+from jupyterlite_simple_cors_proxy.fastf1_proxy import enable_cors_proxy
+
+enable_cors_proxy(
+#    domains=["api.formula1.com", "livetiming.formula1.com"],
+#    debug=True,
+#    proxy_url="https://corsproxy.io/",
+)
+```
+
+## `CorsProxy` with cache facility
+
+Via `claude.ai`, the package is now further enriched.
+
+*Note that `pyodide` sqlite can't write to `/drive` so the cache path dir needs to be something like `/tmp` or a dir created on `/`.*
+
+*I'm not convinced the following works in `pyodide` and `xeus-python` yet - `requests-cache` dependency issues etc.*
+
+```python
+from simple_cors_proxy.proxy import CorsProxy
+
+# Create a cached proxy instance
+proxy = CorsProxy(use_cache=True, expire_after=3600)  # Cache for 1 hour
+
+# Use furl directly from your proxy instance
+file_like = proxy.furl('https://example.com/somefile.csv')
+
+#----
+import pandas as pd
+from simple_cors_proxy.cacheproxy import CorsProxy
+
+proxy = CorsProxy(use_cache=True)
+file_like = proxy.furl('https://example.com/data.csv')
+df = pd.read_csv(file_like)
+
+#----
+
+from simple_cors_proxy.proxy import create_cached_proxy
+
+proxy = create_cached_proxy(cache_name='my_cache', expire_after=86400)  # Cache for 1 day
+file_like = proxy.furl('https://example.com/somefile.csv')
+```

jupyterlite_simple_cors_proxy-0.1.10/README.md

@@ -0,0 +1,91 @@
+# jupyterlite-simple-cors-proxy
+Simple CORS proxy wrapper for making http requests from JupyterLite. Uses https://corsproxy.io/
+
+## Installation
+
+```bash
+pip install jupyterlite-simple-cors-proxy
+```
+
+## Usage
+
+```python
+from jupyterlite_simple_cors_proxy.proxy import cors_proxy_get, robust_get_request, furl, xurl
+
+# Set up
+url = "https://api.example.com/data"
+# Optional params
+params = {"key": "value"}
+
+# Get a cross-origin proxied url
+cross_origin_url = xurl(url) # xurl(url, params)
+
+# Get a file like object
+# (Make the request, then create a file like object
+# from the response)
+file_ob = furl(url) # furl(url, params)
+
+# Make a request
+response = cors_proxy_get(url, params)
+
+# Use like requests
+print(response.text)
+data = response.json()
+raw = response.content
+```
+
+The `robust_get_request()` will first try a simple request, then a proxied request: `robust_get_request(url, params)`
+
+## Features
+
+- Simple CORS proxy wrapper
+- Requests response object
+- Support for URL parameters
+
+## `fastf1` cors proxy
+
+A monkey patch for `fastf1` is provided as:
+
+```python
+import fast f1
+from jupyterlite_simple_cors_proxy.fastf1_proxy import enable_cors_proxy
+
+enable_cors_proxy(
+#    domains=["api.formula1.com", "livetiming.formula1.com"],
+#    debug=True,
+#    proxy_url="https://corsproxy.io/",
+)
+```
+
+## `CorsProxy` with cache facility
+
+Via `claude.ai`, the package is now further enriched.
+
+*Note that `pyodide` sqlite can't write to `/drive` so the cache path dir needs to be something like `/tmp` or a dir created on `/`.*
+
+*I'm not convinced the following works in `pyodide` and `xeus-python` yet - `requests-cache` dependency issues etc.*
+
+```python
+from simple_cors_proxy.proxy import CorsProxy
+
+# Create a cached proxy instance
+proxy = CorsProxy(use_cache=True, expire_after=3600)  # Cache for 1 hour
+
+# Use furl directly from your proxy instance
+file_like = proxy.furl('https://example.com/somefile.csv')
+
+#----
+import pandas as pd
+from simple_cors_proxy.cacheproxy import CorsProxy
+
+proxy = CorsProxy(use_cache=True)
+file_like = proxy.furl('https://example.com/data.csv')
+df = pd.read_csv(file_like)
+
+#----
+
+from simple_cors_proxy.proxy import create_cached_proxy
+
+proxy = create_cached_proxy(cache_name='my_cache', expire_after=86400)  # Cache for 1 day
+file_like = proxy.furl('https://example.com/somefile.csv')
+```

{jupyterlite_simple_cors_proxy-0.1.8 → jupyterlite_simple_cors_proxy-0.1.10}/jupyterlite_simple_cors_proxy/__init__.py

@@ -1,7 +1,7 @@
 # File: jupyterlite_simple_cors_proxy/__init__.py
-from .proxy import cors_proxy_get, robust_get_request, xurl, furl
+from .cacheproxy import cors_proxy_get, robust_get_request, xurl, furl
 
 # from .fastf1_proxy import enable_cors_proxy as fastf1_cors_proxy
 
-__version__ = "0.1.8"
+__version__ = "0.1.10"
 __all__ = ["cors_proxy_get", "robust_get_request", "xurl", "furl"]

jupyterlite_simple_cors_proxy-0.1.10/jupyterlite_simple_cors_proxy/cacheproxy.py

@@ -0,0 +1,83 @@
+# File: simple_cors_proxy/proxy.py
+from urllib.parse import urlencode, quote
+import requests
+import requests_cache
+import io
+import platform
+from typing import Optional, Union
+
+PLATFORM = platform.system().lower()
+
+class CorsProxy:
+    """CORS Proxy with optional caching support."""
+    
+    def __init__(self, use_cache: bool = False, **cache_kwargs):
+        """
+        Initialize the CORS proxy.
+        
+        Args:
+            use_cache: Whether to enable request caching
+            **cache_kwargs: Arguments passed to requests_cache.CachedSession
+                          (e.g., cache_name, backend, expire_after)
+        """
+        if use_cache:
+            # Set some sensible defaults if not provided
+            if 'cache_name' not in cache_kwargs:
+                cache_kwargs['cache_name'] = 'cors_proxy_cache'
+            if 'expire_after' not in cache_kwargs:
+                cache_kwargs['expire_after'] = 3600  # 1 hour default
+            self.session = requests_cache.CachedSession(**cache_kwargs)
+        else:
+            self.session = requests
+
+    def xurl(self, url: str, params: Optional[dict] = None, force: bool = False) -> str:
+        """Generate a proxied URL."""
+        if PLATFORM == "emscripten" or force:
+            if params:
+                url = f"{url}?{urlencode(params)}"
+            url = f"https://corsproxy.io/{quote(url)}"
+        return url
+
+    def furl(self, url: str, params: Optional[dict] = None, force: bool = False) -> io.BytesIO:
+        """Return file like object after calling the proxied URL."""
+        r = self.cors_proxy_get(url, params, force)
+        return io.BytesIO(r.content)
+
+    def cors_proxy_get(self, url: str, params: Optional[dict] = None, force: bool = False) -> requests.Response:
+        """
+        CORS proxy for GET resources with requests-like response.
+        
+        Args:
+            url: The URL to fetch
+            params: Query parameters to include
+            force: Force using the proxy even on non-emscripten platforms
+            
+        Returns:
+            A requests response object.
+        """
+        proxy_url = self.xurl(url, params, force)
+        return self.session.get(proxy_url)
+
+    def robust_get_request(self, url: str, params: Optional[dict] = None) -> requests.Response:
+        """
+        Try to make a simple request else fall back to a proxy.
+        """
+        try:
+            r = self.session.get(url, params=params)
+        except:
+            r = self.cors_proxy_get(url, params=params)
+        return r
+
+# Create default instance
+_default_proxy = CorsProxy()
+
+# Legacy function-based interface
+xurl = _default_proxy.xurl
+furl = _default_proxy.furl
+cors_proxy_get = _default_proxy.cors_proxy_get
+robust_get_request = _default_proxy.robust_get_request
+
+# Convenience function to create a cached proxy
+def create_cached_proxy(**cache_kwargs):
+    """Create a new CorsProxy instance with caching enabled."""
+    return CorsProxy(use_cache=True, **cache_kwargs)

{jupyterlite_simple_cors_proxy-0.1.8 → jupyterlite_simple_cors_proxy-0.1.10}/jupyterlite_simple_cors_proxy/proxy.py

@@ -4,17 +4,20 @@ import requests
 import io
 
 import platform
+
 PLATFORM = platform.system().lower()
 
+
 def xurl(url, params=None, force=False):
     """Generate a proxied URL."""
-    if PLATFORM=="emscripten" or force:
+    if PLATFORM == "emscripten" or force:
         if params:
             url = f"{url}?{urlencode(params)}"
         url = f"https://corsproxy.io/{quote(url)}"
 
     return url
 
+
 def furl(url, params=None, force=False):
     """Return file like object after calling the proxied URL."""
     r = cors_proxy_get(url, params, force)

{jupyterlite_simple_cors_proxy-0.1.8 → jupyterlite_simple_cors_proxy-0.1.10}/jupyterlite_simple_cors_proxy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jupyterlite-simple-cors-proxy
-Version: 0.1.8
+Version: 0.1.10
 Summary: A simple CORS proxy utility with requests-like response
 Home-page: https://github.com/innovationOUtside/jupyterlite-simple-cors-proxy
 Author: Tony Hirst
@@ -65,3 +65,51 @@ The `robust_get_request()` will first try a simple request, then a proxied reque
 - Simple CORS proxy wrapper
 - Requests response object
 - Support for URL parameters
+
+## `fastf1` cors proxy
+
+A monkey patch for `fastf1` is provided as:
+
+```python
+import fast f1
+from jupyterlite_simple_cors_proxy.fastf1_proxy import enable_cors_proxy
+
+enable_cors_proxy(
+#    domains=["api.formula1.com", "livetiming.formula1.com"],
+#    debug=True,
+#    proxy_url="https://corsproxy.io/",
+)
+```
+
+## `CorsProxy` with cache facility
+
+Via `claude.ai`, the package is now further enriched.
+
+*Note that `pyodide` sqlite can't write to `/drive` so the cache path dir needs to be something like `/tmp` or a dir created on `/`.*
+
+*I'm not convinced the following works in `pyodide` and `xeus-python` yet - `requests-cache` dependency issues etc.*
+
+```python
+from simple_cors_proxy.proxy import CorsProxy
+
+# Create a cached proxy instance
+proxy = CorsProxy(use_cache=True, expire_after=3600)  # Cache for 1 hour
+
+# Use furl directly from your proxy instance
+file_like = proxy.furl('https://example.com/somefile.csv')
+
+#----
+import pandas as pd
+from simple_cors_proxy.cacheproxy import CorsProxy
+
+proxy = CorsProxy(use_cache=True)
+file_like = proxy.furl('https://example.com/data.csv')
+df = pd.read_csv(file_like)
+
+#----
+
+from simple_cors_proxy.proxy import create_cached_proxy
+
+proxy = create_cached_proxy(cache_name='my_cache', expire_after=86400)  # Cache for 1 day
+file_like = proxy.furl('https://example.com/somefile.csv')
+```

{jupyterlite_simple_cors_proxy-0.1.8 → jupyterlite_simple_cors_proxy-0.1.10}/jupyterlite_simple_cors_proxy.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE
 README.md
 setup.py
 jupyterlite_simple_cors_proxy/__init__.py
+jupyterlite_simple_cors_proxy/cacheproxy.py
 jupyterlite_simple_cors_proxy/fastf1_proxy.py
 jupyterlite_simple_cors_proxy/proxy.py
 jupyterlite_simple_cors_proxy.egg-info/PKG-INFO

{jupyterlite_simple_cors_proxy-0.1.8 → jupyterlite_simple_cors_proxy-0.1.10}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="jupyterlite-simple-cors-proxy",
-    version="0.1.8",
+    version="0.1.10",
     packages=find_packages(),
     install_requires=[
         "requests",

jupyterlite_simple_cors_proxy-0.1.8/README.md

@@ -1,43 +0,0 @@
-# jupyterlite-simple-cors-proxy
-Simple CORS proxy wrapper for making http requests from JupyterLite. Uses https://corsproxy.io/
-
-## Installation
-
-```bash
-pip install jupyterlite-simple-cors-proxy
-```
-
-## Usage
-
-```python
-from jupyterlite_simple_cors_proxy.proxy import cors_proxy_get, robust_get_request, furl, xurl
-
-# Set up
-url = "https://api.example.com/data"
-# Optional params
-params = {"key": "value"}
-
-# Get a cross-origin proxied url
-cross_origin_url = xurl(url) # xurl(url, params)
-
-# Get a file like object
-# (Make the request, then create a file like object
-# from the response)
-file_ob = furl(url) # furl(url, params)
-
-# Make a request
-response = cors_proxy_get(url, params)
-
-# Use like requests
-print(response.text)
-data = response.json()
-raw = response.content
-```
-
-The `robust_get_request()` will first try a simple request, then a proxied request: `robust_get_request(url, params)`
-
-## Features
-
-- Simple CORS proxy wrapper
-- Requests response object
-- Support for URL parameters