owid-datautils 0.6.1__py3-none-any.whl

owid/datautils/google/sheets.py

@@ -0,0 +1,134 @@
+"""Google Sheet utils."""
+
+import os
+from typing import Any, Optional, Union
+
+import pandas as pd
+from gsheets import Sheets
+from gsheets.models import SpreadSheet, WorkSheet
+
+from owid.datautils.google.config import CLIENT_SECRETS_PATH, CREDENTIALS_PATH
+
+
+class GSheetsApi:
+    """Interface to interact with Google sheets."""
+
+    def __init__(
+        self,
+        clients_secrets: str = CLIENT_SECRETS_PATH,
+        credentials_path: str = CREDENTIALS_PATH,
+    ) -> None:
+        self.clients_secrets = clients_secrets
+        self.credentials_path = credentials_path
+        self._init_config_folder()
+        self.__sheets = None
+
+    @property
+    def sheets(self) -> Sheets:
+        """Access or initialize sheets attribute."""
+        if self.__sheets is None:
+            self.__sheets = Sheets.from_files(self.clients_secrets, self.credentials_path, no_webserver=True)
+        return self.__sheets
+
+    def _init_config_folder(self) -> None:
+        credentials_folder = os.path.expanduser(os.path.dirname(self.credentials_path))
+        if not os.path.isdir(credentials_folder):
+            os.makedirs(credentials_folder, exist_ok=True)
+
+    def get(self, spreadsheet_id: str, worksheet_id: Optional[int] = None) -> Union[SpreadSheet, WorkSheet]:
+        """Get a spreadsheet or worksheet from a Google sheet.
+
+        If only `spreadsheet_id` is provided, this will return the entire spreadsheet. Otherwise,
+        the specific worksheet will be returned.
+
+        Parameters
+        ----------
+        spreadsheet_id : str
+            ID of the spreadsheet.
+        worksheet_id : int
+            ID of the worksheet.
+
+        Returns
+        -------
+        Spreadsheet or WorkSheet
+            SpreadSheet or Worksheet.
+        """
+        ssheet = self.sheets.get(spreadsheet_id)
+        if worksheet_id:
+            return ssheet.get(worksheet_id)  # type: ignore[reportReturnType]
+        return ssheet  # type: ignore[reportReturnType]
+
+    def download_worksheet(
+        self,
+        spreadsheet_id: str,
+        worksheet_id: int,
+        output_path: Optional[str] = None,
+        encoding: str = "utf-8",
+        **kwargs: Any,
+    ) -> None:
+        """Download a worksheet from a Google sheet.
+
+        Saves the downloaded worksheet as a CSV.
+
+        Parameters
+        ----------
+        spreadsheet_id : str
+            ID of the spreadsheet. This is included in the URL of the spreadsheet.
+        worksheet_id : int
+            ID of the worksheet. This is included in the URL of the spreadsheet. Look for
+            "edit#gid=<worksheet_id>" section.
+        output_path : str, optional
+            Local path where to save the downloaded worksheet. By default it will save it in
+            the execution directory under the name that was given to the worksheet on Google Drive.
+        encoding : str, optional
+            Encoding of the file, by default "utf-8"
+        """
+        sheet = self.get(spreadsheet_id, worksheet_id)
+        if output_path:
+            sheet.to_csv(output_path, encoding=encoding, **kwargs)  # type: ignore[reportCallIssue]
+        else:
+            make_filename = "%(title)s.csv"
+            sheet.to_csv(make_filename=make_filename, encoding=encoding, **kwargs)
+
+    def download_spreadsheet(
+        self, spreadsheet_id: str, output_dir: str, encoding: str = "utf-8", **kwargs: Any
+    ) -> None:
+        """Download a spreadsheet from a Google sheet.
+
+        It downloads all the worksheets from the given spreadsheets and saves them as CSVs.
+        The filenames given to the worksheets are as follows:
+
+        `<output_dir>/<spreadsheet_title> - <worksheet_title>.csv`
+
+        Parameters
+        ----------
+        spreadsheet_id : str
+            ID of the spreadsheet. This is included in the URL of the spreadsheet.
+        output_dir : str, optional
+            Local directory where to store all the downloaded worksheets.
+        encoding : str, optional
+            Encoding of the file, by default "utf-8"
+        """
+        sheet = self.get(spreadsheet_id)
+        make_filename = os.path.join(output_dir, "%(title)s - %(sheet)s.csv")
+        sheet.to_csv(make_filename=make_filename, encoding=encoding, **kwargs)
+
+    def worksheet_to_df(self, spreadsheet_id: str, worksheet_id: int) -> pd.DataFrame:
+        """Load a Worksheet as a dataframe.
+
+        Parameters
+        ----------
+        spreadsheet_id : str
+            ID of the spreadsheet. This is included in the URL of the spreadsheet.
+        worksheet_id : int
+            ID of the worksheet. This is included in the URL of the spreadsheet. Look for
+            "edit#gid=<worksheet_id>" section.
+
+        Returns
+        -------
+        pd.DataFrame:
+            Dataframe with the data from the worksheet.
+        """
+        ws = self.get(spreadsheet_id, worksheet_id)
+        df: pd.DataFrame = ws.to_frame()  # type: ignore[reportAttributeAccessIssue]
+        return df

owid/datautils/io/__init__.py

@@ -0,0 +1,14 @@
+"""Input/Output methods."""
+
+from owid.datautils.io.archive import decompress_file
+from owid.datautils.io.df import from_file as df_from_file
+from owid.datautils.io.df import to_file as df_to_file
+from owid.datautils.io.json import load_json, save_json
+
+__all__ = [
+    "decompress_file",
+    "load_json",
+    "save_json",
+    "df_from_file",
+    "df_to_file",
+]

owid/datautils/io/archive.py

@@ -0,0 +1,84 @@
+"""Input/Output functions for local files."""
+
+import tarfile
+import zipfile
+from pathlib import Path
+from typing import Union, cast
+
+from py7zr import SevenZipFile
+
+from owid.datautils.decorators import enable_file_download
+
+
+@enable_file_download(path_arg_name="input_file")
+def decompress_file(
+    input_file: Union[str, Path],
+    output_folder: Union[str, Path],
+    overwrite: bool = False,
+) -> None:
+    """Extract a zip or tar file.
+
+    It can be a local or a remote file.
+
+    Parameters
+    ----------
+    input_file : Union[str, Path]
+        Path to local zip file, or URL of a remote zip file.
+    output_folder : Union[str, Path]
+        Path to local folder.
+    overwrite : bool
+        Overwrite decompressed content if it already exists (otherwise raises an error if content already exists).
+
+    """
+    if isinstance(input_file, str):
+        input_file = Path(input_file)
+    input_file = cast(Path, input_file)
+
+    if zipfile.is_zipfile(input_file):
+        _decompress_zip_file(input_file, output_folder, overwrite)
+    elif tarfile.is_tarfile(input_file):
+        _decompress_tar_file(input_file, output_folder, overwrite)
+    elif input_file.suffix.lower() == ".7z":
+        with SevenZipFile(input_file, mode="r") as z:
+            z.extractall(path=output_folder)
+    else:
+        raise ValueError("File is neither a zip nor a tar file.")
+
+
+def _decompress_zip_file(
+    input_file: Union[str, Path],
+    output_folder: Union[str, Path],
+    overwrite: bool = False,
+) -> None:
+    """Unpack zip file."""
+    zip_file = zipfile.ZipFile(input_file)
+
+    # If the content to be written in output folder already exists, raise an error,
+    # unless 'overwrite' is set to True, in which case the existing file will be overwritten.
+    # Path to new file to be created.
+    new_file = Path(output_folder) / Path(zip_file.namelist()[0])
+    if new_file.exists() and not overwrite:
+        raise FileExistsError("Output already exists. Either change output_folder or use overwrite=True.")
+
+    # Unzip the file and save it in the local output folder.
+    # Note that, if output_folder path does not exist, the following command will create it.
+    zip_file.extractall(output_folder)
+
+
+def _decompress_tar_file(
+    input_file: Union[str, Path],
+    output_folder: Union[str, Path],
+    overwrite: bool = False,
+) -> None:
+    """Unpack tar file."""
+    with tarfile.open(input_file) as tar_file:
+        # If the content to be written in output folder already exists, raise an error,
+        # unless 'overwrite' is set to True, in which case the existing file will be overwritten.
+        # Path to new file to be created.
+        new_file = Path(output_folder) / Path(tar_file.getnames()[0])
+        if new_file.exists() and not overwrite:
+            raise FileExistsError("Output already exists. Either change output_folder or use" " overwrite=True.")
+
+        # Unzip the file and save it in the local output folder.
+        # Note that, if output_folder path does not exist, the following command will create it.
+        tar_file.extractall(output_folder)

owid/datautils/io/df.py

@@ -0,0 +1,163 @@
+"""DataFrame io operations."""
+
+import inspect
+from pathlib import Path
+from typing import Any, List, Optional, Union
+
+import pandas as pd
+
+from owid.datautils.decorators import enable_file_download
+
+COMPRESSION_SUPPORTED = ["gz", "bz2", "zip", "xz", "zst", "tar"]
+
+
+def _has_index(df: pd.DataFrame) -> bool:
+    # Copy of dataframes.has_index to avoid circular imports.
+    df_has_index = True if df.index.names[0] is not None else False
+
+    return df_has_index
+
+
+@enable_file_download("file_path")
+def from_file(
+    file_path: Union[str, Path], file_type: Optional[str] = None, **kwargs: Any
+) -> Union[pd.DataFrame, List[pd.DataFrame]]:
+    """Load a file as a pandas DataFrame.
+
+    It uses standard pandas function pandas.read_* but adds the ability to read from a URL in some
+    cases where pandas does not work.
+
+    The function will infer the extension of `file_path` by simply taking what follows the last ".". For example:
+    "file.csv" will be read as a csv file, and "http://my/domain/file.xlsx" will be read as an excel file.
+
+    Reading from compressed files will not work by default, unless you provide a `file_type`.
+
+    Parameters
+    ----------
+    filepath : str
+        Path or url to file.
+    file_type : str
+        File type of the data file. By default is None, as it is only required when reading compressed files.
+        This is typically equivalent to the file extension. However, when reading a
+        compressed file, this refers to the actual file that is compressed (not the compressed file extension).
+        Reading from compressed files is supported for "csv", "dta" and "json".
+    kwargs :
+        pandas.read_* arguments.
+
+    Returns
+    -------
+    pandas.DataFrame:
+        Read dataframe.
+    """
+    # Ensure file_path is a Path object.
+    file_path = Path(file_path)
+
+    # Ensure extension is lower case and does not start with '.'.
+    extension = file_path.suffix.lstrip(".").lower()
+
+    # If compressed file, raise an exception unless file_type is given
+    if extension in COMPRESSION_SUPPORTED:
+        if file_type:
+            extension = file_type
+        else:
+            raise ValueError(
+                "To be able to read from a compressed file, you need to provide a value" " for `file_type`."
+            )
+
+    # Check path is valid
+    if not file_path.exists():
+        raise FileNotFoundError(f"Cannot find file: {file_path}")
+
+    # Available input methods (some of them may need additional dependencies to work).
+    input_methods = {
+        "csv": pd.read_csv,
+        "dta": pd.read_stata,
+        "feather": pd.read_feather,
+        "hdf": pd.read_hdf,
+        "html": pd.read_html,
+        "json": pd.read_json,
+        "parquet": pd.read_parquet,
+        "pickle": pd.read_pickle,
+        "pkl": pd.read_pickle,
+        "xlsx": pd.read_excel,
+        "xml": pd.read_xml,
+    }
+    if extension not in input_methods:
+        raise ValueError("Failed reading dataframe because of an unknown file extension:" f" {extension}")
+    # Select the appropriate reading method.
+    read_function = input_methods[extension]
+
+    # Load file using the chosen read function and the appropriate arguments.
+    df: pd.DataFrame = read_function(file_path, **kwargs)
+    return df
+
+
+def to_file(df: pd.DataFrame, file_path: Union[str, Path], overwrite: bool = True, **kwargs: Any) -> None:
+    """Save dataframe to file.
+
+    This function wraps all pandas df.to_* methods, e.g. df.to_csv() or df.to_parquet(), with the following advantages:
+    * The output file will have the format determined by the extension of file_path. Hence, to_file(df, "data.csv") will
+    create a csv file, and to_file(df, "data.parquet") will create a parquet file.
+    * If file_path is with one or more subfolders that do not exist, the full path will be created.
+    * It can overwrite an existing file (if overwrite is True), or raise an error if the file already exists.
+    * It will avoid creating an index column if the dataframe has a dummy index (which would be equivalent to doing
+    df.to_csv(file_path, index=False)), but it will include the index if the dataframe has one.
+    * Any additional keyword argument that would be passed on to the method to write a file can be safely added. For
+    example, to_file(df, "data.csv", na_rep="TEST") will replace missing data by "TEST" (analogous to
+    df.to_csv("data.csv", na_rep="TEST")).
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        Dataframe to be stored in a file.
+    file_path : Union[str, Path]
+        Path to file to be created.
+    overwrite : bool, optional
+        True to overwrite file if it already exists. False to raise an error if file already exists.
+
+    """
+    # Ensure file_path is a Path object.
+    file_path = Path(file_path)
+
+    # Ensure extension is lower case and does not start with '.'.
+    extension = file_path.suffix.lstrip(".").lower()
+
+    # Ensure output directory exists.
+    if not file_path.parent.exists():
+        file_path.parent.mkdir(parents=True)
+
+    # Avoid overwriting an existing file unless explicitly stated.
+    if file_path.is_file() and not overwrite:
+        raise FileExistsError("Failed to save dataframe because file exists and 'overwrite' is False.")
+
+    # Available output methods (some of them may need additional dependencies to work).
+    output_methods = {
+        "csv": df.to_csv,
+        "dta": df.to_stata,
+        "feather": df.to_feather,
+        "hdf": df.to_hdf,
+        "html": df.to_html,
+        "json": df.to_json,
+        "md": df.to_markdown,
+        "parquet": df.to_parquet,
+        "pickle": df.to_pickle,
+        "pkl": df.to_pickle,
+        "tex": df.to_latex,
+        "txt": df.to_string,
+        "xlsx": df.to_excel,
+        "xml": df.to_xml,
+    }
+    if extension not in output_methods:
+        raise ValueError(f"Failed saving dataframe because of an unknown file extension: {extension}")
+    # Select the appropriate storing method.
+    save_function = output_methods[extension]
+
+    # Decide whether dataframe should be stored with or without an index, if:
+    # * The storing method allows for an 'index' argument.
+    # * The argument "index" is not explicitly given.
+    if ("index" in inspect.signature(save_function).parameters) and ("index" not in kwargs):
+        # Make 'index' False to avoid storing index if dataframe has a dummy index.
+        kwargs["index"] = _has_index(df=df)
+
+    # Save file using the chosen save function and the appropriate arguments.
+    save_function(file_path, **kwargs)

owid/datautils/io/json.py

@@ -0,0 +1,78 @@
+"""Input/Output functions for local files."""
+
+import json
+from pathlib import Path
+from typing import Any, Hashable, List, Tuple, Union
+
+from owid.datautils.common import warn_on_list_of_entities
+from owid.datautils.decorators import enable_file_download
+
+
+def _load_json_data_and_duplicated_keys(ordered_pairs: List[Tuple[Hashable, Any]]) -> Any:
+    clean_dict = {}
+    duplicated_keys = []
+    for key, value in ordered_pairs:
+        if key in clean_dict:
+            duplicated_keys.append(key)
+        clean_dict[key] = value
+    if len(duplicated_keys) > 0:
+        warn_on_list_of_entities(
+            list_of_entities=duplicated_keys,
+            warning_message="Duplicated entities found.",
+            show_list=True,
+        )
+
+    return clean_dict
+
+
+@enable_file_download(path_arg_name="json_file")
+def load_json(json_file: Union[str, Path], warn_on_duplicated_keys: bool = True) -> Any:
+    """Load data from json file, and optionally warn if there are duplicated keys.
+
+    If json file contains duplicated keys, a warning is optionally raised, and only the value of the latest duplicated
+    key is kept.
+
+    Parameters
+    ----------
+    json_file : Path or str
+        Path to json file.
+    warn_on_duplicated_keys : bool
+        True to raise a warning if there are duplicated keys in json file. False to ignore.
+
+    Returns
+    -------
+    data : dict
+        Data loaded from json file.
+
+    """
+    with open(json_file, "r") as _json_file:
+        json_content = _json_file.read()
+        if warn_on_duplicated_keys:
+            data = json.loads(json_content, object_pairs_hook=_load_json_data_and_duplicated_keys)
+        else:
+            data = json.loads(json_content)
+
+    return data
+
+
+def save_json(data: Any, json_file: Union[str, Path], **kwargs: Any) -> None:
+    """Save data to a json file.
+
+    Parameters
+    ----------
+    data : list
+        Data to be stored in a json file.
+    json_file : str
+        Path to output json file.
+    kwargs:
+        Additional keyword arguments for json.dump (e.g. indent=4, sort_keys=True).
+
+    """
+    # Ensure json_file is a path.
+    json_file = Path(json_file)
+
+    # Ensure output directory exists.
+    json_file.parent.mkdir(parents=True, exist_ok=True)
+
+    with open(json_file, "w") as _json_file:
+        json.dump(data, _json_file, **kwargs)

owid/datautils/ui.py

@@ -0,0 +1,32 @@
+"""Nice console UI helpers."""
+
+import sys
+from typing import NoReturn
+
+import click
+
+
+def log(action: str, message: str) -> None:
+    """Log message."""
+    action = f"{action:20s}"
+    click.echo(f"{blue(action)}{message}")
+
+
+def bail(message: str) -> NoReturn:
+    """Print an error message then exit."""
+    print(f'{red("ERROR:")} {message}', file=sys.stderr)
+    sys.exit(1)
+
+
+def blue(s: str) -> str:
+    """Add click style (blue color)."""
+    return _colorize(s, fg="blue")
+
+
+def red(s: str) -> str:
+    """Add click style (red color)."""
+    return _colorize(s, fg="red")
+
+
+def _colorize(s: str, fg: str) -> str:
+    return click.style(s, fg=fg)

owid/datautils/web.py

@@ -0,0 +1,106 @@
+"""Web utils."""
+
+import re
+import warnings
+from urllib.parse import urlparse
+
+import requests
+from requests.adapters import HTTPAdapter
+from requests.packages.urllib3.util.ssl_ import create_urllib3_context  # type: ignore
+
+
+def get_base_url(url: str, include_scheme: bool = True) -> str:
+    """Get base URL from an arbitrary URL path (e.g. "https://example.com/some/path" -> "https://example.com").
+
+    If the given URL does not start with "http(s)://"
+
+    Parameters
+    ----------
+    url : str
+        Input URL.
+    include_scheme : bool, optional
+        True to include "http(s)://" at the beginning of the returned base URL.
+        False to hide the "http(s)://" (so that "https://example.com/some/path" -> "example.com").
+
+    Returns
+    -------
+    base_url : str
+        Base URL.
+
+    """
+    # Function urlparse cannot parse a url if it does not start with http(s)://.
+    # If such a url is passed, assume "http://".
+    if not re.match(r"https?://", url):
+        warnings.warn(f"Schema not defined for url {url}; assuming http.")
+        url = f"http://{url}"
+
+    # Parse url, and return the base url either starting with "http(s)://" (if include_scheme is True) or without it.
+    parsed_url = urlparse(url)
+    if include_scheme:
+        base_url = f"{parsed_url.scheme}://{parsed_url.netloc}"
+    else:
+        base_url = parsed_url.netloc
+
+    return base_url
+
+
+class _DESAdapter(HTTPAdapter):  # type: ignore
+    """A TransportAdapter that re-enables Triple DES support in requests.
+
+    From: https://stackoverflow.com/a/46186957/5056599
+
+    """
+
+    ciphers = "HIGH:!DH:!aNULL:DEFAULT@SECLEVEL=1"
+
+    def init_poolmanager(self, *args, **kwargs):  # type: ignore
+        context = create_urllib3_context(ciphers=self.ciphers)
+        kwargs["ssl_context"] = context
+        return super(_DESAdapter, self).init_poolmanager(*args, **kwargs)
+
+    def proxy_manager_for(self, *args, **kwargs):  # type: ignore
+        context = create_urllib3_context(ciphers=self.ciphers)
+        kwargs["ssl_context"] = context
+        return super(_DESAdapter, self).proxy_manager_for(*args, **kwargs)
+
+
+def download_file_from_url(
+    url: str,
+    local_path: str,
+    chunk_size: float = 1024 * 1024,
+    timeout: float = 30,
+    verify: bool = True,
+    ciphers_low: bool = False,
+) -> None:
+    """Download file from a URL into a local file.
+
+    Parameters
+    ----------
+    url : str
+        URL of the file to be downloaded.
+    local_path : str
+        Path to local file that will be created.
+    chunk_size : float, optional
+        Maximum size of the chunks of the response of a request.
+    timeout : float, optional
+        Timeout for standard GET requests.
+    verify : bool, optional
+        Verify SSL certificate for HTTPS requests.
+    ciphers_low : bool, optional
+        Use less restrictive encryption for request (required by certain old web sites).
+
+    """
+    # Create a persistent request session.
+    with requests.Session() as session:
+        if ciphers_low:
+            # Special type of request.
+            session.mount(get_base_url(url), _DESAdapter())
+            response = session.get(url, timeout=timeout)
+        else:
+            # Send a standard GET request.
+            response = session.get(url, stream=True, timeout=timeout, verify=verify)
+
+    # Save the requested data into a local file.
+    with open(local_path, "wb") as output_file:
+        for chunk in response.iter_content(chunk_size=chunk_size):  # type: ignore
+            output_file.write(chunk)

owid_datautils-0.6.1.dist-info/METADATA

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: owid-datautils
+Version: 0.6.1
+Summary: Data utils library by the Data Team at Our World in Data
+Author-email: Our World in Data <tech@ourworldindata.org>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: data cleaning,data processing,data utils,our world in data
+Requires-Python: <4.0,>=3.10
+Requires-Dist: boto3>=1.38.23
+Requires-Dist: click>=8.1.7
+Requires-Dist: colorama>=0.4.4
+Requires-Dist: gdown>=4.5.2
+Requires-Dist: gsheets>=0.6.1
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: py7zr>=0.22.0
+Requires-Dist: pyarrow>=18.0.0
+Requires-Dist: pydrive2>=1.15.0
+Requires-Dist: structlog>=21.5.0
+Requires-Dist: urllib3<2

owid_datautils-0.6.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+owid/datautils/__init__.py,sha256=ApGUd0h-5lbnwXtY1DLhjVBFdbdI-wFEy4LLDKg0Trw,96
+owid/datautils/checks.py,sha256=HGw8hvYVkOrIGE19dpkDUqIyKBiEEViqK2OZr37IsOs,50
+owid/datautils/common.py,sha256=9mSgAAL8NnG4iD6Ysj08Vw2Aw1eyxLA1atWqyDffu7M,1598
+owid/datautils/dataframes.py,sha256=Y0rm436WMlWTK3TSmDqCBFwmyFB-FcFzh8VMDOwUAXI,30794
+owid/datautils/decorators.py,sha256=GD_tk13b6pAjHCvp8KQPZ3zB_XhxzR3Xrfo4LYfDMew,3842
+owid/datautils/ui.py,sha256=pNq0MN1ym7jv-dSQI0AyUo3PZZVHfGERpPEOlOxZKZo,656
+owid/datautils/web.py,sha256=Fd62EIFIXD1PWrEaXVa-91idKtEG_SaImCRUI3kedhU,3522
+owid/datautils/format/__init__.py,sha256=L3lFpSnMs9XyKgymLQF5HILI2q5U4TvhVPh9jNFKXDM,151
+owid/datautils/format/numbers.py,sha256=kJBkN-boLvaOTzDynG8oE5nzsplaaXHRUMFUzMRr6Uc,7970
+owid/datautils/google/__init__.py,sha256=iCGh97I6JhM58Y-MpHeS0zeiRUpC1c6N4FW8A3atWSY,101
+owid/datautils/google/api.py,sha256=xPnqwBcP0Qr7hbxqyN59x0a8Sk4KhsuFrluxAfUpg5M,4380
+owid/datautils/google/config.py,sha256=_6zLgKL-mt7AVesJmvTX0HuuwripmW8Mhwund4YmmRk,4195
+owid/datautils/google/sheets.py,sha256=U45Kfd_--cXLTGXqX9W60VjYTN1Q1ztEKg2zs-1oNy0,4933
+owid/datautils/io/__init__.py,sha256=O15qZVYnA28cznkxKjZX0kPH2Rfaof9-lxtO4ho5w6A,363
+owid/datautils/io/archive.py,sha256=miF3nD8lWA0l59AEHoppGYP_eVc7cYCYE7d2VHlniJs,3087
+owid/datautils/io/df.py,sha256=nx0jJRWsBtHpopKdJ4fKDd1X4oF2y2iUA1_2wyPgQZQ,6526
+owid/datautils/io/json.py,sha256=QlK624POl3fmngi0rnPG_HY2-CSPl1JISYBrzSdcEDs,2334
+owid_datautils-0.6.1.dist-info/METADATA,sha256=wsjXD3JgXdc1E0q89xQQxfyE9lZC3cRPkqZQxCR2oho,652
+owid_datautils-0.6.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+owid_datautils-0.6.1.dist-info/licenses/LICENSE,sha256=h3W2OEglx2jaOj145JoWav12nVTK1kHQm_vIsHayHyc,1079
+owid_datautils-0.6.1.dist-info/RECORD,,

owid_datautils-0.6.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

owid_datautils-0.6.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Global Change Data Lab
+
+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.