mergeron 2025.739319.3__py3-none-any.whl → 2025.739341.8__py3-none-any.whl

mergeron/__init__.py

@@ -1,3 +1,5 @@
+"""Variables, types, objects and functions used throughout the package."""
+
 from __future__ import annotations
 
 import enum
@@ -6,13 +8,14 @@ from multiprocessing import cpu_count
 from pathlib import Path
 from typing import Any, Literal
 
+import attrs
 import numpy as np
 from numpy.typing import NDArray
 from ruamel import yaml
 
-_PKG_NAME: str = Path(__file__).parent.stem
+_PKG_NAME: str = Path(__file__).parent.name
 
-VERSION = "2025.739319.3"
+VERSION = "2025.739341.8"
 
 __version__ = VERSION
 
@@ -34,7 +37,7 @@ EMPTY_ARRAYINT = np.array([], int)
 
 NTHREADS = 2 * cpu_count()
 
-PKG_ATTRS_MAP: dict[str, object] = {}
+PKG_ATTRS_MAP: dict[str, type] = {}
 
 np.set_printoptions(precision=24, floatmode="fixed")
 
@@ -75,23 +78,21 @@ this_yaml.indent(mapping=2, sequence=4, offset=2)
 def yaml_rt_mapper(
     _c: yaml.constructor.RoundTripConstructor, _n: yaml.MappingNode
 ) -> Mapping[str, Any]:
-    """
-    Constructs a mapping from a mapping node with the RoundTripConstructor
-
-    """
+    """Construct mapping from a mapping node with the RoundTripConstructor."""
     data_: Mapping[str, Any] = yaml.constructor.CommentedMap()
     _c.construct_mapping(_n, maptyp=data_, deep=True)
     return data_
 
 
-def yamelize_attrs(
-    _typ: object, /, *, attr_map: Mapping[str, object] = PKG_ATTRS_MAP
-) -> None:
+def yamelize_attrs(_typ: type, /, *, attr_map: dict[str, type] = PKG_ATTRS_MAP) -> None:
     """Add yaml representer, constructor for attrs-defined class.
 
-    Applying this function, attributes with property, `init=False` are
-    not serialized to YAML.
+    Attributes with property, `init=False` are not serialized/deserialized
+    to YAML by the functions defined here. These attributes can, of course,
+    be dumped to stand-alone (YAML) representation, and deserialized from there.
     """
+    if not attrs.has(_typ):
+        raise ValueError(f"Object {_typ} is not attrs-defined")
 
     attr_map |= {_typ.__name__: _typ}
 
@@ -99,9 +100,6 @@ def yamelize_attrs(
         _typ,
         lambda _r, _d: _r.represent_mapping(
             f"!{_d.__class__.__name__}",
-            # construct mapping, rather than calling attrs.asdict(),
-            # to use yaml representers defined in this package for
-            # "upstream" objects
             {_a.name: getattr(_d, _a.name) for _a in _d.__attrs_attrs__ if _a.init},
         ),
     )
@@ -113,12 +111,13 @@ def yamelize_attrs(
 
 @this_yaml.register_class
 class Enameled(enum.Enum):
-    """Add YAML representer, constructor for enum.Enum"""
+    """Add YAML representer, constructor for enum.Enum."""
 
     @classmethod
     def to_yaml(
-        cls, _r: yaml.representer.RoundTripRepresenter, _d: object[enum.EnumType]
+        cls, _r: yaml.representer.RoundTripRepresenter, _d: enum.Enum
     ) -> yaml.ScalarNode:
+        """Serialize enumerations by .name, not .value."""
         return _r.represent_scalar(
             f"!{super().__getattribute__(cls, '__name__')}", f"{_d.name}"
         )
@@ -126,8 +125,10 @@ class Enameled(enum.Enum):
     @classmethod
     def from_yaml(
         cls, _c: yaml.constructor.RoundTripConstructor, _n: yaml.ScalarNode
-    ) -> object[enum.EnumType]:
-        return super().__getattribute__(cls, _n.value)
+    ) -> enum.EnumType:
+        """Deserialize enumeration."""
+        retval: enum.EnumType = super().__getattribute__(cls, _n.value)
+        return retval
 
 
 @this_yaml.register_class
@@ -181,10 +182,7 @@ class RECForm(str, Enameled):
 @this_yaml.register_class
 @enum.unique
 class UPPAggrSelector(str, Enameled):
-    """
-    Aggregator for GUPPI and diversion ratio estimates.
-
-    """
+    """Aggregator for GUPPI and diversion ratio estimates."""
 
     AVG = "average"
     CPA = "cross-product-share weighted average"

mergeron/core/__init__.py

@@ -1,3 +1,5 @@
+"""Constants, types, objects and functions used within this sub-package."""
+
 from __future__ import annotations
 
 from collections.abc import Mapping
@@ -8,6 +10,7 @@ from typing import Any
 import mpmath  # type: ignore
 import numpy as np
 from attrs import cmp_using, field, frozen
+from numpy.random import PCG64DXSM
 
 from .. import (  # noqa: TID252
     VERSION,
@@ -20,13 +23,15 @@ from .. import (  # noqa: TID252
 
 __version__ = VERSION
 
+DEFAULT_BITGENERATOR = PCG64DXSM
+
 type MPFloat = mpmath.ctx_mp_python.mpf
-type MPMatrix = mpmath.matrix  # type: ignore
+type MPMatrix = mpmath.matrices.matrices._matrix
 
 
 @frozen
 class GuidelinesBoundary:
-    """Output of a Guidelines boundary function."""
+    """Represents Guidelines boundary analytically."""
 
     coordinates: ArrayDouble
     """Market-share pairs as Cartesian coordinates of points on the boundary."""
@@ -35,8 +40,19 @@ class GuidelinesBoundary:
     """Area under the boundary."""
 
 
+@frozen
+class GuidelinesBoundaryCallable:
+    """A function to generate Guidelines boundary points, along with area and knot."""
+
+    boundary_function: Callable[[ArrayDouble], ArrayDouble]
+    area: float
+    s_naught: float = 0
+
+
 @frozen
 class INVTableData:
+    """Represents individual table of FTC merger investigations data."""
+
     industry_group: str
     additional_evidence: str
     data_array: ArrayBIGINT = field(eq=cmp_using(eq=np.array_equal))
@@ -45,7 +61,7 @@ class INVTableData:
 type INVData = MappingProxyType[
     str, MappingProxyType[str, MappingProxyType[str, INVTableData]]
 ]
-type INVData_in = Mapping[str, Mapping[str, Mapping[str, INVTableData]]]
+type INVData_in = dict[str, dict[str, dict[str, INVTableData]]]
 
 yamelize_attrs(INVTableData)
 
@@ -91,14 +107,14 @@ _, _ = (
 
 def _dict_from_mapping(_p: Mapping[Any, Any], /) -> dict[Any, Any]:
     retval: dict[Any, Any] = {}
-    for _k, _v in _p.items():  # for subit in it:
+    for _k, _v in _p.items():
         retval |= {_k: _dict_from_mapping(_v)} if isinstance(_v, Mapping) else {_k: _v}
     return retval
 
 
 def _mappingproxy_from_mapping(_p: Mapping[Any, Any], /) -> MappingProxyType[Any, Any]:
     retval: dict[Any, Any] = {}
-    for _k, _v in _p.items():  # for subit in it:
+    for _k, _v in _p.items():
         retval |= (
             {_k: _mappingproxy_from_mapping(_v)}
             if isinstance(_v, Mapping)

mergeron/core/empirical_margin_distribution.py

@@ -1,6 +1,4 @@
-"""
-Functions to parse margin data compiled by
-Prof. Aswath Damodaran, Stern School of Business, NYU.
+"""Functions to parse margin data compiled by Prof. Aswath Damodaran, Stern School of Business, NYU.
 
 Provides :func:`margin_data_resampler` for generating margin data
 from an estimated Gaussian KDE from the source (margin) data.
@@ -10,9 +8,8 @@ Data are downloaded or reused from a local copy, on demand.
 For terms of use of Prof. Damodaran's data, please see:
 https://pages.stern.nyu.edu/~adamodar/New_Home_Page/datahistory.html
 
-NOTES
+Notes
 -----
-
 Prof. Damodaran notes that the data construction may not be
 consistent from iteration to iteration. He also notes that,
 "the best use for my data is in real time corporate financial analysis
@@ -36,171 +33,50 @@ price-cost margins fall in the interval :math:`[0, 1]`.
 
 """
 
-import shutil
+import datetime
+import os
+import re
 import zipfile
 from pathlib import Path
 from types import MappingProxyType
 
 import numpy as np
 import urllib3
-from joblib import Parallel, delayed
-from numpy.random import PCG64DXSM, Generator, SeedSequence
+from bs4 import BeautifulSoup
+from joblib import Parallel, delayed  # type: ignore
+from numpy.random import Generator, SeedSequence
+from python_calamine import CalamineWorkbook
 from scipy import stats  # type: ignore
-from xlrd import open_workbook  # type: ignore
 
 from .. import NTHREADS, VERSION, ArrayDouble, this_yaml  # noqa: TID252
 from .. import WORK_DIR as PKG_WORK_DIR  # noqa: TID252
-from .. import data as mdat  # noqa: TID252
-from . import _mappingproxy_from_mapping
+from . import DEFAULT_BITGENERATOR
 
 __version__ = VERSION
 
 WORK_DIR = globals().get("WORK_DIR", PKG_WORK_DIR)
-"""Redefined, in case the user defines WORK_DIR betweeen module imports."""
+"""Redefined, in case the user defines WORK_DIR between module imports."""
 
 MGNDATA_ARCHIVE_PATH = WORK_DIR / "damodaran_margin_data_serialized.zip"
 
 type DamodaranMarginData = MappingProxyType[str, MappingProxyType[str, float | int]]
 
-u3pm = urllib3.PoolManager()
-
-
-def margin_data_getter(  # noqa: PLR0912
-    _table_name: str = "margin",
-    *,
-    data_archive_path: Path = MGNDATA_ARCHIVE_PATH,
-    data_download_flag: bool = False,
-) -> DamodaranMarginData:
-    if _table_name != "margin":  # Not validated for other tables
-        raise ValueError(
-            "This code is designed for parsing Prof. Damodaran's margin tables."
-        )
-
-    data_archive_path = data_archive_path or MGNDATA_ARCHIVE_PATH
-    workbook_path = data_archive_path.parent / f"damodaran_{_table_name}_data.xls"
-    if data_archive_path.is_file() and not data_download_flag:
-        with zipfile.ZipFile(data_archive_path) as _yzip:
-            margin_data_dict = this_yaml.load(
-                _yzip.read(data_archive_path.with_suffix(".yaml").name)
-            )
-        return margin_data_dict
-    elif workbook_path.is_file():
-        workbook_path.unlink()
-        if data_archive_path.is_file():
-            data_archive_path.unlink()
-
-    margin_urlstr = (
-        f"https://pages.stern.nyu.edu/~adamodar/pc/datasets/{_table_name}.xls"
-    )
-    try:
-        chunk_size_ = 1024 * 1024
-        with (
-            u3pm.request(
-                "GET", margin_urlstr, preload_content=False
-            ) as _urlopen_handle,
-            workbook_path.open("wb") as margin_file,
-        ):
-            while True:
-                data_ = _urlopen_handle.read(chunk_size_)
-                if not data_:
-                    break
-                margin_file.write(data_)
-
-        print(f"Downloaded {margin_urlstr} to {workbook_path}.")
-
-    except urllib3.exceptions.MaxRetryError as error_:
-        if isinstance(error_.__cause__, urllib3.exceptions.SSLError):
-            # Works fine with other sites secured with certificates
-            # from the Internet2 CA, such as,
-            # https://snap.stanford.edu/data/web-Stanford.txt.gz
-            print(
-                f"WARNING: Could not establish secure connection to, {margin_urlstr}."
-                "Using bundled copy."
-            )
-            if not workbook_path.is_file():
-                shutil.copy2(mdat.DAMODARAN_MARGIN_WORKBOOK, workbook_path)
-        else:
-            raise error_
-
-    xl_book = open_workbook(workbook_path, ragged_rows=True, on_demand=True)
-    xl_sheet = xl_book.sheet_by_name("Industry Averages")
-
-    margin_dict_in: dict[str, dict[str, float | int]] = {}
-    row_keys: list[str] = []
-    read_row_flag = False
-    for _ridx in range(xl_sheet.nrows):
-        xl_row = xl_sheet.row_values(_ridx)
-        if xl_row[0] == "Industry Name":
-            read_row_flag = True
-            row_keys = xl_row
-            continue
-
-        if not xl_row[0] or not read_row_flag:
-            continue
-
-        xl_row[1] = int(xl_row[1])
-        margin_dict_in[xl_row[0]] = dict(zip(row_keys[1:], xl_row[1:], strict=True))
-
-    margin_dict = _mappingproxy_from_mapping(margin_dict_in)
-    with (
-        zipfile.ZipFile(data_archive_path, "w") as _yzip,
-        _yzip.open(f"{data_archive_path.stem}.yaml", "w") as _yfh,
-    ):
-        this_yaml.dump(margin_dict, _yfh)
-
-    return margin_dict
-
-
-def margin_data_builder(
-    _src_data_dict: DamodaranMarginData | None = None, /
-) -> tuple[ArrayDouble, ArrayDouble]:
-    if _src_data_dict is None:
-        _src_data_dict = margin_data_getter()
-
-    margin_data_wts, margin_data_obs = (
-        _f.flatten()
-        for _f in np.hsplit(
-            np.array([
-                tuple(
-                    _src_data_dict[_g][_h] for _h in ["Number of firms", "Gross Margin"]
-                )
-                for _g in _src_data_dict
-                if not _g.startswith("Total Market")
-                and _g
-                not in {
-                    "Bank (Money Center)",
-                    "Banks (Regional)",
-                    "Brokerage & Investment Banking",
-                    "Financial Svcs. (Non-bank & Insurance)",
-                    "Insurance (General)",
-                    "Insurance (Life)",
-                    "Insurance (Prop/Cas.)",
-                    "Investments & Asset Management",
-                    "R.E.I.T.",
-                    "Retail (REITs)",
-                    "Reinsurance",
-                }
-            ]),
-            2,
-        )
-    )
-
-    margin_wtd_avg = np.average(margin_data_obs, weights=margin_data_wts)
-    # https://www.itl.nist.gov/div898/software/dataplot/refman2/ch2/weighvar.pdf
-    margin_wtd_stderr = np.sqrt(
-        np.average((margin_data_obs - margin_wtd_avg) ** 2, weights=margin_data_wts)
-        * (len(margin_data_wts) / (len(margin_data_wts) - 1))
-    )
-
-    return np.stack([margin_data_obs, margin_data_wts], axis=1, dtype=float), np.round(
-        (
-            margin_wtd_avg,
-            margin_wtd_stderr,
-            margin_data_obs.min(),
-            margin_data_obs.max(),
-        ),
-        8,
+FINANCIAL_INDUSTRIES = {
+    _i.upper()
+    for _i in (
+        "Bank (Money Center)",
+        "Banks (Regional)",
+        "Brokerage & Investment Banking",
+        "Financial Svcs. (Non-bank & Insurance)",
+        "Insurance (General)",
+        "Insurance (Life)",
+        "Insurance (Prop/Cas.)",
+        "Investments & Asset Management",
+        "R.E.I.T.",
+        "Retail (REITs)",
+        "Reinsurance",
     )
+}
 
 
 def margin_data_resampler(
@@ -211,8 +87,7 @@ def margin_data_resampler(
     seed_sequence: SeedSequence | None = None,
     nthreads: int = NTHREADS,
 ) -> ArrayDouble:
-    """
-    Generate draws from the empirical distribution bassed on Prof. Damodaran's margin data.
+    """Generate draws from the empirical distribution based on Prof. Damodaran's margin data.
 
     The empirical distribution is estimated using a Gaussian KDE; the bandwidth
     selected using Silverman's rule is narrowed to reflect that the margin data
@@ -222,7 +97,6 @@ def margin_data_resampler(
 
     Parameters
     ----------
-
     _dist_parms
         Array of margins and firm counts extracted from Prof. Damodaran's margin data
 
@@ -235,12 +109,12 @@ def margin_data_resampler(
 
     nthreads
         Number of threads to use in generating margin data.
+
     Returns
     -------
         Array of margin values
 
     """
-
     _dist_parms = margin_data_builder()[0] if _dist_parms is None else _dist_parms
 
     _seed = seed_sequence or SeedSequence(pool_size=8)
@@ -248,23 +122,204 @@ def margin_data_resampler(
     _x, _w = _dist_parms[:, 0], _dist_parms[:, 1]
 
     margin_kde = stats.gaussian_kde(_x, weights=_w, bw_method="silverman")
+    # preserve multiplicity of modes:
     margin_kde.set_bandwidth(bw_method=margin_kde.factor / 3.0)
 
     if isinstance(sample_size, int):
-        return margin_kde.resample(sample_size, seed=Generator(PCG64DXSM(_seed))).T
+        return margin_kde.resample(
+            sample_size, seed=Generator(DEFAULT_BITGENERATOR(_seed))
+        ).T
 
     elif isinstance(sample_size, tuple) and len(sample_size) == 2:
         ret_array = np.empty(sample_size, float)
 
         _ssz, _ncol = sample_size
-        dat_list = Parallel(n_jobs=min(nthreads, _ncol), prefer="threads")(
-            delayed(margin_kde.resample)(_ssz, seed=Generator(PCG64DXSM(_col_seed)))
+        _threads = min(nthreads, _ncol)
+        dat_list = Parallel(n_jobs=_threads, prefer="threads")(
+            delayed(margin_kde.resample)(
+                _ssz, seed=Generator(DEFAULT_BITGENERATOR(_col_seed))
+            )
             for _col_seed in _seed.spawn(_ncol)
         )
 
         for _i in range(_ncol):
-            ret_array[:, [_i]] = dat_list[_i].T
+            ret_array[:, _i] = dat_list[_i][0]
 
         return ret_array
     else:
         raise ValueError(f"Invalid sample size: {sample_size!r}")
+
+
+def margin_data_builder(
+    _margin_data_dict: DamodaranMarginData | None = None,
+) -> tuple[ArrayDouble, ArrayDouble]:
+    """Derive average firm-counts and gross-margins by industry from source data."""
+    _margin_data_dict = (
+        margin_data_getter() if _margin_data_dict is None else _margin_data_dict
+    )
+    dmd_keys = set()
+    for _k, _v in _margin_data_dict.items():
+        dmd_keys.update(set(_v.keys()))
+    dmd_keys = sorted(dmd_keys)
+
+    dist_parms = np.array([np.nan, np.nan], dtype=float)
+    for _sk in dmd_keys:
+        if _sk in FINANCIAL_INDUSTRIES or _sk.startswith("TOTAL"):
+            continue
+
+        _missing = {"GROSS MARGIN": 0.0, "NUMBER OF FIRMS": 0.0}
+        gm, fc = zip(*[
+            [_v.get(_sk, _missing).get(_f) for _f in _missing]
+            for _k, _v in _margin_data_dict.items()
+        ])
+
+        average_margin, firm_count = np.array(gm, float), np.array(fc, int)
+        # print(firm_count, average_margin)
+        dist_parms = np.vstack((
+            dist_parms,
+            np.array((
+                np.average(
+                    average_margin, weights=(average_margin > 0) * (firm_count > 0)
+                ),
+                np.average(firm_count, weights=(average_margin > 0) * (firm_count > 0)),
+            )),
+        ))
+
+    dist_parms = dist_parms[1:, :]
+
+    obs_, wts_ = (dist_parms[:, _f] for _f in range(2))
+
+    avg_gm, num_firms = np.average(obs_, weights=wts_, returned=True)
+    std_gm = np.sqrt(
+        np.average((obs_ - avg_gm) ** 2, weights=wts_)
+        * num_firms
+        * len(obs_)
+        / ((num_firms - len(obs_)) * (len(obs_) - 1))
+    )
+
+    return dist_parms, np.array([avg_gm, std_gm, obs_.min(), obs_.max()], float)
+
+
+def margin_data_getter(
+    *, data_archive_path: Path | None = None, data_download_flag: bool = False
+) -> DamodaranMarginData:
+    """Download and parse Prof.Damodaran's margin data."""
+    data_archive_path = (
+        MGNDATA_ARCHIVE_PATH if data_archive_path is None else data_archive_path
+    )
+    if data_archive_path.is_file() and not data_download_flag:
+        with zipfile.ZipFile(data_archive_path) as _yzp:
+            margin_data_dict: DamodaranMarginData = this_yaml.load(
+                _yzp.read(data_archive_path.with_suffix(".yaml").name)
+            )
+        return margin_data_dict
+
+    # Get workbooks from source
+    elif data_download_flag or not list(data_archive_path.glob("margin*.xls")):
+        margin_data_downloader()
+
+    # Whitespace cleanup
+    ws_pat = re.compile(r"\s+")
+
+    #  Parse workbooks and save margin data dictionary
+    margin_data_dict = {}
+    for _p in (WORK_DIR / "damodaran_margin_data_archive").iterdir():
+        xl_wbk = CalamineWorkbook.from_path(_p)
+        xl_wks = xl_wbk.get_sheet_by_index(
+            0 if (_p.stem != "margin" and int(_p.stem[-2:]) in {17, 18, 19}) else 1
+        ).to_python()
+        if xl_wks[8][2] != "Gross Margin":
+            raise ValueError("Worksheet does not match expected layout.")
+
+        update = xl_wks[0][1].isoformat()[:10]
+        margin_data_annual = margin_data_dict.setdefault(update, {})
+        row_keys: list[str] = []
+        read_row_flag = False
+        for xl_row in xl_wks:
+            row_key = _s.upper() if isinstance((_s := xl_row[0]), str) else ""
+
+            if ws_pat.sub(" ", row_key) == "INDUSTRY NAME":
+                read_row_flag = True
+                row_keys = [_c.upper() for _c in xl_row]
+                continue
+            elif not read_row_flag or not row_key or row_key.startswith("TOTAL"):
+                continue
+            else:
+                xl_row[1] = int(xl_row[1])
+                margin_data_annual |= MappingProxyType({
+                    row_key: MappingProxyType(
+                        dict(zip(row_keys[1:], xl_row[1:], strict=True))
+                    )
+                })
+
+    damodaran_margin_data = MappingProxyType(margin_data_dict)
+    with (
+        zipfile.ZipFile(data_archive_path, "w") as _yzp,
+        _yzp.open(f"{data_archive_path.stem}.yaml", "w") as _yfh,
+    ):
+        this_yaml.dump(damodaran_margin_data, _yfh)
+
+    return damodaran_margin_data
+
+
+def margin_data_downloader() -> DamodaranMarginData:
+    """Download Prof.Damodaran's margin data."""
+    _u3pm = urllib3.PoolManager(ca_certs=certifi.where())
+    _data_source_url = "https://pages.stern.nyu.edu/~adamodar/pc/datasets/"
+    _archive_source_url = "https://pages.stern.nyu.edu/~adamodar/pc/archives/"
+
+    dest_dir = WORK_DIR / "damodaran_margin_data_archive"
+
+    # Get current-year margin data
+    workbook_name = "margin.xls"
+    workbook_path = dest_dir / workbook_name
+    if workbook_path.is_file():
+        workbook_path.unlink()
+
+    u3pm = urllib3.PoolManager(ca_certs=certifi.where())
+    download_file(u3pm, f"{_data_source_url}{workbook_name}", workbook_path)
+
+    # Get archived margin data
+    workbook_re = re.compile(r"margin(\d{2}).xls")
+    archive_html = _u3pm.request("GET", _archive_source_url).data.decode("utf-8")
+    archive_tree = BeautifulSoup(archive_html, "lxml")
+    for tag in archive_tree.find_all("a"):
+        if (
+            (_r := workbook_re.fullmatch(_w := tag.get("href", "")))
+            and int(_r[1]) > 16
+            and int(_r[1]) not in {98, 99}
+        ):
+            _url, _path = f"{_archive_source_url}{_w}", dest_dir / _w
+            if _path.is_file():
+                _path.unlink()
+
+            download_file(_u3pm, _url, _path)
+
+
+def download_file(_u3pm: urllib3.PoolManager, _url: str, _path: Path) -> None:
+    """Download a a binary file from URL to filesystem path."""
+    chunk_size_ = 1024 * 1024
+    with (
+        _u3pm.request("GET", _url, preload_content=False) as _uh,
+        _path.open("wb") as _fh,
+    ):
+        while True:
+            data_ = _uh.read(chunk_size_)
+            if not data_:
+                break
+            _fh.write(data_)
+    os.utime(
+        _path,
+        times=(
+            (
+                _t := datetime.datetime.strptime(
+                    _uh.headers["Last-Modified"], "%a, %d %b %Y %H:%M:%S %Z"
+                )
+                .astimezone(datetime.UTC)
+                .timestamp()
+            ),
+            _t,
+        ),
+    )
+
+    print(f"Downloaded {_url} to {_path}.")