dataquery-sdk 0.1.0__tar.gz → 0.1.2__tar.gz

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

@@ -14,6 +14,10 @@ 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 serires data made optional
+- Time series data made optional
+## [0.1.1] - 2026-02-18
+- Non blocking IO
+## [0.1.2] - 2026-02-18
+- File already exists status added 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataquery-sdk
-Version: 0.1.0
+Version: 0.1.2
 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
@@ -34,10 +34,8 @@ Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
-Requires-Dist: black>=23.0.0; extra == "dev"
-Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: ruff>=0.4.0; extra == "dev"
 Requires-Dist: mypy>=1.5.0; extra == "dev"
-Requires-Dist: isort>=5.12.0; extra == "dev"
 Requires-Dist: pre-commit>=3.0.0; extra == "dev"
 Requires-Dist: pip-audit>=2.7.0; extra == "dev"
 Requires-Dist: build>=1.3.0; extra == "dev"
@@ -53,10 +51,8 @@ Provides-Extra: all
 Requires-Dist: pytest>=7.0.0; extra == "all"
 Requires-Dist: pytest-asyncio>=0.21.0; extra == "all"
 Requires-Dist: pytest-cov>=4.0.0; extra == "all"
-Requires-Dist: black>=23.0.0; extra == "all"
-Requires-Dist: flake8>=6.0.0; extra == "all"
+Requires-Dist: ruff>=0.4.0; extra == "all"
 Requires-Dist: mypy>=1.5.0; extra == "all"
-Requires-Dist: isort>=5.12.0; extra == "all"
 Requires-Dist: pre-commit>=3.0.0; extra == "all"
 Requires-Dist: mkdocs>=1.5.0; extra == "all"
 Requires-Dist: mkdocs-material>=9.0.0; extra == "all"
@@ -279,7 +275,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.1.0 → dataquery_sdk-0.1.2}/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.1.0 → dataquery_sdk-0.1.2}/dataquery/__init__.py

@@ -14,9 +14,9 @@ Quick Start:
 For more information, visit: https://github.com/dataquery/dataquery-sdk
 """
 
-__version__ = "0.1.0"
+__version__ = "0.1.2"
 __author__ = "DATAQUERY SDK Team"
-__email__ = "dataquery@jpmorgan.com"
+__email__ = "dataquery_support@jpmorgan.com"
 __license__ = "MIT"
 __url__ = "https://github.com/jpmorganchase/dataquery-sdk"
 
@@ -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.1.0 → dataquery_sdk-0.1.2}/dataquery/auth.py

@@ -32,9 +32,7 @@ class TokenManager:
         # Prefer explicit token_storage_dir only when token storage is enabled,
         # else fallback to download_dir/.tokens if download_dir is provided.
         base_dir: Optional[Path] = None
-        token_storage_enabled = bool(
-            getattr(self.config, "token_storage_enabled", False)
-        )
+        token_storage_enabled = bool(getattr(self.config, "token_storage_enabled", False))
         token_storage_dir = getattr(self.config, "token_storage_dir", None)
         if token_storage_enabled and token_storage_dir:
             base_dir = Path(token_storage_dir)
@@ -97,16 +95,13 @@ class TokenManager:
 
         # Validate required fields
         if not self.config.client_id or not self.config.client_secret:
-            raise ConfigurationError(
-                "client_id and client_secret are required for OAuth"
-            )
+            raise ConfigurationError("client_id and client_secret are required for OAuth")
 
         # Create token request
         token_request = TokenRequest(
             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),
         )
 
@@ -143,9 +138,7 @@ class TokenManager:
                             status=response.status,
                             error=error_data,
                         )
-                        raise AuthenticationError(
-                            f"OAuth token request failed: {response.status}"
-                        )
+                        raise AuthenticationError(f"OAuth token request failed: {response.status}")
 
         except Exception as e:
             logger.error("Error getting OAuth token", error=str(e))
@@ -221,9 +214,7 @@ class TokenManager:
 
             # Convert timestamp back to datetime
             if "issued_at" in token_data:
-                token_data["issued_at"] = datetime.fromisoformat(
-                    token_data["issued_at"]
-                )
+                token_data["issued_at"] = datetime.fromisoformat(token_data["issued_at"])
 
             self.current_token = OAuthToken(**token_data)
 
@@ -233,9 +224,7 @@ class TokenManager:
                 self.current_token = None
                 return None
 
-            logger.info(
-                "Token loaded from storage", expires_at=self.current_token.expires_at
-            )
+            logger.info("Token loaded from storage", expires_at=self.current_token.expires_at)
             return self.current_token
 
         except Exception as e:
@@ -298,16 +287,8 @@ class TokenManager:
         return {
             "status": self.current_token.status.value,
             "token_type": self.current_token.token_type,
-            "issued_at": (
-                self.current_token.issued_at.isoformat()
-                if self.current_token.issued_at
-                else None
-            ),
-            "expires_at": (
-                self.current_token.expires_at.isoformat()
-                if self.current_token.expires_at
-                else None
-            ),
+            "issued_at": (self.current_token.issued_at.isoformat() if self.current_token.issued_at else None),
+            "expires_at": (self.current_token.expires_at.isoformat() if self.current_token.expires_at else None),
             "is_expired": self.current_token.is_expired,
             "has_refresh_token": self.current_token.refresh_token is not None,
         }

{dataquery_sdk-0.1.0 → dataquery_sdk-0.1.2}/dataquery/auto_download.py

@@ -121,8 +121,7 @@ class AutoDownloadManager:
         self._stop_event.clear()
 
         self.logger.info(
-            f"Starting auto-download for group '{self.group_id}' "
-            f"(interval: {self.interval_minutes} minutes)"
+            f"Starting auto-download for group '{self.group_id}' (interval: {self.interval_minutes} minutes)"
         )
 
         # Start the monitoring task
@@ -145,9 +144,7 @@ class AutoDownloadManager:
             try:
                 await asyncio.wait_for(self._task, timeout=5.0)
             except asyncio.TimeoutError:
-                self.logger.warning(
-                    "Monitoring task did not stop gracefully, cancelling..."
-                )
+                self.logger.warning("Monitoring task did not stop gracefully, cancelling...")
                 self._task.cancel()
                 try:
                     await self._task
@@ -166,7 +163,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,13 +177,11 @@ 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:
-                    await asyncio.wait_for(
-                        self._stop_event.wait(), timeout=self.interval_minutes * 60
-                    )
+                    await asyncio.wait_for(self._stop_event.wait(), timeout=self.interval_minutes * 60)
                     # If we reach here, stop was requested
                     break
                 except asyncio.TimeoutError:
@@ -196,7 +191,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
 
@@ -220,38 +215,34 @@ class AutoDownloadManager:
             )
 
             if not isinstance(available_files, list) or not available_files:
-                self.logger.debug(
-                    f"No available files for group '{self.group_id}' between {start_date} and {end_date}"
-                )
+                self.logger.debug(f"No available files for group '{self.group_id}' between {start_date} and {end_date}")
                 return
 
-            self.logger.debug(
-                f"Found {len(available_files)} available file entries for group '{self.group_id}'"
-            )
+            self.logger.debug(f"Found {len(available_files)} available file entries for group '{self.group_id}'")
 
             # 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
@@ -265,20 +256,13 @@ class AutoDownloadManager:
                 async with semaphore:
                     await self._download_file(fid, dstr, fkey)
 
-            tasks = [
-                asyncio.create_task(worker(fid, dstr, fkey))
-                for fid, dstr, fkey in eligible
-            ]
+            tasks = [asyncio.create_task(worker(fid, dstr, fkey)) for fid, dstr, fkey in eligible]
             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 +277,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 +286,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,17 +311,18 @@ 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,
             )
 
             succeeded = False
+            already_exists = False
             if result is not None and getattr(result, "status", None) is not None:
                 try:
                     from .models import (  # import inside to avoid cycles in some tools
@@ -349,19 +330,29 @@ class AutoDownloadManager:
                     )
 
                     succeeded = result.status == DownloadStatus.COMPLETED
+                    already_exists = result.status == DownloadStatus.ALREADY_EXISTS
                 except Exception:
                     succeeded = False
 
-            if succeeded:
-                self.logger.info(f"Successfully downloaded '{file_id}' for {date_str}")
+            if already_exists:
+                self.logger.info(
+                    "File already exists for '%s' for %s, skipping",
+                    file_group_id,
+                    date_str,
+                )
+                self.stats["files_skipped"] += 1
+                self._downloaded_files.add(file_key)
+                if file_key in self._failed_files:
+                    del self._failed_files[file_key]
+
+            elif succeeded:
+                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
                 try:
                     if getattr(result, "file_size", None):
-                        self.stats["total_bytes_downloaded"] += (
-                            int(result.file_size) or 0
-                        )
+                        self.stats["total_bytes_downloaded"] += int(result.file_size) or 0
                 except Exception:
                     pass
 
@@ -370,19 +361,23 @@ class AutoDownloadManager:
                     del self._failed_files[file_key]
 
             else:
-                error_msg = (
-                    getattr(result, "error_message", "Unknown error")
-                    if result
-                    else "No result"
-                )
+                error_msg = getattr(result, "error_message", "Unknown error") if result 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 +390,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.1.0 → dataquery_sdk-0.1.2}/dataquery/cli.py

@@ -11,18 +11,14 @@ from dataquery import DataQuery
 
 def create_parser() -> argparse.ArgumentParser:
     """Create the top-level CLI parser with subcommands."""
-    parser = argparse.ArgumentParser(
-        description="Command Line Interface for the DataQuery SDK"
-    )
+    parser = argparse.ArgumentParser(description="Command Line Interface for the DataQuery SDK")
     parser.add_argument("--env-file", type=str, default=None, help="Path to .env file")
     subparsers = parser.add_subparsers(dest="command")
 
     # groups
     p_groups = subparsers.add_parser("groups", help="List or search groups")
     p_groups.add_argument("--json", action="store_true", help="Output JSON")
-    p_groups.add_argument(
-        "--limit", type=int, default=None, help="Limit number of results"
-    )
+    p_groups.add_argument("--limit", type=int, default=None, help="Limit number of results")
     p_groups.add_argument("--search", type=str, default=None, help="Search keywords")
 
     # files
@@ -43,22 +39,14 @@ def create_parser() -> argparse.ArgumentParser:
     p_dl.add_argument("--file-group-id", default=None)
     p_dl.add_argument("--file-datetime", default=None)
     p_dl.add_argument("--destination", type=str, default=None)
-    p_dl.add_argument(
-        "--watch", action="store_true", help="Watch a group for new files"
-    )
+    p_dl.add_argument("--watch", action="store_true", help="Watch a group for new files")
     p_dl.add_argument("--group-id", default=None, help="Required with --watch")
     p_dl.add_argument("--json", action="store_true")
-    p_dl.add_argument(
-        "--num-parts", type=int, default=5, help="Number of parallel parts"
-    )
-    p_dl.add_argument(
-        "--chunk-size", type=int, default=None, help="Chunk size in bytes"
-    )
+    p_dl.add_argument("--num-parts", type=int, default=5, help="Number of parallel parts")
+    p_dl.add_argument("--chunk-size", type=int, default=None, help="Chunk size in bytes")
 
     # download-group
-    p_dlg = subparsers.add_parser(
-        "download-group", help="Download all files in a group"
-    )
+    p_dlg = subparsers.add_parser("download-group", help="Download all files in a group")
     p_dlg.add_argument("--group-id", required=True)
     p_dlg.add_argument("--start-date", required=True)
     p_dlg.add_argument("--end-date", required=True)
@@ -101,9 +89,7 @@ async def cmd_groups(args: argparse.Namespace) -> int:
             for g in items:
                 try:
                     d = g.model_dump()
-                    print(
-                        f"{d.get('group_id') or d.get('group-id')}\t{d.get('group_name') or d.get('group-name')}"
-                    )
+                    print(f"{d.get('group_id') or d.get('group-id')}\t{d.get('group_name') or d.get('group-name')}")
                 except Exception:
                     print(str(g))
     return 0
@@ -125,9 +111,7 @@ async def cmd_files(args: argparse.Namespace) -> int:
             for f in files:
                 try:
                     d = f.model_dump()
-                    print(
-                        f"{d.get('file_group_id') or d.get('file-group-id')}\t{d.get('file_type')}"
-                    )
+                    print(f"{d.get('file_group_id') or d.get('file-group-id')}\t{d.get('file_type')}")
                 except Exception:
                     print(str(f))
     return 0
@@ -135,9 +119,7 @@ async def cmd_files(args: argparse.Namespace) -> int:
 
 async def cmd_availability(args: argparse.Namespace) -> int:
     async with DataQuery(args.env_file) as dq:
-        avail = await dq.check_availability_async(
-            args.file_group_id, args.file_datetime
-        )
+        avail = await dq.check_availability_async(args.file_group_id, args.file_datetime)
         if args.json:
             try:
                 print(json.dumps(getattr(avail, "model_dump")(), indent=2))
@@ -210,9 +192,7 @@ async def cmd_download_group(args: argparse.Namespace) -> int:
         if args.json:
             print(json.dumps(results, indent=2))
         else:
-            print(
-                f"Downloaded {results.get('successful', 0)} files to {args.destination}"
-            )
+            print(f"Downloaded {results.get('successful', 0)} files to {args.destination}")
             if results.get("failed", 0) > 0:
                 print(f"Failed: {results.get('failed', 0)}")
     return 0
@@ -221,9 +201,7 @@ async def cmd_download_group(args: argparse.Namespace) -> int:
 def cmd_config_show(args: argparse.Namespace) -> int:
     from dataquery.config import EnvConfig
 
-    EnvConfig.create_client_config(
-        env_file=Path(args.env_file) if getattr(args, "env_file", None) else None
-    )
+    EnvConfig.create_client_config(env_file=Path(args.env_file) if getattr(args, "env_file", None) else None)
     print("Configuration loaded")
     return 0