python-eia 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

eia/cli/catalog_cmd.py

@@ -0,0 +1,186 @@
+"""CLI command: browse the built-in data catalog and recipes."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+from eia.catalog import ROUTES, RECIPES
+
+catalog_app = typer.Typer(no_args_is_help=True)
+console = Console()
+
+
+@catalog_app.command("refresh")
+def catalog_refresh(
+    dry_run: bool = typer.Option(True, "--dry-run/--apply", help="Show what would change without modifying files"),
+):
+    """Discover new routes from the live EIA API and compare with the catalog."""
+    from eia.cli.app import get_client
+    from eia.catalog_manager import EIACatalogManager
+
+    client = get_client()
+    mgr = EIACatalogManager(client)
+    result = mgr.refresh(dry_run=dry_run)
+
+    if result.errors:
+        for err in result.errors:
+            console.print(f"[red]Error:[/red] {err}")
+
+    if result.updated:
+        console.print(f"\n[blue]Updated schema ({len(result.updated)}):[/blue]")
+        for r in result.updated:
+            console.print(f"  ~ {r}")
+
+    if result.added:
+        console.print(f"\n[green]New routes ({len(result.added)}):[/green]")
+        for r in result.added:
+            console.print(f"  + {r}")
+
+    if result.removed:
+        console.print(f"\n[yellow]Routes in catalog but not discovered ({len(result.removed)}):[/yellow]")
+        for r in result.removed:
+            console.print(f"  - {r}")
+
+    if not result.updated and not result.added:
+        console.print("[green]All routes up to date.[/green]")
+
+    console.print(f"\n[dim]Unchanged: {len(result.unchanged)} routes[/dim]")
+
+
+@catalog_app.command("routes")
+def catalog_routes(
+    query: Optional[str] = typer.Argument(None, help="Filter routes by keyword"),
+):
+    """List all cataloged data routes with descriptions."""
+    table = Table(title="EIA Data Routes", show_header=True, padding=(0, 1))
+    table.add_column("Route", style="cyan")
+    table.add_column("Name")
+    table.add_column("Frequency", style="green")
+
+    for route_path, info in sorted(ROUTES.items()):
+        if query:
+            q = query.lower()
+            if q not in route_path.lower() and q not in info.name.lower() and q not in info.description.lower():
+                continue
+        table.add_row(route_path, info.name, info.frequency)
+
+    console.print(table)
+
+
+@catalog_app.command("show")
+def catalog_show(
+    route: str = typer.Argument(..., help="Route path (e.g. natural-gas/move/expc)"),
+):
+    """Show detailed info for a specific route, including facets and hints."""
+    from eia.catalog import get_route
+
+    try:
+        info = get_route(route)
+    except KeyError as e:
+        console.print(f"[red]{e}[/red]")
+        raise typer.Exit(1)
+
+    console.print(f"\n[bold]{info.name}[/bold]")
+    console.print(f"  Route: {info.route}")
+    console.print(f"  {info.description}")
+    console.print(f"  Default frequency: {info.frequency}")
+
+    if info.notes:
+        console.print(f"\n  [yellow]Note:[/yellow] {info.notes}")
+
+    if info.start_period or info.end_period:
+        console.print(f"\n  Period: {info.start_period} → {info.end_period}")
+    if info.default_date_format:
+        console.print(f"  Date format: {info.default_date_format}")
+    if info.last_refreshed:
+        console.print(f"  [dim]Last refreshed: {info.last_refreshed}[/dim]")
+
+    if info.data_columns:
+        console.print(f"\n  [bold]Data Columns:[/bold]")
+        col_table = Table(show_header=True, padding=(0, 1))
+        col_table.add_column("Column", style="green")
+        col_table.add_column("Alias")
+        col_table.add_column("Units")
+        col_table.add_column("Aggregation")
+        for col in info.data_columns:
+            col_table.add_row(col.id, col.alias, col.units, col.aggregation_method)
+        console.print(col_table)
+
+    if info.frequencies:
+        console.print(f"\n  [bold]Frequencies:[/bold]")
+        freq_table = Table(show_header=True, padding=(0, 1))
+        freq_table.add_column("ID", style="green")
+        freq_table.add_column("Description")
+        freq_table.add_column("Query")
+        freq_table.add_column("Format")
+        for freq in info.frequencies:
+            freq_table.add_row(freq.id, freq.description, freq.query, freq.format)
+        console.print(freq_table)
+
+    for facet in info.facets:
+        console.print(f"\n  [cyan]Facet: {facet.id}[/cyan] — {facet.description}")
+        if facet.common_values:
+            table = Table(show_header=True, padding=(0, 1))
+            table.add_column("Value", style="green")
+            table.add_column("Description")
+            for val_id, val_desc in sorted(facet.common_values.items()):
+                table.add_row(val_id, val_desc)
+            console.print(table)
+
+    console.print()
+
+
+@catalog_app.command("recipes")
+def catalog_recipes(
+    query: Optional[str] = typer.Argument(None, help="Filter recipes by keyword"),
+):
+    """List pre-configured query recipes for common use cases."""
+    table = Table(title="EIA Recipes", show_header=True, padding=(0, 1))
+    table.add_column("ID", style="cyan")
+    table.add_column("Name")
+    table.add_column("Route", style="green")
+
+    for recipe_id, recipe in sorted(RECIPES.items()):
+        if query:
+            q = query.lower()
+            if q not in recipe_id.lower() and q not in recipe.name.lower() and q not in recipe.description.lower():
+                continue
+        table.add_row(recipe_id, recipe.name, recipe.route)
+
+    console.print(table)
+
+
+@catalog_app.command("recipe")
+def catalog_recipe(
+    recipe_id: str = typer.Argument(..., help="Recipe ID (e.g. lng-exports-europe)"),
+):
+    """Show detailed info for a specific recipe, including code examples."""
+    from eia.catalog import get_recipe
+
+    try:
+        recipe = get_recipe(recipe_id)
+    except KeyError as e:
+        console.print(f"[red]{e}[/red]")
+        raise typer.Exit(1)
+
+    console.print(f"\n[bold]{recipe.name}[/bold]")
+    console.print(f"  {recipe.description}")
+    console.print(f"  Route: {recipe.route}")
+    console.print(f"  Frequency: {recipe.frequency}")
+    console.print(f"  Facets: {recipe.facets}")
+
+    if recipe.notes:
+        console.print(f"\n  [yellow]Note:[/yellow] {recipe.notes}")
+
+    if recipe.cli_example:
+        console.print(Panel(recipe.cli_example, title="CLI Example", border_style="green"))
+
+    if recipe.python_example:
+        console.print(Panel(recipe.python_example, title="Python Example", border_style="blue"))
+
+    console.print()

eia/client.py

@@ -2,8 +2,10 @@ import requests
 import logging
 import pandas as pd
 import re
+from pathlib import Path
 from urllib.parse import urlparse, parse_qs
 from typing import (
+    TYPE_CHECKING,
     List,
     Dict,
     Optional,
@@ -16,9 +18,14 @@ from typing import (
     Protocol,
     runtime_checkable,
 )
+
+if TYPE_CHECKING:
+    from eia.catalog import RouteInfo
 import os
 from dataclasses import dataclass, field
 
+from eia.cache import CacheConfig, CacheStore, _facets_key
+
 # Configure logging
 logging.basicConfig(
     level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
@@ -87,9 +94,16 @@ class FacetInfo:
     # Store the route slug for potential API calls
     _route_slug: Optional[str] = field(default=None, repr=False)
     _client: Optional["EIAClient"] = field(default=None, repr=False)
+    _cached_values: Optional[List["FacetValue"]] = field(default=None, repr=False)
 
     def get_values(self) -> List[FacetValue]:
-        """Fetches and returns all possible values for this facet."""
+        """Returns all possible values for this facet.
+
+        Uses cached catalog values when available, otherwise fetches from the API.
+        """
+        if self._cached_values is not None:
+            return self._cached_values
+
         if not self._client or not self._route_slug:
             raise ValueError("Client and route slug must be set to fetch facet values.")
 
@@ -258,10 +272,17 @@ class FacetContainer(BaseFacetContainer):
 class Data:
     """Represents a data endpoint in the EIA API with its metadata and query capabilities."""
 
-    def __init__(self, client: "EIAClient", route: str, metadata: Dict[str, Any]):
+    def __init__(
+        self,
+        client: "EIAClient",
+        route: str,
+        metadata: Dict[str, Any],
+        cache: Optional[CacheStore] = None,
+    ):
         self._client = client
         self._route = route
         self._metadata = metadata
+        self._cache = cache
         self.id = metadata.get("id", route.split("/")[-1])
         self.name = metadata.get("name", "")
         self.description = metadata.get("description", "")
@@ -281,16 +302,26 @@ class Data:
             if isinstance(freq, dict) and "id" in freq
         ]
 
-        facet_dict = {
-            facet_data["id"]: FacetInfo(
-                id=facet_data["id"],
+        cached_facet_values = metadata.get("_facet_values", {})
+        facet_dict = {}
+        for facet_data in metadata.get("facets", []):
+            if not isinstance(facet_data, dict) or "id" not in facet_data:
+                continue
+            fid = facet_data["id"]
+            # Build cached FacetValue list from catalog values if available
+            cached_values = None
+            if fid in cached_facet_values:
+                cached_values = [
+                    FacetValue(id=vid, name=vname)
+                    for vid, vname in cached_facet_values[fid].items()
+                ]
+            facet_dict[fid] = FacetInfo(
+                id=fid,
                 description=facet_data.get("description"),
-                _route_slug=route,  # Pass route slug
-                _client=client,  # Pass client instance
+                _route_slug=route,
+                _client=client,
+                _cached_values=cached_values,
             )
-            for facet_data in metadata.get("facets", [])
-            if isinstance(facet_data, dict) and "id" in facet_data
-        }
         # Use FacetContainer for attribute-based access
         self.facets = FacetContainer(facet_dict)
 
@@ -327,8 +358,11 @@ class Data:
         paginate: bool = True,
     ) -> pd.DataFrame:
         """
-        Retrieves data from this endpoint, stores it and metadata internally,
-        and returns the data as a pandas DataFrame. Handles pagination automatically by default.
+        Retrieves data from this endpoint with transparent caching.
+
+        On first call, fetches from the API and persists to a local parquet
+        cache. Subsequent calls for the same (or overlapping) date range
+        return cached data instantly, only fetching gaps.
 
         Args:
             data_columns: List of data column IDs to retrieve. If None, all available columns are fetched.
@@ -342,6 +376,175 @@ class Data:
             output_format: Response format ('json' or 'xml'). Must be 'json' for DataFrame conversion.
             paginate: Whether to automatically paginate through results (default: True).
 
+        Returns:
+            A pandas DataFrame containing the requested data
+        """
+        # Cache requires start/end and must be json format
+        can_cache = (
+            self._cache is not None
+            and start is not None
+            and end is not None
+            and output_format == "json"
+            and offset is None
+            and length is None
+        )
+
+        if not can_cache:
+            return self._fetch(
+                data_columns=data_columns,
+                facets=facets,
+                frequency=frequency,
+                start=start,
+                end=end,
+                sort=sort,
+                length=length,
+                offset=offset,
+                output_format=output_format,
+                paginate=paginate,
+            )
+
+        # -- Cache path --
+        route = self._route.strip("/")
+        freq_key = frequency or "_default_"
+        fk = _facets_key(facets)
+
+        start_ts = pd.Timestamp(start)
+        end_ts = pd.Timestamp(end)
+
+        # 1. Read cached data
+        cached = self._cache.read(route, freq_key, fk, start_ts, end_ts)
+        logging.debug(
+            "Cache read: %d rows for %s/%s/%s [%s → %s]",
+            len(cached), route, freq_key, fk, start, end,
+        )
+
+        # 2. Find gaps
+        gaps = self._cache.find_gaps(cached, start_ts, end_ts)
+
+        if not gaps:
+            logging.info("Cache hit — no gaps for %s/%s/%s", route, freq_key, fk)
+            df = cached
+        else:
+            logging.info(
+                "Cache gaps: %s — fetching %d range(s)",
+                [(str(g.start), str(g.end)) for g in gaps],
+                len(gaps),
+            )
+            # 3. Fetch each gap (always fetch ALL columns for cache reuse)
+            fetched_parts = []
+            for gap in gaps:
+                # Format gap dates to match the endpoint's frequency
+                # Monthly endpoints expect YYYY-MM, daily expects YYYY-MM-DD, etc.
+                gap_start = self._format_gap_date(gap.start, frequency)
+                gap_end = self._format_gap_date(gap.end, frequency)
+                gap_df = self._fetch(
+                    data_columns=None,  # all columns → maximise cache reuse
+                    facets=facets,
+                    frequency=frequency,
+                    start=gap_start,
+                    end=gap_end,
+                    sort=sort,
+                    paginate=paginate,
+                )
+                if not gap_df.empty:
+                    fetched_parts.append(gap_df)
+
+            # 4. Concat cached + new, deduplicate, sort
+            all_parts = [cached] + fetched_parts if not cached.empty else fetched_parts
+            if all_parts:
+                df = pd.concat(all_parts, ignore_index=False)
+                # Ensure period is the index for dedup/sort
+                if "period" in df.columns and not isinstance(df.index, pd.DatetimeIndex):
+                    df = df.set_index("period")
+                    df.index.name = "period"
+                # For long-format data: deduplicate keeping latest fetch
+                # Group by index + all non-numeric columns to identify unique rows
+                facet_cols = [c for c in df.columns if c not in list(self.data_columns.keys())]
+                if facet_cols:
+                    df = df.reset_index()
+                    df = df.drop_duplicates(
+                        subset=["period"] + facet_cols,
+                        keep="last",
+                    )
+                    df = df.set_index("period")
+                else:
+                    df = df[~df.index.duplicated(keep="last")]
+                df = df.sort_index()
+            else:
+                df = pd.DataFrame()
+
+            # 5. Persist to cache
+            if not df.empty:
+                self._cache.write(route, freq_key, fk, df)
+
+        # 6. Filter to requested data_columns before returning
+        if data_columns and not df.empty:
+            existing = [c for c in data_columns if c in df.columns]
+            # Always keep facet columns alongside requested data columns
+            facet_cols = [c for c in df.columns if c not in list(self.data_columns.keys())]
+            keep = list(dict.fromkeys(facet_cols + existing))  # preserve order, dedupe
+            df = df[keep]
+
+        # Reset index so 'period' is a regular column (matches _fetch output)
+        if isinstance(df.index, pd.DatetimeIndex) and df.index.name == "period":
+            df = df.reset_index()
+
+        # Slice to requested range (handle tz-aware vs tz-naive)
+        if not df.empty and "period" in df.columns:
+            period_tz = getattr(df["period"].dt, "tz", None)
+            if period_tz is not None:
+                start_ts = start_ts.tz_localize(period_tz) if start_ts.tzinfo is None else start_ts.tz_convert(period_tz)
+                end_ts = end_ts.tz_localize(period_tz) if end_ts.tzinfo is None else end_ts.tz_convert(period_tz)
+            df = df[(df["period"] >= start_ts) & (df["period"] <= end_ts + pd.Timedelta(days=1))]
+
+        self.dataframe = df
+        return df
+
+    @staticmethod
+    def _format_gap_date(ts: "pd.Timestamp", frequency: Optional[str] = None) -> str:
+        """Format a gap timestamp to match the API frequency.
+
+        Monthly endpoints expect YYYY-MM, annual expects YYYY,
+        daily/hourly expect YYYY-MM-DD. Falls back to date string.
+        """
+        if frequency is not None:
+            freq_lower = frequency.lower()
+            if "annual" in freq_lower or "yearly" in freq_lower:
+                return str(ts.year)
+            if "month" in freq_lower:
+                return ts.strftime("%Y-%m")
+        # For daily, hourly, or unknown: use date string
+        return str(ts.date())
+
+    def _fetch(
+        self,
+        data_columns: Optional[List[str]] = None,
+        facets: Optional[Dict[str, Union[str, List[str]]]] = None,
+        frequency: Optional[str] = None,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+        sort: Optional[List[Dict[str, str]]] = None,
+        length: Optional[int] = None,
+        offset: Optional[int] = None,
+        output_format: Optional[Literal["json", "xml"]] = "json",
+        paginate: bool = True,
+    ) -> pd.DataFrame:
+        """
+        Fetches data from the EIA API (no caching). This is the original
+        get() logic extracted verbatim.
+
+        Args:
+            data_columns: List of data column IDs to retrieve. If None, all available columns are fetched.
+            facets: Dictionary of facet filters.
+            frequency: Data frequency ID (e.g., 'daily', 'monthly')
+            start: Start date/period
+            end: End date/period
+            sort: List of sort specifications
+            length: Maximum number of rows to return *if paginate=False*.
+            offset: Starting row offset for the first request.
+            output_format: Response format ('json' or 'xml').
+            paginate: Whether to automatically paginate through results.
+
         Returns:
             A pandas DataFrame containing the requested data
         """
@@ -349,6 +552,11 @@ class Data:
         column_ids_to_fetch = (
             data_columns if data_columns is not None else list(self.data_columns.keys())
         )
+        # Some endpoints report no data columns in metadata but DO return
+        # 'value' when explicitly requested. Fall back to ['value'] so the
+        # response includes actual data instead of metadata-only rows.
+        if not column_ids_to_fetch:
+            column_ids_to_fetch = ["value"]
 
         # Ensure output is json if we want a DataFrame
         if output_format != "json":
@@ -497,7 +705,8 @@ class Route:
 
             # If response doesn't contain routes, it means this endpoint has data
             if "routes" not in response_data:
-                self._data = Data(self._client, self._slug, response_data)
+                cache = getattr(self._client, "_cache", None)
+                self._data = Data(self._client, self._slug, response_data, cache=cache)
 
     def __getattr__(self, name: str) -> Union["Route", Any]:
         """
@@ -597,7 +806,13 @@ class EIAClient:
     )
 
     def __init__(
-        self, api_key: Optional[str] = None, session: Optional[requests.Session] = None
+        self,
+        api_key: Optional[str] = None,
+        session: Optional[requests.Session] = None,
+        *,
+        cache: bool = True,
+        cache_dir: Optional[Union[str, Path]] = None,
+        cache_recent_ttl: int = 48,
     ):
         """
         Initializes the EIAClient.
@@ -605,6 +820,9 @@ class EIAClient:
         Args:
             api_key: Your EIA API key. If None, it will try to read from the EIA_API_KEY environment variable.
             session: An optional requests.Session object for persistent connections.
+            cache: Enable/disable local parquet caching (default: True).
+            cache_dir: Custom cache directory. Defaults to ~/.cache/eia.
+            cache_recent_ttl: Hours before recent data is re-fetched (default: 48).
         """
         resolved_api_key = api_key or os.environ.get("EIA_API_KEY")
         if not resolved_api_key:
@@ -614,7 +832,21 @@ class EIAClient:
         self.api_key = resolved_api_key
         self.session = session or requests.Session()
         self.session.headers.update({"User-Agent": "Python EIAClient"})
-        logging.info("EIAClient initialized.")
+
+        # Cache setup
+        config = CacheConfig(
+            enabled=cache,
+            cache_dir=Path(cache_dir) if cache_dir else CacheConfig().cache_dir,
+            recent_ttl_hours=cache_recent_ttl,
+        )
+        self._cache: Optional[CacheStore] = CacheStore(config) if config.enabled else None
+
+        # Catalog manager (lazy-loads YAML on first access)
+        from eia.catalog_manager import EIACatalogManager
+
+        self.catalog = EIACatalogManager(self)
+
+        logging.info("EIAClient initialized (cache=%s).", "enabled" if cache else "disabled")
 
     def route(self, slug: str) -> Route:
         """
@@ -812,11 +1044,59 @@ class EIAClient:
 
         return response_data.get("response", {})
 
+    @staticmethod
+    def _route_info_to_metadata(route_info: "RouteInfo") -> Dict[str, Any]:
+        """Reconstruct API-style metadata dict from a RouteInfo with cached schema."""
+        metadata: Dict[str, Any] = {
+            "id": route_info.route.split("/")[-1],
+            "name": route_info.name,
+            "description": route_info.description,
+            "defaultFrequency": route_info.frequency,
+            "startPeriod": route_info.start_period,
+            "endPeriod": route_info.end_period,
+            "defaultDateFormat": route_info.default_date_format,
+        }
+
+        # Reconstruct frequency list
+        metadata["frequency"] = [
+            {
+                "id": f.id,
+                "description": f.description,
+                "query": f.query,
+                "format": f.format,
+            }
+            for f in route_info.frequencies
+        ]
+
+        # Reconstruct facets list, with cached values
+        metadata["facets"] = [
+            {"id": fh.id, "description": fh.description}
+            for fh in route_info.facets
+        ]
+        metadata["_facet_values"] = {
+            fh.id: fh.values
+            for fh in route_info.facets
+            if fh.values
+        }
+
+        # Reconstruct data dict (keyed by column id)
+        metadata["data"] = {
+            col.id: {
+                "units": col.units,
+                "aggregation-method": col.aggregation_method,
+                "alias": col.alias,
+            }
+            for col in route_info.data_columns
+        }
+
+        return metadata
+
     def get_data_endpoint(self, route_string: str) -> Data:
         """
         Directly retrieves the Data object for a known, complete data route string.
 
-        This allows bypassing the chained route navigation if the exact data route is known.
+        If the route exists in the catalog with cached API schema, uses that
+        to avoid an API metadata call. Otherwise falls back to fetching from the API.
 
         Args:
             route_string: The full route path to the data endpoint
@@ -829,9 +1109,19 @@ class EIAClient:
             EIAError: If the route does not exist or does not contain data.
         """
         route_string = route_string.strip("/")
-        logging.info(f"Directly accessing data endpoint metadata for: {route_string}")
 
-        # Fetch metadata for the route
+        # Try catalog first — skip API call if schema is cached
+        try:
+            route_info = self.catalog.get_route(route_string)
+            if route_info.data_columns:  # has cached schema
+                logging.info(f"Using cached catalog schema for: {route_string}")
+                metadata = self._route_info_to_metadata(route_info)
+                return Data(self, route_string, metadata, cache=self._cache)
+        except KeyError:
+            pass
+
+        # Fallback: hit API as before
+        logging.info(f"Directly accessing data endpoint metadata for: {route_string}")
         metadata = self.get_metadata(route_string)
 
         # Check if the route actually contains data (basic check)
@@ -857,7 +1147,7 @@ class EIAClient:
                 )
 
         # Instantiate and return the Data object
-        return Data(self, route_string, metadata)
+        return Data(self, route_string, metadata, cache=self._cache)
 
     def get_data_from_url(self, url: str) -> Dict[str, Any]:
         """

{python_eia-0.2.0.dist-info → python_eia-0.3.0.dist-info}/METADATA

@@ -1,12 +1,14 @@
 Metadata-Version: 2.4
 Name: python-eia
-Version: 0.2.0
+Version: 0.3.0
 Summary: A Python client for the U.S. Energy Information Administration (EIA) API v2
 Project-URL: Homepage, https://github.com/datons/python-eia
-Project-URL: Repository, https://github.com/datons/python-eia.git
+Project-URL: Repository, https://github.com/datons/python-eia
 Project-URL: Issues, https://github.com/datons/python-eia/issues
-Author-email: Jesus Lopez <jesus.lopez@datons.ai>
+Project-URL: Changelog, https://github.com/datons/python-eia/releases
+Author-email: Jesús López <jesus.lopez@datons.com>
 License-Expression: MIT
+Keywords: api,eia,electricity,energy,gas,oil,usa
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -20,6 +22,8 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: >=3.10
 Requires-Dist: pandas>=2.0
+Requires-Dist: pyarrow>=14.0
+Requires-Dist: pyyaml>=6.0
 Requires-Dist: requests>=2.31.0
 Requires-Dist: rich>=13.0
 Requires-Dist: typer>=0.9

python_eia-0.3.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+eia/__init__.py,sha256=nRNJ61aw4Y8PwNPAeyd27-cLdCPui4px0NntDFVdhvk,302
+eia/cache.py,sha256=R8TuAeBRLQW2IjfOwxRIVOuRpxhTsJ-utlkrwiBZLGo,13124
+eia/catalog.py,sha256=ISYEwTqcAOGGdSdGB0xC0mhdZj5bCO2Rovf9tNQvuHw,3910
+eia/catalog_manager.py,sha256=C6vNvKd3mfXj0EbrFaP6Y2nPd3x5TadiTtllIuAv6Fc,17446
+eia/client.py,sha256=C7izyxHkG62ZOEz4xIB8y-6ZmY3lg0-4eRay11-7SZM,44980
+eia/.agents/skills/eia/SKILL.md,sha256=UhGQCEnc38yCrog2NTkJGgiJokHX9skR38BXSkUe900,6294
+eia/cli/__init__.py,sha256=KCvyQU45hrJdWk3cra4mSHhW-u_5qFeQDfeE5KkDdN4,243
+eia/cli/_output.py,sha256=mhD1j5TyuHtw5BcjwUvHZ8-a87xpBPcEKtoPqMk0-pA,2618
+eia/cli/app.py,sha256=0Gch8mErIdlkkDuopoQ0XWrqI2m7WU_2AvgrcXoMC5g,1843
+eia/cli/cache_cmd.py,sha256=QUK-pPWVE86_6kgIjax0C0XivZDbazOb4R1XOmmhHBU,1563
+eia/cli/catalog_cmd.py,sha256=2piq4i46F4gq0jh51uEVi81iqXRm3lQ6P8_AdDSvodw,6533
+eia/cli/config.py,sha256=V_1wiXixPPIgVivIUDuAIS9aL9JcPu0qTshlVw9XDxQ,1657
+eia/cli/config_cmd.py,sha256=rUdnM-G3UHSoiBqfqxHXrRDdf7TFjAD6t8QLkuTJ0Ao,917
+eia/cli/exec_cmd.py,sha256=DkP8Bcm9RNjdC-D1E6k0skRJmGH1uRy8ALpyXFdr488,2776
+eia/cli/facets_cmd.py,sha256=urpbAtqsZKnNn-Hiqf8hR8tAyZCd9Hm7xJmSH3YONuo,2208
+eia/cli/get_cmd.py,sha256=MtHQ4yM_mHqAf7YdeYZUqL7lfd6w3-tSVMQPSHIVM94,3036
+eia/cli/meta_cmd.py,sha256=p8JObyCMG-VnPnMjKVYpVGTJh38SU_eQ9zp2x7ET6LA,3112
+eia/cli/routes_cmd.py,sha256=FuK90wjFklUb5KtUWDoufEYjc2b5KhE-KpsPWXc4iFM,2427
+python_eia-0.3.0.dist-info/METADATA,sha256=dvmN68A5trEUhSvHb58kXWS8MCWq4rZ0MoYz1ofqjn0,2257
+python_eia-0.3.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+python_eia-0.3.0.dist-info/entry_points.txt,sha256=oi4FTIzWeuoYDkpi_yywwRlEMBMLceEVJQKKD7zrRO0,36
+python_eia-0.3.0.dist-info/RECORD,,