readabs 0.0.2__py3-none-any.whl

readabs/__init__.py

@@ -0,0 +1,4 @@
+from . import readabs
+from .readabs import *
+
+__version__ = "0.0.2"

readabs/abs_catalogue_map.py

@@ -0,0 +1,56 @@
+"""Catalogue map for ABS data."""
+
+from io import StringIO
+
+from pandas import DataFrame, read_csv
+def catalogue_map() -> DataFrame:
+    """Return the catalogue map."""
+
+    csv = """Catalogue ID,Theme,Parent Topic,Topic,URL,Status
+1364.0.15.003,Economy,National Accounts,Modellers Database,https://www.abs.gov.au/statistics/economy/national-accounts/modellers-database/latest-release, 
+3101.0,People,Population,National State And Territory Population,https://www.abs.gov.au/statistics/people/population/national-state-and-territory-population/latest-release, 
+3222.0,People,Population,Population Projections Australia,https://www.abs.gov.au/statistics/people/population/population-projections-australia/latest-release, 
+3401.0,Industry,Tourism And Transport,Overseas Arrivals And Departures Australia,https://www.abs.gov.au/statistics/industry/tourism-and-transport/overseas-arrivals-and-departures-australia/latest-release, 
+5204.0,Economy,National Accounts,Australian System National Accounts,https://www.abs.gov.au/statistics/economy/national-accounts/australian-system-national-accounts/latest-release, 
+5206.0,Economy,National Accounts,Australian National Accounts National Income Expenditure And Product,https://www.abs.gov.au/statistics/economy/national-accounts/australian-national-accounts-national-income-expenditure-and-product/latest-release, 
+5220.0,Economy,National Accounts,Australian National Accounts State Accounts,https://www.abs.gov.au/statistics/economy/national-accounts/australian-national-accounts-state-accounts/latest-release, 
+5232.0,Economy,National Accounts,Australian National Accounts Finance And Wealth,https://www.abs.gov.au/statistics/economy/national-accounts/australian-national-accounts-finance-and-wealth/latest-release, 
+5232.0.55.001,Economy,Finance,Assets And Liabilities Australian Securitisers,https://www.abs.gov.au/statistics/economy/finance/assets-and-liabilities-australian-securitisers/latest-release, 
+5302.0,Economy,International Trade,Balance Payments And International Investment Position Australia,https://www.abs.gov.au/statistics/economy/international-trade/balance-payments-and-international-investment-position-australia/latest-release, 
+5368.0,Economy,International Trade,International Trade Goods And Services Australia,https://www.abs.gov.au/statistics/economy/international-trade/international-trade-goods-and-services-australia/latest-release, 
+5368.0.55.024,Economy,International Trade,International Merchandise Trade Preliminary Australia,https://www.abs.gov.au/statistics/economy/international-trade/international-merchandise-trade-preliminary-australia/latest-release, 
+5601.0,Economy,Finance,Lending Indicators,https://www.abs.gov.au/statistics/economy/finance/lending-indicators/latest-release, 
+5625.0,Economy,Business Indicators,Private New Capital Expenditure And Expected Expenditure Australia,https://www.abs.gov.au/statistics/economy/business-indicators/private-new-capital-expenditure-and-expected-expenditure-australia/latest-release, 
+5655.0,Economy,Finance,Managed Funds Australia,https://www.abs.gov.au/statistics/economy/finance/managed-funds-australia/latest-release, 
+5676.0,Economy,Business Indicators,Business Indicators Australia,https://www.abs.gov.au/statistics/economy/business-indicators/business-indicators-australia/latest-release, 
+5681.0,Economy,Business Indicators,Monthly Business Turnover Indicator,https://www.abs.gov.au/statistics/economy/business-indicators/monthly-business-turnover-indicator/latest-release, 
+5682.0,Economy,Finance,Monthly Household Spending Indicator,https://www.abs.gov.au/statistics/economy/finance/monthly-household-spending-indicator/latest-release, 
+6202.0,Labour,Employment And Unemployment,Labour Force Australia,https://www.abs.gov.au/statistics/labour/employment-and-unemployment/labour-force-australia/latest-release, 
+6150.0.55.003,Labour,Labour Accounts,Labour Account Australia,https://www.abs.gov.au/statistics/labour/labour-accounts/labour-account-australia/latest-release, 
+6248.0.55.002,Labour,Employment And Unemployment,Public Sector Employment And Earnings,https://www.abs.gov.au/statistics/labour/employment-and-unemployment/public-sector-employment-and-earnings/latest-release, 
+6291.0.55.001,Labour,Employment And Unemployment,Labour Force Australia Detailed,https://www.abs.gov.au/statistics/labour/employment-and-unemployment/labour-force-australia-detailed/latest-release, 
+6302.0,Labour,Earnings And Working Conditions,Average Weekly Earnings Australia,https://www.abs.gov.au/statistics/labour/earnings-and-working-conditions/average-weekly-earnings-australia/latest-release, 
+6321.0.55.001,Labour,Earnings And Working Conditions,Industrial Disputes Australia,https://www.abs.gov.au/statistics/labour/earnings-and-working-conditions/industrial-disputes-australia/latest-release, 
+6345.0,Economy,Price Indexes And Inflation,Wage Price Index Australia,https://www.abs.gov.au/statistics/economy/price-indexes-and-inflation/wage-price-index-australia/latest-release, 
+6354.0,Labour,Jobs,Job Vacancies Australia,https://www.abs.gov.au/statistics/labour/jobs/job-vacancies-australia/latest-release, 
+6401.0,Economy,Price Indexes And Inflation,Consumer Price Index Australia,https://www.abs.gov.au/statistics/economy/price-indexes-and-inflation/consumer-price-index-australia/latest-release, 
+6416.0,Economy,Price Indexes And Inflation,Residential Property Price Indexes Eight Capital Cities,https://www.abs.gov.au/statistics/economy/price-indexes-and-inflation/residential-property-price-indexes-eight-capital-cities/latest-release,Ceased
+6427.0,Economy,Price Indexes And Inflation,Producer Price Indexes Australia,https://www.abs.gov.au/statistics/economy/price-indexes-and-inflation/producer-price-indexes-australia/latest-release, 
+6432.0,Economy,Price Indexes And Inflation,Total Value Dwellings,https://www.abs.gov.au/statistics/economy/price-indexes-and-inflation/total-value-dwellings/latest-release, 
+6457.0,Economy,Price Indexes And Inflation,International Trade Price Indexes Australia,https://www.abs.gov.au/statistics/economy/price-indexes-and-inflation/international-trade-price-indexes-australia/latest-release, 
+6467.0,Economy,Price Indexes And Inflation,Selected Living Cost Indexes Australia,https://www.abs.gov.au/statistics/economy/price-indexes-and-inflation/selected-living-cost-indexes-australia/latest-release, 
+6484.0,Economy,Price Indexes And Inflation,Monthly Consumer Price Index Indicator,https://www.abs.gov.au/statistics/economy/price-indexes-and-inflation/monthly-consumer-price-index-indicator/latest-release, 
+7215.0,Industry,Agriculture,Livestock Products Australia,https://www.abs.gov.au/statistics/industry/agriculture/livestock-products-australia/latest-release, 
+7218.0.55.001,Industry,Agriculture,Livestock And Meat Australia,https://www.abs.gov.au/statistics/industry/agriculture/livestock-and-meat-australia/latest-release,Ceased
+8155.0,Industry,Industry Overview,Australian Industry,https://www.abs.gov.au/statistics/industry/industry-overview/australian-industry/latest-release, 
+8165.0,Economy,Business Indicators,Counts Australian Businesses Including Entries And Exits,https://www.abs.gov.au/statistics/economy/business-indicators/counts-australian-businesses-including-entries-and-exits/latest-release, 
+8412.0,Industry,Mining,Mineral And Petroleum Exploration Australia,https://www.abs.gov.au/statistics/industry/mining/mineral-and-petroleum-exploration-australia/latest-release, 
+8501.0,Industry,Retail And Wholesale Trade,Retail Trade Australia,https://www.abs.gov.au/statistics/industry/retail-and-wholesale-trade/retail-trade-australia/latest-release, 
+8701.0,Industry,Building And Construction,Estimated Dwelling Stock,https://www.abs.gov.au/statistics/industry/building-and-construction/estimated-dwelling-stock/latest-release, 
+8731.0,Industry,Building And Construction,Building Approvals Australia,https://www.abs.gov.au/statistics/industry/building-and-construction/building-approvals-australia/latest-release, 
+8752.0,Industry,Building And Construction,Building Activity Australia,https://www.abs.gov.au/statistics/industry/building-and-construction/building-activity-australia/latest-release, 
+8755.0,Industry,Building And Construction,Construction Work Done Australia Preliminary,https://www.abs.gov.au/statistics/industry/building-and-construction/construction-work-done-australia-preliminary/latest-release, 
+8762.0,Industry,Building And Construction,Engineering Construction Activity Australia,https://www.abs.gov.au/statistics/industry/building-and-construction/engineering-construction-activity-australia/latest-release, 
+8782.0.65.001,Industry,Building And Construction,Construction Activity Chain Volume Measures Australia,https://www.abs.gov.au/statistics/industry/building-and-construction/construction-activity-chain-volume-measures-australia/jun-2020,Ceased
+"""
+    return read_csv(StringIO(csv), index_col=0)

readabs/abs_meta_data_support.py

@@ -0,0 +1,40 @@
+"""abs_meta_data_sypport.py
+
+Support for working with ABS meta data."""
+
+from collections import namedtuple
+
+Metacol = namedtuple(
+    "Metacol",
+    [
+        "did",
+        "stype",
+        "id",
+        "start",
+        "end",
+        "num",
+        "unit",
+        "dtype",
+        "freq",
+        "cmonth",
+        "table",
+        "tdesc",
+        "cat",
+    ],
+)
+
+metacol = Metacol(
+    did="Data Item Description",
+    stype="Series Type",
+    id="Series ID",
+    start="Series Start",
+    end="Series End",
+    num="No. Obs.",
+    unit="Unit",
+    dtype="Data Type",
+    freq="Freq.",
+    cmonth="Collection Month",
+    table="Table",
+    tdesc="Table Description",
+    cat="Catalogue number",
+)

readabs/download_cache.py

@@ -0,0 +1,218 @@
+"""download_cache.py - a module for downloading and caching data from the web.
+
+The default cache directory can be specified by setting the environment 
+variable READABS_CACHE_DIR."""
+
+# --- imports
+# system imports
+from hashlib import md5
+import re
+from datetime import datetime, timezone
+from os import utime, getenv
+from pathlib import Path
+from typing import Any
+
+# data imports
+import pandas as pd
+import requests
+
+
+# --- constants
+# define the default cache directory
+DEFAULT_CACHE_DIR = "./.readabs_cache"
+READABS_CACHE_DIR = getenv("READABS_CACHE_DIR", DEFAULT_CACHE_DIR)
+READABS_CACHE_PATH = Path(READABS_CACHE_DIR)
+
+DOWNLOAD_TIMEOUT = 60  # seconds
+
+
+# --- Exception classes
+class HttpError(Exception):
+    """A problem retrieving data from HTTP."""
+
+
+class CacheError(Exception):
+    """A problem retrieving data from the cache."""
+
+
+# --- functions
+def check_for_bad_response(
+    url: str,
+    response: requests.Response,
+    **kwargs: Any,
+) -> bool:
+    """Raise an Exception if we could not retrieve the URL.
+    If "ignore_errors" is True, return True if there is a problem,
+    otherwise raise an exception if there is a problem."""
+
+    ignore_errors = kwargs.get("ignore_errors", False)
+    code = response.status_code
+    if code != 200 or response.headers is None:
+        problem = f"Problem {code} accessing: {url}."
+        if not ignore_errors:
+            raise HttpError(problem)
+        print(problem)
+        return True
+
+    return False
+
+
+def request_get(
+    url: str,
+    **kwargs: Any,
+) -> bytes:
+    """Use python requests to get the contents of the specified URL.
+    Depending on "ignore_errors", if something goes wrong, we either
+    raise an exception or return an empty bytes object."""
+
+    # Initialise variables
+    verbose = kwargs.get("verbose", False)
+    ignore_errors = kwargs.get("ignore_errors", False)
+
+    if verbose:
+        print(f"About to request/download: {url}")
+
+    try:
+        gotten = requests.get(url, allow_redirects=True, timeout=DOWNLOAD_TIMEOUT)
+    except requests.exceptions.RequestException as e:
+        error = f"request_get(): there was a problem downloading {url}."
+        if not ignore_errors:
+            raise HttpError(error) from e
+        print(error)
+        return b""
+
+    if check_for_bad_response(url, gotten, **kwargs):
+        # Note: check_for_bad_response() will raise an exception
+        # if it encounters a problem and ignore_errors is False.
+        # Otherwise it will print an error message and return True
+        return b""
+
+    return gotten.content  # bytes
+
+
+def save_to_cache(
+    file: Path,
+    contents: bytes,
+    **kwargs: Any,
+) -> None:
+    """Save bytes to the file-system."""
+
+    verbose = kwargs.get("verbose", False)
+    if len(contents) == 0:
+        # dont save empty files (probably caused by ignoring errors)
+        return
+    if file.exists():
+        if verbose:
+            print("Removing old cache file.")
+        file.unlink()
+    if verbose:
+        print(f"About to save to cache: {file}")
+    file.open(mode="w", buffering=-1, encoding=None, errors=None, newline=None)
+    file.write_bytes(contents)
+
+
+def retrieve_from_cache(file: Path, **kwargs: Any) -> bytes:
+    """Retrieve bytes from file-system."""
+
+    verbose = kwargs.get("verbose", False)
+    ignore_errors = kwargs.get("ignore_errors", False)
+
+    if not file.exists() or not file.is_file():
+        message = f"Cached file not available: {file.name}"
+        if ignore_errors:
+            print(message)
+            return b""
+        raise CacheError(message)
+    if verbose:
+        print(f"Retrieving from cache: {file}")
+    return file.read_bytes()
+
+
+def get_file(
+    url: str,
+    cache_dir: Path = READABS_CACHE_PATH,
+    cache_prefix: str = "cache",
+    **kwargs: Any,
+) -> bytes:
+    """Get a file from URL or local file-system cache, depending on freshness.
+    Note: we create the cache_dir if it does not exist.
+    Returns: the contents of the file as bytes."""
+
+    def get_fpath() -> Path:
+        """Convert URL string into a cache file name,
+        then return as a Path object."""
+        bad_cache_pattern = r'[~"#%&*:<>?\\{|}]+'  # chars to remove from name
+        hash_name = md5(url.encode("utf-8")).hexdigest()
+        tail_name = url.split("/")[-1].split("?")[0]
+        file_name = re.sub(
+            bad_cache_pattern, "", f"{cache_prefix}--{hash_name}--{tail_name}"
+        )
+        return Path(cache_dir / file_name)
+
+    # create and check cache_dir is a directory
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    if not cache_dir.is_dir():
+        raise CacheError(f"Cache path is not a directory: {cache_dir.name}")
+
+    # get URL modification time in UTC
+    response = requests.head(url, allow_redirects=True, timeout=20)
+    if not check_for_bad_response(url, response, **kwargs):
+        source_time = response.headers.get("Last-Modified", None)
+    else:
+        source_time = None
+    source_mtime = (
+        None if source_time is None else pd.to_datetime(source_time, utc=True)
+    )
+
+    # get cache modification time in UTC
+    target_mtime: datetime | None = None
+    file_path = get_fpath()
+    if file_path.exists() and file_path.is_file():
+        target_mtime = pd.to_datetime(
+            datetime.fromtimestamp(file_path.stat().st_mtime, tz=timezone.utc), utc=True
+        )
+
+    # get and save URL source data
+    if target_mtime is None or (  # cache is empty, or
+        source_mtime is not None
+        and source_mtime > target_mtime  # URL is fresher than cache
+    ):
+        url_bytes = request_get(url, **kwargs)  # raises exception if it fails
+        save_to_cache(file_path, url_bytes, **kwargs)
+        # - change file mod time to reflect mtime at URL
+        if source_mtime is not None and len(url_bytes) > 0:
+            unixtime = source_mtime.value / 1_000_000_000  # convert to seconds
+            utime(file_path, (unixtime, unixtime))
+        return url_bytes
+
+    # return the data that has been cached previously
+    return retrieve_from_cache(file_path, **kwargs)
+
+
+# --- preliminary testing:
+DO_TEST = False
+if __name__ == "__main__" and DO_TEST:
+
+    def cache_test() -> None:
+        """This function provides a quick test of the retrieval
+        and caching system.  You may need to first clear the
+        cache directory to see the effect of the cache."""
+
+        # prepare the test case
+        url1 = (
+            "https://www.abs.gov.au/statistics/labour/employment-and-"
+            + "unemployment/labour-force-australia/nov-2023/6202001.xlsx"
+        )
+
+        # implement - first retrieval is from the web, second from the cache
+        width = 20
+        print("Test commencing.")
+        for u in (url1, url1):
+            print("=" * width)
+            content = get_file(u, verbose=True)
+            print("-" * width)
+            print(f"{len(content)} bytes retrieved from {u}.")
+        print("=" * width)
+        print("Test completed.")
+
+    cache_test()

readabs/generate_catalogue_map.py

@@ -0,0 +1,56 @@
+"""Generate the catalogue_map.py file."""
+
+# --- imports
+from io import StringIO
+import pandas as pd
+from pandas import DataFrame, Series, Index
+from download_cache import get_file
+
+
+# --- functions
+# private
+def _get_abs_directory() -> DataFrame:
+    """Return a DataFrame of ABS Catalogue numbers."""
+
+    # get ABS web page of catalogue numbers
+    url = "https://www.abs.gov.au/about/data-services/help/abs-time-series-directory"
+    page = get_file(url)
+    links = pd.read_html(StringIO(page.decode("utf-8")), extract_links="body")[
+        1
+    ]  # second table on the page
+
+    # extract catalogue numbers
+    cats = links["Catalogue Number"].apply(Series)[0]
+    urls = links["Topic"].apply(Series)[1]
+    root = "https://www.abs.gov.au/statistics/"
+    snip = urls.str.replace(root, "")
+    snip = (
+        snip[~snip.str.contains("http")].str.replace("-", " ").str.title()
+    )  # remove bad cases
+    frame = snip.str.split("/", expand=True).iloc[:, :3]
+    frame.columns = Index(["Theme", "Parent Topic", "Topic"])
+    frame["URL"] = urls
+    cats = cats[frame.index]
+    cat_index = cats.str.replace("(Ceased)", "").str.strip()
+    status = Series(" ", index=cats.index).where(cat_index == cats, "Ceased")
+    frame["Status"] = status
+    frame.index = Index(cat_index)
+    frame.index.name = "Catalogue ID"
+    return frame
+
+
+def produce_catalogue_map():
+    """Generate the catalogue_map.py file."""
+    directory = _get_abs_directory()
+    with open("abs_catalogue_map.py", "w", encoding="utf-8") as file:
+        file.write('"""Catalogue map for ABS data."""\n\n')
+        file.write("from io import StringIO\n\n")
+        file.write("from pandas import DataFrame, read_csv\n")
+        file.write("def catalogue_map() -> DataFrame:\n")
+        file.write('    """Return the catalogue map."""\n\n')
+        file.write(f'    csv = """{directory.to_csv()}"""\n')
+        file.write("    return read_csv(StringIO(csv), index_col=0)\n")
+
+
+if __name__ == "__main__":
+    produce_catalogue_map()

readabs/get_data_links.py

@@ -0,0 +1,121 @@
+"""To do"""
+
+import re
+from typing import Any
+from bs4 import BeautifulSoup
+
+# local imports - ugly, need to find out how to fix thiscd 
+if __package__ is None or __package__ == "":
+    from download_cache import get_file, HttpError, CacheError
+else:
+    from .download_cache import get_file, HttpError, CacheError
+
+
+# private
+def _make_absolute_url(url: str, prefix: str = "https://www.abs.gov.au") -> str:
+    """Convert a relative URL address found on the ABS site to
+    an absolute URL address."""
+
+    # remove a prefix if it already exists (just to be sure)
+    url = url.replace(prefix, "")
+    url = url.replace(prefix.replace("https://", "http://"), "")
+    # then add the prefix (back) ...
+    return f"{prefix}{url}"
+
+
+# public (also used by read_abs_cat.py)
+def get_table_name(url: str) -> str:
+    """Get the table name from the ABS URL."""
+
+    tail = url.rsplit("/", 1)[-1]
+    table_name = tail.split(".")[0]
+    return table_name
+
+
+# private
+def historicise_links(
+    link_dict: dict[str, list[str]], history: str
+) -> dict[str, list[str]]:
+    """Age an ABS link so that it points to a historical version of the data.
+    Note: the history string is typically in "mon-yr" format, but not alwayts.
+    Note: we are also assuming that the date is in the second last part of the URL.
+    These assumptions may not always hold."""
+
+    new_dict = {}
+    for link_type, link_list in link_dict.items():
+        new_list = []
+        for link in link_list:
+            head, _, tail = link.rsplit("/", 2)
+            replacement = "/".join([head, history, tail])
+            new_list.append(replacement)
+        new_dict[link_type] = new_list
+
+    return new_dict
+
+
+# public
+def get_data_links(
+    url: str,  # the URL of the ABS page to scan
+    inspect_file_name="",  # for debugging - save the page to disk
+    **kwargs: Any,
+) -> dict[str, list[str]]:
+    """Scan the webpage at the ABS URL for links to ZIP files and for
+    links to Microsoft Excel files.
+    Return the links in a dictionary of lists undexed by file type ending.
+    Ensure relative links have been fully expanded to be absolute links."""
+
+    # get relevant web-page from ABS website
+    verbose = kwargs.get("verbose", False)
+    if verbose:
+        print("Getting data links from the ABS web page.")
+    try:
+        page = get_file(url, **kwargs)
+    except (HttpError, CacheError) as e:
+        print(f"Error when obtaining links from ABS web page: {e}")
+        return {}
+
+    # save the HTML webpage to disk for inspection
+    if inspect_file_name:
+        with open(inspect_file_name, "w", encoding="utf-8") as file_handle:
+            file_handle.write(page.decode("utf-8"))
+
+    # remove those pesky span tags - probably not necessary
+    page = re.sub(b"<span[^>]*>", b" ", page)
+    page = re.sub(b"</span>", b" ", page)
+    page = re.sub(b"\\s+", b" ", page)  # tidy up white space
+
+    # capture all links (of ZIP and Microsoft Excel types)
+    link_types = (
+        ".zip",
+        ".xlsx",
+    )  # must be lower case
+    soup = BeautifulSoup(page, features="lxml")
+    link_dict: dict[str, list[str]] = {}
+    for link in soup.findAll("a"):
+        url = link.get("href")
+        if url is None:
+            # ignore silly cases
+            continue
+        if "pivot" in url.rsplit("/", 1)[-1].lower():
+            # ignore pivot tables
+            continue
+        for link_type in link_types:
+            if url.lower().endswith(link_type):
+                if link_type not in link_dict:
+                    link_dict[link_type] = []
+                link_dict[link_type].append(_make_absolute_url(url))
+                break
+
+    # age links if required
+    history = kwargs.get("history", "")
+    if history:
+        link_dict = historicise_links(link_dict, history)
+
+    if verbose:
+        print("Found links to the following ABS data tables:")
+        for link_type, link_list in link_dict.items():
+            summary = [get_table_name(x) for x in link_list]  # just the file name
+            print(f"Found: {len(link_list)} items of type {link_type}: {summary}")
+        print()
+
+    return link_dict

readabs/read_abs_cat.py

@@ -0,0 +1,389 @@
+"""read_abs_cat.py
+
+Download all/selected timeseries data from the
+Australian Bureau of Statistics (ABS) for a specified 
+ABS catalogue identifier and package that data into a 
+dictionary of DataFrames."""
+
+# --- imports ---
+# standard library imports
+import calendar
+import zipfile
+from functools import cache
+from io import BytesIO
+from typing import Any, Callable, cast
+
+# analytic imports
+import pandas as pd
+from pandas import DataFrame
+
+# local imports - ugly, need to find out how to fix this
+#print(f"in read_abs_cat.py: __main__={__name__}, __package__={__package__}")
+if __package__ is None or __package__ == "":
+    from abs_meta_data_support import metacol
+    from get_data_links import get_data_links, get_table_name
+    from abs_catalogue_map import catalogue_map
+    from read_support import check_kwargs, get_args
+    from download_cache import get_file
+else:
+    from .abs_meta_data_support import metacol
+    from .get_data_links import get_data_links, get_table_name
+    from .abs_catalogue_map import catalogue_map
+    from .read_support import check_kwargs, get_args
+    from .download_cache import get_file
+
+
+# --- functions ---
+# private
+def _get_meta_from_excel(
+    excel: pd.ExcelFile,
+    table: str,
+    tab_desc: str,
+    cat_id: str,
+) -> pd.DataFrame:
+    """Capture the metadata from the Index sheet of an ABS excel file.
+    Returns a DataFrame specific to the current excel file.
+    Returning an empty DataFrame, means that the meatadata could not
+    be identified. Meta data for each ABS data item is organised by row."""
+
+    # Unfortunately, the header for some of the 3401.0
+    #                spreadsheets starts on row 10
+    starting_rows = 9, 10
+    required = metacol.did, metacol.id, metacol.stype, metacol.unit
+    required_set = set(required)
+    for header_row in starting_rows:
+        file_meta = excel.parse(
+            "Index",
+            header=header_row,
+            parse_dates=True,
+            infer_datetime_format=True,
+            converters={"Unit": str},
+        )
+        file_meta = file_meta.iloc[1:-2]  # drop first and last 2
+        file_meta = file_meta.dropna(axis="columns", how="all")
+
+        if required_set.issubset(set(file_meta.columns)):
+            break
+
+        if header_row == starting_rows[-1]:
+            print(f"Could not find metadata for {cat_id}-{tab_desc}")
+            return pd.DataFrame()
+
+    # add the table name and table description to the metadata
+    file_meta[metacol.table] = table.strip()
+    file_meta[metacol.tdesc] = tab_desc.strip()
+    file_meta[metacol.cat] = cat_id.strip()
+
+    # make damn sure there are no rogue white spaces
+    for col in required:
+        file_meta[col] = file_meta[col].str.strip()
+
+    return file_meta
+
+
+# private
+def _unpack_excel_into_df(
+    excel: pd.ExcelFile,
+    meta: DataFrame,
+    freq: str,
+    verbose: bool,
+) -> DataFrame:
+    """Take an ABS excel file and put all the Data sheets into a single
+    pandas DataFrame and return that DataFrame."""
+
+    data = DataFrame()
+    data_sheets = [x for x in excel.sheet_names if cast(str, x).startswith("Data")]
+    for sheet_name in data_sheets:
+        sheet_data = excel.parse(
+            sheet_name,
+            header=9,
+            index_col=0,
+        ).dropna(how="all", axis="index")
+        data.index = pd.to_datetime(data.index)
+
+        # merge data into a large dataframe
+        if len(data) == 0:
+            data = sheet_data
+        else:
+            data = pd.merge(
+                left=data,
+                right=sheet_data,
+                how="outer",
+                left_index=True,
+                right_index=True,
+                suffixes=("", ""),
+            )
+    if freq:
+        if freq in ("Q", "A"):
+            month = calendar.month_abbr[
+                cast(pd.PeriodIndex, data.index).month.max()
+            ].upper()
+            freq = f"{freq}-{month}"
+        if isinstance(data.index, pd.DatetimeIndex):
+            data = data.to_period(freq=freq)
+
+    # check for NA columns - rarely happens
+    # Note: these empty columns are not removed,
+    # but it is useful to know they are there
+    if data.isna().all().any() and verbose:
+        cols = data.columns[data.isna().all()]
+        print(
+            "Caution: these columns are all NA in "
+            + f"{meta[metacol.table].iloc[0]}: {cols}"
+        )
+
+    # check for duplicate columns - should not happen
+    # Note: these duplicate columns are removed
+    duplicates = data.columns.duplicated()
+    if duplicates.any():
+        if verbose:
+            dup_table = meta[metacol.table].iloc[0]
+            print(
+                f"Note: duplicates removed from {dup_table}: "
+                + f"{data.columns[duplicates]}"
+            )
+        data = data.loc[:, ~duplicates].copy()
+    return data
+
+
+# private
+def _extract_data_from_excel(
+    raw_bytes: bytes, table_name: str, **kwargs: Any
+) -> tuple[DataFrame, DataFrame]:
+    """Convert the raw bytes of an Excel file into a pandas DataFrame.
+    Returns the actual data and meta data in two separate DataFrames."""
+
+    ignore_errors = kwargs.get("ignore_errors", False)
+
+    # convert the raw bytes into a pandas ExcelFile
+    try:
+        excel = pd.ExcelFile(BytesIO(raw_bytes))
+    except Exception as e:
+        message = f"With {table_name}: could not convert raw bytes to ExcelFile.\n{e}"
+        if ignore_errors:
+            print(message)
+            return pd.DataFrame(), pd.DataFrame()
+        raise RuntimeError(message) from e
+
+    excel = pd.ExcelFile(BytesIO(raw_bytes))
+
+    # get table information (ie. the meta data)
+    if "Index" not in excel.sheet_names:
+        print(
+            "Caution: Could not find the 'Index' "
+            f"sheet in {table_name}. File not included"
+        )
+        return pd.DataFrame(), pd.DataFrame()
+
+    # get table header information
+    header = excel.parse("Index", nrows=8)  # ???
+    cat_id = header.iat[3, 1].split(" ")[0].strip()
+    tab_desc = header.iat[4, 1].split(".", 1)[-1].strip()
+
+    # get the metadata rows
+    file_meta = _get_meta_from_excel(excel, table_name, tab_desc, cat_id)
+    if len(file_meta) == 0:
+        return pd.DataFrame(), pd.DataFrame()
+
+    # establish freq - used for making the index a PeriodIndex
+    freq_dict = {"annual": "Y", "biannual": "Q", "quarter": "Q", "month": "M"}
+    freqlist = file_meta["Freq."].str.lower().unique()
+    if not len(freqlist) == 1 or freqlist[0] not in freq_dict:
+        print(f"Unrecognised data frequency {freqlist} for {tab_desc}")
+        return pd.DataFrame(), pd.DataFrame()
+    freq = freq_dict[freqlist[0]]
+
+    data = _unpack_excel_into_df(
+        excel, file_meta, freq, verbose=kwargs.get("verbose", False)
+    )
+
+    return data, file_meta
+
+
+# private
+def _process_zip_binary(
+    zip_contents: bytes,
+    **kwargs: Any,
+) -> tuple[dict[str, DataFrame], DataFrame]:
+    """Extract the contents of a ZIP file into a tuple, where the
+    first element is a dictionary of DataFrames; and the second
+    element is the related ABS meta data in a DataFrame."""
+
+    verbose = kwargs.get("verbose", False)
+    if verbose:
+        print("Extracting DataFrames from the zip-file binary.")
+    returnable_data: dict[str, DataFrame] = {}
+    returnable_meta = DataFrame()
+
+    with zipfile.ZipFile(BytesIO(zip_contents)) as zipped:
+        for count, element in enumerate(zipped.infolist()):
+            # get the zipfile into pandas
+            table_name = get_table_name(url=element.filename)
+            raw_bytes = zipped.read(element.filename)
+            excel_df, file_meta = _extract_data_from_excel(
+                raw_bytes, table_name, **kwargs
+            )
+            if len(excel_df) == 0:
+                # this table could not be captured
+                continue
+
+            # fix tabulation if ABS used the same table numbers for data
+            if table_name in returnable_data:
+                # This really just should not happen, but if it does, we need to dix it
+                tmp = f"{table_name}-{count}"
+                if verbose:
+                    print(f"Changing duplicate table name from {table_name} to {tmp}.")
+                table_name = tmp
+                file_meta[metacol.table] = table_name
+
+            # aggregate the meta data
+            returnable_meta = pd.concat([returnable_meta, file_meta])
+
+            # add the table to the returnable dictionary
+            returnable_data[table_name] = excel_df
+
+    return returnable_data, returnable_meta
+
+
+# private
+def _add_zip(
+    link: str, abs_dict: dict[str, DataFrame], abs_meta: DataFrame, **args
+) -> tuple[dict[str, DataFrame], DataFrame]:
+    """Add tables from zip file to the dictionary of DataFrames
+    and associated rows to the meta data."""
+
+    zip_contents = get_file(link, **args)
+    if len(zip_contents) == 0:
+        return abs_dict, abs_meta
+    zip_data, zip_meta = _process_zip_binary(zip_contents, **args)
+    abs_dict.update(zip_data)
+    abs_meta = pd.concat([abs_meta, zip_meta], axis=0)
+    return abs_dict, abs_meta
+
+
+# private
+def _add_excel(
+    link: str,
+    abs_dict: dict[str, DataFrame],
+    abs_meta: DataFrame,
+    **args: Any,
+) -> tuple[dict[str, DataFrame], DataFrame]:
+    """Add a table to the dictionary of DataFrames
+    and rows to the the meta data."""
+
+    name = get_table_name(link)
+    if name in abs_dict:
+        # table already in the dictionary
+        return abs_dict, abs_meta
+    raw_bytes = get_file(link, **args)
+    if len(raw_bytes) == 0:
+        # could not get the file, and errors are ignored
+        return abs_dict, abs_meta
+    excel_df, file_meta = _extract_data_from_excel(raw_bytes, name, **args)
+    if len(excel_df) == 0:
+        # could not get the file, and errors are ignored
+        return abs_dict, abs_meta
+    abs_dict[name] = excel_df
+    abs_meta = pd.concat([abs_meta, file_meta], axis=0)
+    return abs_dict, abs_meta
+
+
+# private
+def _add_single(
+    name: str,
+    abs_dict: dict[str, DataFrame],
+    abs_meta: DataFrame,
+    links: dict[str, list[str]],
+    typology: str,  # ".zip" or ".xlsx"
+    **args,
+) -> tuple[dict[str, DataFrame], DataFrame]:
+    """Add a single excel file or zip file to the dictionary of DataFrames,
+    along with associated meta data."""
+
+    fn: Callable = _add_zip if typology == ".zip" else _add_excel
+    selection = {get_table_name(x): x for x in links.get(typology, [])}
+    if name not in selection:
+        message = f"File ({name}{typology}) not found on ABS web page."
+        if not args["ignore_errors"]:
+            raise ValueError(message)
+        print(message)
+        return abs_dict, abs_meta
+    abs_dict, abs_meta = fn(selection[name], abs_dict, abs_meta, **args)
+    return abs_dict, abs_meta
+
+
+# public -- primary entry point for this module
+@cache  # minimise slowness with repeat business
+def read_abs_cat(
+    cat: str, **kwargs: Any  # ABS catalogue number  # keyword arguments
+) -> tuple[dict[str, DataFrame], DataFrame]:
+    """Read the ABS data for a catalogue id and return the data.
+
+    Parameters
+    ----------
+    cat : str
+        The ABS catalogue number.
+    **kwargs : Any
+        Keyword arguments for the read_abs_cat function.
+
+    Returns
+    -------
+    tuple[dict[str, DataFrame], DataFrame]
+        A dictionary of DataFrames and a DataFrame of the meta data.
+        The dictionary is indexed by table names, which can be found
+        in the meta data DataFrame."""
+
+    # check/get the keyword arguments
+    check_kwargs(kwargs, "read_abs_cat")
+    args = get_args(kwargs)
+
+    if (
+        not args["get_zip"]
+        and not args["get_excel"]
+        and not args["get_excel_if_no_zip"]
+    ):
+        raise ValueError("read_abs_dict: either get_zip or get_excel must be True.")
+
+    # convert the catalogue number to the ABS webpage URL
+    cm = catalogue_map()
+    if cat not in cm.index:
+        raise ValueError(f"ABS catalogue number {cat} not found.")
+    url = cm["URL"].astype(str)[cat]
+
+    # get the URL links to the relevant ABS data files on that webpage
+    links = get_data_links(url, **args)
+    if not links:
+        print(f"No data files found for catalogue number {cat}")
+        return {}, DataFrame()  # return an empty dictionary, DataFrame
+
+    # read the data files into a dictionary of DataFrames
+    abs_dict: dict[str, DataFrame] = {}
+    abs_meta: DataFrame = DataFrame()
+
+    if args["single_excel_only"]:
+        abs_dict, abs_meta = _add_single(
+            args["single_excel_only"], abs_dict, abs_meta, links, ".xlsx", **args
+        )
+
+    elif args["single_zip_only"]:
+        abs_dict, abs_meta = _add_single(
+            args["single_zip_only"], abs_dict, abs_meta, links, ".zip", **args
+        )
+
+    else:
+        for link_type in ".zip", ".xlsx":  # .zip must come first
+            for link in links.get(link_type, []):
+                if link_type == ".zip" and args["get_zip"]:
+                    abs_dict, abs_meta = _add_zip(link, abs_dict, abs_meta, **args)
+
+                elif link_type == ".xlsx" and (
+                    args["get_excel"]
+                    or (args["get_excel_if_no_zip"] and not args["get_zip"])
+                    or (args["get_excel_if_no_zip"] and not links.get(".zip", []))
+                ):
+                    abs_dict, abs_meta = _add_excel(
+                        link, abs_dict, abs_meta, links=links, **args
+                    )
+
+    # reset the index of the metadata
+    return abs_dict, abs_meta.reset_index()

readabs/read_abs_series.py

@@ -0,0 +1,95 @@
+"""read_abs_series.py
+
+Get specific ABS data series by their ABS series identifiers."""
+
+# --- imports
+# system imports
+from typing import Any, Sequence, cast
+
+# analytic imports
+from pandas import DataFrame, PeriodIndex, concat
+
+# local imports
+if __package__ is None or __package__ == "":
+    from read_abs_cat import read_abs_cat
+    from read_support import check_kwargs, get_args
+    from abs_meta_data_support import metacol
+else:
+    from .read_abs_cat import read_abs_cat
+    from .read_support import check_kwargs, get_args
+    from .abs_meta_data_support import metacol
+
+
+# --- functions
+def read_abs_series(
+    cat: str,
+    series_id: str | Sequence[str],
+    **kwargs: Any,
+) -> tuple[DataFrame, DataFrame]:
+    """Get specific ABS data series by their ABS catalogue ID and series ID
+
+    Parameters
+    ----------
+    cat : str
+        The ABS catalogue ID.
+    series_id : str | Sequence[str]
+        An ABS series ID or a sequence of ABS series IDs.
+    **kwargs : Any
+        Keyword arguments for the read_abs_series function,
+        which are the same as the keyword arguments for the r
+        read_abs_cat function.
+
+    Returns
+    -------
+    tuple[DataFrame, DataFrame]
+        The ABS series data and the associated meta data.
+    """
+
+    # check for unexpected keyword arguments/get defaults
+    check_kwargs(kwargs, "read_abs_series")
+    args = get_args(kwargs)
+
+    # read the ABS category data
+    cat_data, cat_meta = read_abs_cat(cat, **args)
+
+    # drop repeated series_ids in the meta data, make series_ids the index
+    cat_meta.index = cat_meta[metacol.id]
+    cat_meta = cat_meta.groupby(cat_meta.index).first()
+
+    # get the ABS series data
+    if isinstance(series_id, str):
+        series_id = [series_id]
+    return_data, return_meta = DataFrame(), DataFrame()
+    for identifier in series_id:
+
+        # confirm that the series ID is in the catalogue
+        if not identifier in cat_meta.index:
+            if args["verbose"]:
+                print(f"Series ID {identifier} not found in ABS catalogue ID {cat}")
+            if args["ignore_errors"]:
+                continue
+            raise ValueError(f"Series ID {identifier} not found in catalogue {cat}")
+
+        # confirm thay the index of the series is compatible
+        table = cat_meta.loc[identifier, metacol.table]
+        data_series = cat_data[table][identifier]
+        if (
+            len(return_data) > 0
+            and cast(PeriodIndex, return_data.index).freq
+            != cast(PeriodIndex, data_series.index).freq
+        ):
+            if args["verbose"]:
+                print(f"Frequency mismatch for series ID {identifier}")
+            if args["ignore_errors"]:
+                continue
+            raise ValueError(f"Frequency mismatch for series ID {identifier}")
+
+        # add the series data and meta data to the return values
+        if len(return_data) > 0:
+            return_data = return_data.reindex(
+                return_data.index.union(data_series.index)
+            )
+        return_data[identifier] = data_series
+        return_meta = concat([return_meta, cat_meta.loc[identifier]], axis=1)
+
+    return return_data, return_meta.T

readabs/read_support.py

@@ -0,0 +1,31 @@
+"""Support for the read ABS data functions, all of which take the
+same keyword arguments. This module provides a way to check for
+unexpected keyword arguments and to provide default values for
+those arguments that are not provided."""
+
+from typing import Any
+
+DEFAULTS: dict[str, Any] = {
+    # argument_name: default_value,
+    "verbose": False,
+    "ignore_errors": False,
+    "get_zip": True,
+    "get_excel_if_no_zip": True,
+    "get_excel": False,
+    "single_zip_only": "",
+    "single_excel_only": "",
+    "history": "",
+}
+
+
+def check_kwargs(kwargs: dict[str, Any], name: str) -> None:
+    """Warn if there are any invalid keyword args."""
+    for k in kwargs:
+        if k not in DEFAULTS:
+            print(f"{name}: Unexpected keyword argument {k}")
+
+
+def get_args(kwargs: dict[str, Any]) -> dict[str, Any]:
+    """Return a dictionary with only the valid kwargs
+    (and their default values if a valid key is missing from kwargs)."""
+    return {k: kwargs.get(k, v) for k, v in DEFAULTS.items()}

readabs/readabs.py

@@ -0,0 +1,40 @@
+"""Read time series data from the Australian Bureau of Statistics (ABS)."""
+
+# --- imports
+# system imports
+
+# analytic imports
+
+# local imports
+from .abs_catalogue_map import catalogue_map
+from .get_data_links import get_data_links
+from .read_abs_cat import read_abs_cat
+from .read_abs_series import read_abs_series
+from .abs_meta_data_support import metacol
+from .utilities import (
+    percent_change,
+    annualise_rates,
+    annualise_percentages,
+    qtly_to_monthly,
+    monthly_to_qtly,
+)
+
+_ = (
+    # silence linters/checkers
+    get_data_links,
+    metacol,
+    read_abs_cat,
+    read_abs_series,
+    percent_change,
+    annualise_rates,
+    annualise_percentages,
+    qtly_to_monthly,
+    monthly_to_qtly,
+)
+
+
+# --- functions
+def print_abs_catalogue() -> None:
+    """Print the ABS catalogue."""
+    catalogue = catalogue_map()
+    print(catalogue.loc[:, catalogue.columns != "URL"].to_markdown())

readabs/readabs.pyi

@@ -0,0 +1,26 @@
+"""Stubs for readabs."""
+
+from typing import Any, Sequence
+from pandas import DataFrame, Series
+
+
+# TO DO: metacol
+
+def catalogue_map() -> DataFrame: ...
+def print_abs_catalogue() -> None: ...
+
+def get_data_links(
+    url: str, inspect_file_name="", **kwargs: Any,
+) -> dict[str, list[str]]: ...
+
+def read_abs_cat(
+    cat: str, **kwargs: Any,
+) -> tuple[dict[str, DataFrame], DataFrame]: ...
+
+def read_abs_series(
+    cat: str,
+    series_id: str | Sequence[str],
+    **kwargs: Any,
+) -> tuple[DataFrame, DataFrame]: ...
+
+

readabs/utilities.py

@@ -0,0 +1,98 @@
+"""utilities.py
+
+This module provides a small numer of utilities for
+working with ABS timeseries data."""
+
+# --- imports
+from typing import TypeVar, Optional, cast
+from pandas import Series, DataFrame, PeriodIndex, DatetimeIndex
+from numpy import nan
+
+# - define a useful typevar for working with both Series and DataFrames
+DataT = TypeVar("DataT", Series, DataFrame)
+
+
+# --- functions
+def percent_change(data: DataT, m_periods: int) -> DataT:
+    """Calculate an percentage change in a series over n_periods."""
+
+    return (data / data.shift(m_periods) - 1) * 100
+
+
+def annualise_rates(data: DataT, periods_per_year: int | float = 12) -> DataT:
+    """Annualise a growth rate for a period.
+    Note: returns a percentage (and not a rate)!"""
+
+    return (((1 + data) ** periods_per_year) - 1) * 100
+
+
+def annualise_percentages(data: DataT, periods_per_year: int | float = 12) -> DataT:
+    """Annualise a growth rate (expressed as a percentage) for a period."""
+
+    rates = data / 100.0
+    return annualise_rates(rates, periods_per_year)
+
+
+def qtly_to_monthly(
+    data: DataT,
+    interpolate: bool = True,
+    limit: Optional[int] = 2,  # only used if interpolate is True
+    dropna: bool = True,
+) -> DataT:
+    """Convert a pandas timeseries with a Quarterly PeriodIndex to an
+    timeseries with a Monthly PeriodIndex.
+
+    Arguments:
+    ==========
+    data - either a pandas Series or DataFrame - assumes the index is unique.
+    interpolate - whether to interpolate the missing monthly data.
+    dropna - whether to drop NA data
+
+    Notes:
+    ======
+    Necessitated by Pandas 2.2, which removed .resample()
+    from pandas objects with a PeriodIndex."""
+
+    # sanity checks
+    assert isinstance(data.index, PeriodIndex)
+    assert data.index.freqstr[0] == "Q"
+    assert data.index.is_unique
+    assert data.index.is_monotonic_increasing
+
+    def set_axis_monthly_periods(x: DataT) -> DataT:
+        """Convert a DatetimeIndex to a Monthly PeriodIndex."""
+
+        return x.set_axis(
+            labels=cast(DatetimeIndex, x.index).to_period(freq="M"), axis="index"
+        )
+
+    # do the heavy lifting
+    data = (
+        data.set_axis(
+            labels=data.index.to_timestamp(how="end"), axis="index", copy=True
+        )
+        .resample(rule="ME")  # adds in every missing month
+        .first(min_count=1)  # generates nans for new months
+        # assumes only one value per quarter (ie. unique index)
+        .pipe(set_axis_monthly_periods)
+    )
+
+    if interpolate:
+        data = data.interpolate(limit_area="inside", limit=limit)
+    if dropna:
+        data = data.dropna()
+
+    return data
+
+
+def monthly_to_qtly(data: DataT, q_ending="DEC", f: str = "mean") -> DataT:
+    """Convert monthly data to quarterly data by taking the mean of
+    the three months in each quarter. Ignore quarters with less than
+    three months data. Drop NA items. Change f to "sum" for a quarterly sum"""
+
+    return (
+        data.groupby(PeriodIndex(data.index, freq=f"Q-{q_ending}"))
+        .agg([f, "count"])
+        .apply(lambda x: x["mean"] if x["count"] == 3 else nan, axis=1)
+        .dropna()
+    )

readabs-0.0.2.dist-info/LICENSE

@@ -0,0 +1,8 @@
+Copyright 2024 Bryan Palmer (Canberra Australia)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

readabs-0.0.2.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.1
+Name: readabs
+Version: 0.0.2
+Summary: Get ABS timeseries data in pandas DataFrames
+Author-email: Bryan Palmer <palmer.bryan@gmail.com>
+Maintainer-email: Bryan Palmer <palmer.bryan@gmail.com>
+Project-URL: Homepage, https://github.com/bpalmer4/readabs
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+License-File: LICENSE
+

readabs-0.0.2.dist-info/RECORD

@@ -0,0 +1,17 @@
+readabs/__init__.py,sha256=oRPBeNE3YqW2BPHpluXF39OfwCFGrVws2dMTeXyhnhM,68
+readabs/abs_catalogue_map.py,sha256=XrTc844NEV0g6CaxadS0HsCJweOGUQwpRMEdi2I5iBY,8922
+readabs/abs_meta_data_support.py,sha256=PgVOWIGb3_axFwYDnCIZ0IBJ5WUTtBIfNwkdjFfQ9zs,705
+readabs/download_cache.py,sha256=h_ElUmdJJuBm5DAB9KefShOWxCvMHskHDwVlV6L5IiE,6960
+readabs/generate_catalogue_map.py,sha256=5Air2d4fvZVezJt9fzUQc7WLX1aHsv2y4Yn0SJtXbRk,2011
+readabs/get_data_links.py,sha256=wLL2p8cZMUVM-PYCoh5XKO2-lt3J9QwEGL17CFaYDq4,4116
+readabs/read_abs_cat.py,sha256=6Sb1meL_NlcjXRB3J7VbjbtDvIlRP5GzKzmKD5ZpUGI,13464
+readabs/read_abs_series.py,sha256=R0ogok9Wm4fgL59ZYcI2TObPLEQjAH5QxRZ2qoUjhmc,3175
+readabs/read_support.py,sha256=AQAvOQ-FlpQBRHrLQHx44OiUDgN1twRPrwVHcekh6Bk,1007
+readabs/readabs.py,sha256=D1zJXYbrc1mipDCp9rKmPjuGx91MLIKlRMHKH-pq0ig,909
+readabs/readabs.pyi,sha256=N6psbIWpV5obaltk0BbFl2Eip0LUaPN0hCFzhr5wQXs,524
+readabs/utilities.py,sha256=-L2kSe-141l-8s5fKj-bSPxs7o5VKFDU5JKaqU5rGDU,3124
+readabs-0.0.2.dist-info/LICENSE,sha256=YMg097MHV-y9Yg1sZK7T9nueRGswD4cEcCRtst9FGxE,1082
+readabs-0.0.2.dist-info/METADATA,sha256=cLZ2HVbv1q19NV_89nhnftjpdmuo8BDrtcir7XaNkiA,464
+readabs-0.0.2.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
+readabs-0.0.2.dist-info/top_level.txt,sha256=lA7BwCI3L6fvTyx0HcMTcS3FhgXkCiEL3sXUQ2WtLbE,8
+readabs-0.0.2.dist-info/RECORD,,

readabs-0.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (70.1.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

readabs-0.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+readabs