dataquery-sdk 0.0.9__tar.gz → 0.1.1__tar.gz

{dataquery_sdk-0.0.9 → dataquery_sdk-0.1.1}/CHANGELOG.md

@@ -14,4 +14,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.0.8] - 2025-10-21
 - Made label and expression parameters optional in attribute api response 
 ## [0.0.9] - 2025-12-09
-- Perfomance optimizations
+- Performance optimizations
+## [0.1.0] - 2025-12-10
+- Time series data made optional
+## [0.1.1] - 2026-02-18
+- Non blocking IO

{dataquery_sdk-0.0.9 → dataquery_sdk-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataquery-sdk
-Version: 0.0.9
+Version: 0.1.1
 Summary: Python SDK for DATAQUERY Data API - Query, download, and check availability of economic data files
 Author-email: DATAQUERY SDK Team <support@dataquery.com>
 Project-URL: Homepage, https://github.com/dataquery/dataquery-sdk
@@ -279,7 +279,7 @@ DATAQUERY_CLIENT_SECRET=your_client_secret
 
 # Optional - API Endpoints
 DATAQUERY_BASE_URL=https://api-developer.jpmorgan.com
-DATAQUERY_FILES_BASE_URL=https://api-strm-gw01.jpmchase.com
+DATAQUERY_FILES_BASE_URL=https://api-dataquery.jpmchase.com
 
 # Optional - Performance
 DATAQUERY_MAX_RETRIES=3

{dataquery_sdk-0.0.9 → dataquery_sdk-0.1.1}/README.md

@@ -210,7 +210,7 @@ DATAQUERY_CLIENT_SECRET=your_client_secret
 
 # Optional - API Endpoints
 DATAQUERY_BASE_URL=https://api-developer.jpmorgan.com
-DATAQUERY_FILES_BASE_URL=https://api-strm-gw01.jpmchase.com
+DATAQUERY_FILES_BASE_URL=https://api-dataquery.jpmchase.com
 
 # Optional - Performance
 DATAQUERY_MAX_RETRIES=3

{dataquery_sdk-0.0.9 → dataquery_sdk-0.1.1}/dataquery/__init__.py

@@ -14,7 +14,7 @@ Quick Start:
 For more information, visit: https://github.com/dataquery/dataquery-sdk
 """
 
-__version__ = "0.0.9"
+__version__ = "0.1.1"
 __author__ = "DATAQUERY SDK Team"
 __email__ = "dataquery@jpmorgan.com"
 __license__ = "MIT"
@@ -43,7 +43,7 @@ from .connection_pool import (
 )
 
 # Core imports
-from .dataquery import DataQuery, setup_logging
+from .dataquery import DataQuery
 from .exceptions import (
     AuthenticationError,
     AvailabilityError,
@@ -52,6 +52,7 @@ from .exceptions import (
     DateRangeError,
     DownloadError,
     FileNotFoundError,
+    FileNotFoundInGroupError,
     FileTypeError,
     GroupNotFoundError,
     NetworkError,
@@ -124,7 +125,6 @@ from .utils import (
 __all__ = [
     # Core
     "DataQuery",
-    "setup_logging",
     # Models
     "ClientConfig",
     "Group",
@@ -153,6 +153,7 @@ __all__ = [
     "AvailabilityError",
     "GroupNotFoundError",
     "FileNotFoundError",
+    "FileNotFoundInGroupError",
     "DateRangeError",
     "FileTypeError",
     "WorkflowError",

{dataquery_sdk-0.0.9 → dataquery_sdk-0.1.1}/dataquery/auth.py

@@ -106,7 +106,6 @@ class TokenManager:
             grant_type=self.config.grant_type,
             client_id=self.config.client_id,
             client_secret=self.config.client_secret,
-            # scope removed
             aud=getattr(self.config, "aud", None),
         )
 

{dataquery_sdk-0.0.9 → dataquery_sdk-0.1.1}/dataquery/auto_download.py

@@ -166,7 +166,7 @@ class AutoDownloadManager:
                     self.stats["last_check_time"] = datetime.now()
 
                 except Exception as e:
-                    self.logger.error(f"Error in monitoring loop: {e}")
+                    self.logger.error("Error in monitoring loop: %s", e)
                     self.stats["errors"].append(
                         {
                             "timestamp": datetime.now().isoformat(),
@@ -180,7 +180,7 @@ class AutoDownloadManager:
                         try:
                             await self._safe_call_callback(self.error_callback, e)
                         except Exception as cb_error:
-                            self.logger.error(f"Error in error callback: {cb_error}")
+                            self.logger.error("Error in error callback: %s", cb_error)
 
                 # Wait for the specified interval or until stopped
                 try:
@@ -196,7 +196,7 @@ class AutoDownloadManager:
         except asyncio.CancelledError:
             self.logger.info("Monitoring loop cancelled")
         except Exception as e:
-            self.logger.error(f"Fatal error in monitoring loop: {e}")
+            self.logger.error("Fatal error in monitoring loop: %s", e)
         finally:
             self._running = False
 
@@ -230,28 +230,30 @@ class AutoDownloadManager:
             )
 
             # Build eligible downloads
-            eligible: List[tuple[str, str, str]] = []  # (file_id, date_str, file_key)
+            eligible: List[tuple[str, str, str]] = (
+                []
+            )  # (file_group_id, date_str, file_key)
             for item in available_files:
                 if not self._running:
                     break
-                file_id = item.get("file-group-id")
+                file_group_id = item.get("file-group-id")
                 date_str = item.get("file-datetime")
                 avail_flag = item.get("is-available")
                 is_available = bool(avail_flag)
-                if not file_id or not date_str or not is_available:
+                if not file_group_id or not date_str or not is_available:
                     continue
                 if self.file_filter and not self.file_filter(item):
                     continue
-                file_key = f"{file_id}_{date_str}"
+                file_key = f"{file_group_id}_{date_str}"
                 if file_key in self._downloaded_files:
                     continue
                 if self._failed_files.get(file_key, 0) >= self.max_retries:
                     continue
-                if self._file_exists_locally(file_id, date_str):
+                if self._file_exists_locally(file_group_id, date_str):
                     self.stats["files_skipped"] += 1
                     self._downloaded_files.add(file_key)
                     continue
-                eligible.append((file_id, date_str, file_key))
+                eligible.append((file_group_id, date_str, file_key))
 
             if not eligible:
                 return
@@ -272,13 +274,9 @@ class AutoDownloadManager:
             await asyncio.gather(*tasks, return_exceptions=True)
 
         except Exception as e:
-            self.logger.error(f"Error checking available files: {e}")
+            self.logger.error("Error checking available files: %s", e)
             raise
 
-    async def _process_file(self, file_info):
-        """Deprecated path; available-files flow supersedes this."""
-        return
-
     def _get_dates_to_check(self) -> List[str]:
         """Get list of dates to check for files."""
         if self.check_current_date_only:
@@ -293,11 +291,7 @@ class AutoDownloadManager:
                 dates.append(date.strftime("%Y%m%d"))
             return dates
 
-    async def _check_and_download_file_for_date(self, file_id: str, date_str: str):
-        """Deprecated path; available-files flow supersedes this."""
-        return
-
-    def _file_exists_locally(self, file_id: str, date_str: str) -> bool:
+    def _file_exists_locally(self, file_group_id: str, date_str: str) -> bool:
         """Check if file already exists in the destination directory."""
         # Look for files that might match this file_group_id and date
         # This is a heuristic approach since we don't know the exact filename
@@ -306,14 +300,14 @@ class AutoDownloadManager:
             if file_path.is_file():
                 filename = file_path.name
                 # Check if filename contains the file_group_id and date
-                if file_id in filename and date_str in filename:
+                if file_group_id in filename and date_str in filename:
                     return True
 
         return False
 
-    async def _download_file(self, file_id: str, date_str: str, file_key: str):
+    async def _download_file(self, file_group_id: str, date_str: str, file_key: str):
         """Download a file."""
-        self.logger.info(f"Downloading '{file_id}' for {date_str}...")
+        self.logger.info("Downloading '%s' for %s", file_group_id, date_str)
 
         # Create progress callback that updates statistics
         def progress_wrapper(progress: DownloadProgress):
@@ -331,11 +325,11 @@ class AutoDownloadManager:
                     else:
                         self.progress_callback(progress)
                 except Exception as e:
-                    self.logger.error(f"Error in progress callback: {e}")
+                    self.logger.error("Error in progress callback: %s", e)
 
         try:
             result = await self.client.download_file_async(
-                file_group_id=file_id,
+                file_group_id=file_group_id,
                 file_datetime=date_str,
                 options=self.download_options,
                 progress_callback=progress_wrapper,
@@ -353,7 +347,9 @@ class AutoDownloadManager:
                     succeeded = False
 
             if succeeded:
-                self.logger.info(f"Successfully downloaded '{file_id}' for {date_str}")
+                self.logger.info(
+                    "Successfully downloaded '%s' for %s", file_group_id, date_str
+                )
                 self.stats["files_downloaded"] += 1
                 self._downloaded_files.add(file_key)
                 # Accumulate total bytes if provided
@@ -376,13 +372,21 @@ class AutoDownloadManager:
                     else "No result"
                 )
                 self.logger.error(
-                    f"Download failed for '{file_id}' for {date_str}: {error_msg}"
+                    "Download failed for '%s' for %s: %s",
+                    file_group_id,
+                    date_str,
+                    error_msg,
                 )
                 self._failed_files[file_key] = self._failed_files.get(file_key, 0) + 1
                 self.stats["download_failures"] += 1
 
         except Exception as e:
-            self.logger.error(f"Exception downloading '{file_id}' for {date_str}: {e}")
+            self.logger.error(
+                "Exception downloading '%s' for %s: %s",
+                file_group_id,
+                date_str,
+                e,
+            )
             self._failed_files[file_key] = self._failed_files.get(file_key, 0) + 1
             self.stats["download_failures"] += 1
             raise
@@ -395,7 +399,7 @@ class AutoDownloadManager:
             else:
                 callback(*args, **kwargs)
         except Exception as e:
-            self.logger.error(f"Error in callback: {e}")
+            self.logger.error("Error in callback: %s", e)
 
     def get_stats(self) -> Dict[str, Any]:
         """Get auto-download statistics."""

{dataquery_sdk-0.0.9 → dataquery_sdk-0.1.1}/dataquery/client.py

@@ -5,6 +5,7 @@ Main client for the DATAQUERY SDK.
 import asyncio
 import socket
 import time
+from collections import OrderedDict
 from datetime import datetime
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
@@ -26,7 +27,7 @@ from .connection_pool import ConnectionPoolConfig, ConnectionPoolMonitor
 from .exceptions import (
     AuthenticationError,
     ConfigurationError,
-    FileNotFoundError,
+    FileNotFoundInGroupError,
     NetworkError,
     NotFoundError,
     RateLimitError,
@@ -158,8 +159,11 @@ class DataQueryClient:
         self.pool_monitor = ConnectionPoolMonitor(pool_config)
 
         # Initialize response cache for read-only operations
-        self._response_cache: Dict[str, tuple] = {}  # key -> (data, timestamp)
+        self._response_cache: OrderedDict[str, tuple] = (
+            OrderedDict()
+        )  # key -> (data, timestamp)
         self._cache_ttl = 300  # 5 minutes cache TTL
+        self._cache_max_size = 256  # Maximum cache entries (LRU eviction)
 
         self.logger.info(
             "Enhanced client components initialized",
@@ -278,6 +282,7 @@ class DataQueryClient:
         if cache_key in self._response_cache:
             data, timestamp = self._response_cache[cache_key]
             if time.time() - timestamp < self._cache_ttl:
+                self._response_cache.move_to_end(cache_key)
                 return data
             else:
                 # Remove expired entry
@@ -285,8 +290,12 @@ class DataQueryClient:
         return None
 
     def _set_cache(self, cache_key: str, data: Any) -> None:
-        """Store data in cache."""
+        """Store data in cache with LRU eviction."""
+        if cache_key in self._response_cache:
+            self._response_cache.move_to_end(cache_key)
         self._response_cache[cache_key] = (data, time.time())
+        while len(self._response_cache) > self._cache_max_size:
+            self._response_cache.popitem(last=False)
 
     def clear_cache(self) -> None:
         """Clear all cached responses."""
@@ -297,13 +306,7 @@ class DataQueryClient:
         if self.session is None:
             # Optimize timeout configuration
             timeout = aiohttp.ClientTimeout(
-                total=self.config.timeout,
-                connect=min(
-                    300.0, self.config.timeout * 0.5
-                ),  # 50% of total timeout for connect
-                sock_read=min(
-                    300.0, self.config.timeout * 0.5
-                ),  # 50% for read operations
+                total=self.config.timeout, connect=300.0, sock_read=self.config.timeout
             )
 
             # Optimize connector configuration for better performance
@@ -315,7 +318,6 @@ class DataQueryClient:
                 use_dns_cache=True,  # Enable DNS caching
                 ttl_dns_cache=300,  # 5 minutes DNS cache
                 family=socket.AF_UNSPEC,  # Allow both IPv4 and IPv6
-                ssl=False,  # Let aiohttp handle SSL context
                 local_addr=None,  # Let OS choose local address
                 force_close=False,  # Keep connections alive
             )
@@ -347,18 +349,6 @@ class DataQueryClient:
 
             self.session = aiohttp.ClientSession(**session_kwargs)  # type: ignore[arg-type]
 
-            # For compatibility tests expecting BasicAuth construction when proxy auth is configured
-            if self.config.proxy_enabled and self.config.has_proxy_credentials:
-                try:
-                    from aiohttp import BasicAuth
-
-                    _ = BasicAuth(
-                        login=self.config.proxy_username or "",
-                        password=self.config.proxy_password or "",
-                    )
-                except Exception:
-                    pass
-
             self.logger.info(
                 "Client connected with optimized configuration",
                 base_url=self.config.base_url,
@@ -550,19 +540,23 @@ class DataQueryClient:
             raise NetworkError("Failed to establish connection")
 
         try:
-            return await self.session.request(method, url, **kwargs)
-        except Exception:
-            # For proxy-auth related tests, construct BasicAuth so tests see it was used
-            if self.config.proxy_enabled and self.config.has_proxy_credentials:
-                try:
-                    from aiohttp import BasicAuth
+            response = await self.session.request(method, url, **kwargs)
 
-                    _ = BasicAuth(
-                        login=self.config.proxy_username or "",
-                        password=self.config.proxy_password or "",
-                    )
+            # Check for retryable server errors (5xx) - these should trigger retry
+            if response.status >= 500:
+                try:
+                    await response.text()
                 except Exception:
                     pass
+                raise NetworkError(
+                    f"Server error: {response.status}", status_code=response.status
+                )
+
+            return response
+        except NetworkError:
+            # Re-raise NetworkError to trigger retry
+            raise
+        except Exception:
             raise
 
     async def list_groups_async(self, limit: Optional[int] = None) -> List[Group]:
@@ -758,7 +752,7 @@ class DataQueryClient:
         file_list = await self.list_files_async(group_id, file_group_id)
 
         if not file_list.file_group_ids:
-            raise FileNotFoundError(file_group_id, group_id)
+            raise FileNotFoundInGroupError(file_group_id, group_id)
 
         return file_list.file_group_ids[0]
 
@@ -933,6 +927,15 @@ class DataQueryClient:
         temp_destination: Optional[Path] = None
         total_bytes: int = 0
 
+        # Check if range downloads are disabled - use single stream instead
+        if not self.config.enable_range_downloads:
+            return await self._download_file_single_stream(
+                file_group_id=file_group_id,
+                file_datetime=file_datetime,
+                options=options,
+                progress_callback=progress_callback,
+            )
+
         try:
             url = self._build_files_api_url("group/file/download")
 
@@ -959,18 +962,21 @@ class DataQueryClient:
                         progress_callback=progress_callback,
                     )
 
-                # If file is small (<10MB), prefer a single-stream download
-                try:
-                    ten_mb = 10 * 1024 * 1024
-                    if total_bytes and total_bytes < ten_mb:
-                        return await self._download_file_single_stream(
-                            file_group_id=file_group_id,
-                            file_datetime=file_datetime,
-                            options=options,
-                            progress_callback=progress_callback,
-                        )
-                except Exception:
-                    pass
+                    # If file is small (<10MB), prefer a single-stream download
+                ten_mb = 10 * 1024 * 1024
+                if total_bytes and total_bytes < ten_mb:
+                    return await self._download_file_single_stream(
+                        file_group_id=file_group_id,
+                        file_datetime=file_datetime,
+                        options=options,
+                        progress_callback=progress_callback,
+                    )
+
+                # Scale num_parts with file size for large files
+                if total_bytes > 500 * 1024 * 1024:  # >500MB
+                    num_parts = max(
+                        num_parts, min(total_bytes // (100 * 1024 * 1024), 20)
+                    )  # 1 part per 100MB, max 20
 
                 # Determine filename and destination
                 filename = get_filename_from_response(
@@ -1011,74 +1017,118 @@ class DataQueryClient:
                 start_time=datetime.now(),
             )
 
+            # Scale chunk size with file size for parallel parts
+            part_size = total_bytes // num_parts
+            chunk_size = options.chunk_size or 1048576  # 1MB default
+            if part_size > 100 * 1024 * 1024:  # Part >100MB: use 4MB chunks
+                chunk_size = max(chunk_size, 4 * 1024 * 1024)
+            elif part_size > 50 * 1024 * 1024:  # Part >50MB: use 2MB chunks
+                chunk_size = max(chunk_size, 2 * 1024 * 1024)
+
             # Progress callback optimization: track last callback state
             last_callback_bytes = 0
             last_callback_time = time.time()
             callback_threshold_bytes = 1024 * 1024  # 1MB
             callback_threshold_time = 0.5  # 0.5 seconds
 
+            # Per-part retry configuration
+            max_part_retries = options.max_retries
+            part_retry_delay = options.retry_delay
+
+            # For large file parts, disable the total timeout (which caps the entire
+            # transfer) but keep sock_read so stalled connections are detected.
+            range_timeout = aiohttp.ClientTimeout(
+                total=None,
+                sock_read=self.config.timeout,
+            )
+
             # Get the current event loop
             loop = asyncio.get_running_loop()
             bytes_lock = asyncio.Lock()
 
             async def download_range(start_byte: int, end_byte: int):
                 nonlocal bytes_downloaded, last_callback_bytes, last_callback_time
-                headers = {"Range": f"bytes={start_byte}-{end_byte}"}
-
-                # Open a separate file handle for this part to avoid lock contention
-                # Use 'r+b' to write to the existing file without truncating
-                with open(temp_destination, "r+b") as part_fh:
-                    # each part request
-                    async with await self._enter_request_cm(
-                        "GET", url, params=params, headers=headers
-                    ) as resp:
-                        await self._handle_response(resp)
-                        # Stream and write to correct offset
-                        current_pos = start_byte
-                        chunk_size = (
-                            options.chunk_size or 1048576
-                        )  # 1MB default for better performance
-
-                        async for chunk in resp.content.iter_chunked(chunk_size):
-                            # Write directly to file at correct position
-                            # Since we have a private handle, we don't need a file lock
-                            # But we should still run IO in executor to avoid blocking the loop
-                            await loop.run_in_executor(None, part_fh.seek, current_pos)
-                            await loop.run_in_executor(None, part_fh.write, chunk)
-
-                            chunk_len = len(chunk)
-                            current_pos += chunk_len
+                range_headers = {"Range": f"bytes={start_byte}-{end_byte}"}
+                part_bytes_written = (
+                    0  # Track bytes written by this part for retry rollback
+                )
 
+                for attempt in range(max_part_retries + 1):
+                    try:
+                        # On retry, subtract previously counted bytes for this part
+                        if attempt > 0 and part_bytes_written > 0:
                             async with bytes_lock:
-                                bytes_downloaded += chunk_len
+                                bytes_downloaded -= part_bytes_written
                                 progress.update_progress(bytes_downloaded)
+                            part_bytes_written = 0
+                            await asyncio.sleep(part_retry_delay * (2 ** (attempt - 1)))
+
+                        with open(temp_destination, "r+b") as part_fh:
+                            async with await self._enter_request_cm(
+                                "GET",
+                                url,
+                                params=params,
+                                headers=range_headers,
+                                timeout=range_timeout,
+                            ) as resp:
+                                await self._handle_response(resp)
+                                current_pos = start_byte
+
+                                def _seek_write(fh, pos, data):
+                                    fh.seek(pos)
+                                    fh.write(data)
+
+                                async for chunk in resp.content.iter_chunked(
+                                    chunk_size
+                                ):
+                                    await loop.run_in_executor(
+                                        None, _seek_write, part_fh, current_pos, chunk
+                                    )
+
+                                    chunk_len = len(chunk)
+                                    current_pos += chunk_len
+                                    part_bytes_written += chunk_len
+
+                                    # Update counters under lock, invoke callback outside
+                                    should_callback = False
+                                    async with bytes_lock:
+                                        bytes_downloaded += chunk_len
+                                        progress.update_progress(bytes_downloaded)
+
+                                        current_time = time.time()
+                                        bytes_diff = (
+                                            bytes_downloaded - last_callback_bytes
+                                        )
+                                        time_diff = current_time - last_callback_time
 
-                                # Optimized progress callback: only call every 1MB or 0.5s
-                                current_time = time.time()
-                                bytes_diff = bytes_downloaded - last_callback_bytes
-                                time_diff = current_time - last_callback_time
-
-                                should_callback = (
-                                    bytes_diff >= callback_threshold_bytes
-                                    or time_diff >= callback_threshold_time
-                                    or bytes_downloaded
-                                    == total_bytes  # Always callback on completion
-                                )
-
-                                if should_callback:
-                                    if progress_callback:
-                                        progress_callback(progress)
-                                    elif options.show_progress:
-                                        self.logger.info(
-                                            "Download progress",
-                                            file=file_group_id,
-                                            percentage=f"{progress.percentage:.1f}%",
-                                            downloaded=format_file_size(
-                                                bytes_downloaded
-                                            ),
+                                        should_callback = (
+                                            bytes_diff >= callback_threshold_bytes
+                                            or time_diff >= callback_threshold_time
+                                            or bytes_downloaded
+                                            == total_bytes  # Always callback on completion
                                         )
-                                    last_callback_bytes = bytes_downloaded
-                                    last_callback_time = current_time
+
+                                        if should_callback:
+                                            last_callback_bytes = bytes_downloaded
+                                            last_callback_time = current_time
+
+                                    if should_callback:
+                                        if progress_callback:
+                                            progress_callback(progress)
+                                        elif options.show_progress:
+                                            self.logger.info(
+                                                "Download progress",
+                                                file=file_group_id,
+                                                percentage=f"{progress.percentage:.1f}%",
+                                                downloaded=format_file_size(
+                                                    bytes_downloaded
+                                                ),
+                                            )
+                        # Part completed successfully
+                        return
+                    except Exception:
+                        if attempt == max_part_retries:
+                            raise  # Exhausted retries, propagate to gather
 
             # Run all parts concurrently
             await asyncio.gather(*(download_range(s, e) for s, e in ranges))
@@ -1099,10 +1149,7 @@ class DataQueryClient:
                 if temp_destination and temp_destination.exists():
                     try:
                         # Ensure any open handle is closed
-                        if (
-                            total_bytes
-                            and temp_destination.stat().st_size >= total_bytes
-                        ):
+                        if total_bytes and bytes_downloaded >= total_bytes:
                             if destination is None:
                                 destination = temp_destination.with_suffix("")
                             temp_destination.replace(destination)
@@ -1453,25 +1500,7 @@ class DataQueryClient:
             validate_date_format(start_date, "start-date")
         if end_date is not None:
             validate_date_format(end_date, "end-date")
-        """
-        Retrieve time-series data for explicit list of instruments and attributes using identifiers.
 
-        Args:
-            instruments: List of instrument identifiers
-            attributes: List of attribute identifiers
-            data: Data type (REFERENCE_DATA, NO_REFERENCE_DATA, ALL)
-            format: Response format (JSON)
-            start_date: Start date in YYYYMMDD or TODAY-Nx format
-            end_date: End date in YYYYMMDD or TODAY-Nx format
-            calendar: Calendar convention
-            frequency: Frequency convention
-            conversion: Conversion convention
-            nan_treatment: Missing data treatment
-            page: Optional page token for pagination
-
-        Returns:
-            TimeSeriesResponse containing the time series data
-        """
         params = {
             "instruments": instruments,
             "attributes": attributes,
@@ -2461,9 +2490,6 @@ class DataQueryClient:
             )
         )
 
-    # Note: download_multiple_files method removed as it's not part of the new API spec
-    # Use individual download_file calls for batch operations
-
     def list_available_files(
         self,
         group_id: str,