ne-loader 0.3.2__tar.gz → 0.4__tar.gz

{ne_loader-0.3.2 → ne_loader-0.4}/PKG-INFO

@@ -1,17 +1,20 @@
 Metadata-Version: 2.4
 Name: ne-loader
-Version: 0.3.2
+Version: 0.4
 Summary: A simple loader for Natural Earth map data.
 Author-email: Eric Tunn <erictunn@icloud.com>
 Project-URL: Homepage, https://github.com/erictunn/ne-loader
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: geopandas>=0.12
 Requires-Dist: platformdirs>=4
 Requires-Dist: requests>=2.25
+Requires-Dist: click>=8.4
 
 # NE Loader
 
+[![CI](https://github.com/erictunn/NE_loader_package/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/erictunn/NE_loader_package/actions/workflows/ci.yml)
+
 A simple, robust Python package to download and load Natural Earth map data using GeoPandas.
 
 ## Features
@@ -54,6 +57,40 @@ To set an environment override for the NE data save path:
 export NATURAL_EARTH_CACHE_DIR="..."
 ```
 
+Some commands include:  
+List cached datasets.  
+
+```bash
+ne-loader list
+```
+
+Query where the cached datasets are.  
+If you change NATURAL_EARTH_CACHE_DIR, the command shows the active cache path for the current environment.
+
+```bash
+ne-loader where
+```
+
+Download a Natural Earth Dataset. Default resolution is 10m.
+
+```bash
+ne-loader download {category} {name} --res {res}
+```
+
+Example usage to download 10m_admin_0_countries
+
+```bash
+ne-loader download cultural admin_0_countries
+```
+
+Delete either one dataset or all, from current cache directory.
+
+```bash
+ne-loader rm {dataset}
+# or
+ne-loader rm --all
+```
+
 ## Tests
 
 ```bash

ne_loader-0.4/README.md

@@ -0,0 +1,89 @@
+# NE Loader
+
+[![CI](https://github.com/erictunn/NE_loader_package/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/erictunn/NE_loader_package/actions/workflows/ci.yml)
+
+A simple, robust Python package to download and load Natural Earth map data using GeoPandas.
+
+## Features
+
+- Download and cache Natural Earth datasets
+- Load shapefiles as GeoDataFrames
+
+## Installation
+
+```bash
+pip install ne-loader
+```
+
+## Usage
+
+```python
+from ne_loader import map_loader
+world = map_loader.get_natural_earth('cultural', 'admin_0_countries')
+```
+
+Errors are raised by default. To return the caught exception instead:
+
+```python
+result = map_loader.get_natural_earth(
+    'cultural',
+    'admin_0_countries',
+    error_mode='return',
+)
+```
+
+## CLI
+
+```bash
+ne-loader --help
+```
+
+To set an environment override for the NE data save path:
+
+```bash
+export NATURAL_EARTH_CACHE_DIR="..."
+```
+
+Some commands include:  
+List cached datasets.  
+
+```bash
+ne-loader list
+```
+
+Query where the cached datasets are.  
+If you change NATURAL_EARTH_CACHE_DIR, the command shows the active cache path for the current environment.
+
+```bash
+ne-loader where
+```
+
+Download a Natural Earth Dataset. Default resolution is 10m.
+
+```bash
+ne-loader download {category} {name} --res {res}
+```
+
+Example usage to download 10m_admin_0_countries
+
+```bash
+ne-loader download cultural admin_0_countries
+```
+
+Delete either one dataset or all, from current cache directory.
+
+```bash
+ne-loader rm {dataset}
+# or
+ne-loader rm --all
+```
+
+## Tests
+
+```bash
+python3 -m pytest tests
+```
+
+## License
+
+MIT

{ne_loader-0.3.2 → ne_loader-0.4}/pyproject.toml

@@ -5,20 +5,24 @@ build-backend = "setuptools.build_meta"
 [tool.setuptools.packages.find]
 where = ["src"]
 
+[tool.setuptools.package-data]
+ne_loader = ["py.typed"]
+
 [project]
 name = "ne-loader"
-version = "0.3.2"
+version = "0.4"
 description = "A simple loader for Natural Earth map data."
 authors = [
     { name = "Eric Tunn", email = "erictunn@icloud.com" }
 ]
 readme = "README.md"
 license = { file = "LICENSE" }
-requires-python = ">=3.8"
+requires-python = ">=3.10"
 dependencies = [
     "geopandas>=0.12",
     "platformdirs>=4",
-    "requests>=2.25"
+    "requests>=2.25",
+    "click>=8.4"
 ]
 
 [project.urls]

ne_loader-0.4/src/ne_loader/__init__.py

@@ -0,0 +1,8 @@
+"""Natural Earth Loader package.
+
+See map_loader.py for public API entrypoint.
+"""
+
+from .map_loader import get_natural_earth, Resolution
+
+__all__ = ["get_natural_earth", "Resolution"]

{ne_loader-0.3.2 → ne_loader-0.4}/src/ne_loader/cacher.py

@@ -2,15 +2,14 @@
 
 import os
 from pathlib import Path
-from typing import Optional, Union
 
 from platformdirs import user_cache_dir
 
 
-PathLike = Union[str, Path]
+PathLike = str | Path
 
 
-def get_cache_dir(path_override: Optional[PathLike] = None) -> Path:
+def get_cache_dir(path_override: PathLike | None = None) -> Path:
     """Return the directory used to cache Natural Earth downloads.
 
     Cache directory in order of precedence:
@@ -27,7 +26,7 @@ def get_cache_dir(path_override: Optional[PathLike] = None) -> Path:
     if path_override:
         return Path(path_override).expanduser()
 
-    env_path: Optional[str] = os.getenv("NATURAL_EARTH_CACHE_DIR")
+    env_path: str | None = os.getenv("NATURAL_EARTH_CACHE_DIR")
     if env_path:
         return Path(env_path).expanduser()
 

ne_loader-0.4/src/ne_loader/cli.py

@@ -0,0 +1,71 @@
+"""Provides basic command line functionality."""
+
+import click
+import shutil
+
+from . import map_loader
+from .cacher import get_cache_dir
+
+
+@click.group()
+def main() -> None:
+    """Entry point for the ne-loader CLI."""
+
+
+@main.command("download")
+@click.argument("category")
+@click.argument("name")
+@click.option("--res", default="10m", help="NE dataset resolution (default: 10m)")
+def cli_get_natural_earth(category: str, name: str, res: map_loader.Resolution) -> None:
+    """Download a Natural Earth dataset and load it into GeoPandas."""
+    map_loader.get_natural_earth(category, name, res)
+
+@main.command("where")
+def cli_where_cache() -> None:
+    """Locate the cache directory."""
+    cache_dir = get_cache_dir()
+    click.echo(cache_dir)
+
+@main.command("list")
+def cli_list_cached_files() -> None:
+    """List all cached NE files within the cache dir."""
+    cache_dir = get_cache_dir()
+    sub_folders = [f.name for f in cache_dir.iterdir() if f.is_dir()]
+    click.echo(", ".join(sub_folders))
+
+@main.command("rm")
+@click.argument("dataset", required=False)
+@click.option(
+    "--all",
+    "all_",
+    is_flag=True,
+    default=False,
+    help="Remove the entire cache directory instead of a single dataset.",
+)
+def cli_remove_cached_file(dataset: str | None, all_: bool) -> None:
+    """Remove a specific cached dataset, or the entire cache when --all is used."""
+    cache_dir = get_cache_dir()
+
+    if all_:
+        if click.confirm(
+            "Are you sure you want to delete all cached Natural Earth datasets?",
+            default=False,
+        ):
+            shutil.rmtree(cache_dir, ignore_errors=True)
+            click.echo("Removed all cached datasets.")
+        return
+
+    if not dataset:
+        raise click.UsageError("Specify a dataset name to remove or use --all to" \
+        "clear the whole cache.")
+
+    dataset_dir = cache_dir / dataset
+    if not dataset_dir.exists():
+        raise click.ClickException(f"Cached dataset not found: {dataset}")
+
+    if click.confirm(
+        f"Are you sure you want to delete the cached dataset '{dataset}'?",
+        default=False,
+    ):
+        shutil.rmtree(dataset_dir, ignore_errors=True)
+        click.echo(f"Removed cached dataset: {dataset}")

{ne_loader-0.3.2 → ne_loader-0.4}/src/ne_loader/error_handler.py

@@ -1,6 +1,6 @@
 """Helpers for error handling."""
 
-from typing import Literal, NoReturn, Union, overload
+from typing import Literal, NoReturn, overload
 
 ErrorMode = Literal["ignore", "raise", "return"]
 
@@ -20,7 +20,7 @@ def error_handler(error: Exception, error_mode: Literal["raise"]) -> NoReturn: .
 def error_handler(
     error: Exception,
     error_mode: ErrorMode,
-) -> Union[None, Exception]:
+) -> Exception | None:
     """Provide consistent error handling based on standardised error mode.
 
     Args:
@@ -32,7 +32,7 @@ def error_handler(
         ValueError: if error mode is invalid, raises a ValueError.
 
     Returns:
-        Union[None, Exception]: depending on mode, can return None (ignore),
+        Exception | None: depending on mode, can return None (ignore),
             the error object (return) or raise the error again (raise).
 
     """
@@ -45,7 +45,7 @@ def error_handler(
         raise error
 
 
-def validate_error_mode(error_mode: str) -> None:
+def validate_error_mode(error_mode: ErrorMode) -> None:
     """Validate error_mode.
 
     Args:

{ne_loader-0.3.2 → ne_loader-0.4}/src/ne_loader/map_loader.py

@@ -5,7 +5,7 @@ import logging
 import shutil
 import zipfile
 from pathlib import Path
-from typing import Literal, Optional, Union, overload
+from typing import Literal, overload
 
 import geopandas as gpd
 import requests
@@ -54,10 +54,10 @@ def get_natural_earth(
     name: str,
     res: Resolution = "10m",
     *,
-    dir_override: Optional[PathLike] = None,
+    dir_override: PathLike | None = None,
     error_mode: Literal["ignore"],
-    user_logger: Optional[logging.Logger] = None,
-) -> Optional[gpd.GeoDataFrame]: ...
+    user_logger: logging.Logger | None = None,
+) -> gpd.GeoDataFrame | None: ...
 
 
 @overload
@@ -66,9 +66,9 @@ def get_natural_earth(
     name: str,
     res: Resolution = "10m",
     *,
-    dir_override: Optional[PathLike] = None,
+    dir_override: PathLike | None = None,
     error_mode: Literal["raise"] = "raise",
-    user_logger: Optional[logging.Logger] = None,
+    user_logger: logging.Logger | None = None,
 ) -> gpd.GeoDataFrame: ...
 
 
@@ -78,10 +78,10 @@ def get_natural_earth(
     name: str,
     res: Resolution = "10m",
     *,
-    dir_override: Optional[PathLike] = None,
+    dir_override: PathLike | None = None,
     error_mode: Literal["return"],
-    user_logger: Optional[logging.Logger] = None,
-) -> Union[gpd.GeoDataFrame, Exception]: ...
+    user_logger: logging.Logger | None = None,
+) -> gpd.GeoDataFrame | Exception: ...
 
 
 def get_natural_earth(
@@ -89,10 +89,10 @@ def get_natural_earth(
     name: str,
     res: Resolution = "10m",
     *,
-    dir_override: Optional[PathLike] = None,
+    dir_override: PathLike | None = None,
     error_mode: ErrorMode = "raise",
-    user_logger: Optional[logging.Logger] = None,
-) -> Union[gpd.GeoDataFrame, Exception, None]:
+    user_logger: logging.Logger | None = None,
+) -> gpd.GeoDataFrame | Exception | None:
     """Download, cache, and load a Natural Earth vector dataset.
 
     Args:
@@ -129,7 +129,7 @@ def get_natural_earth(
         extract_dir: Path = build_ne_extract_dir(data_dir, name, res)
         shp_file: Path = build_ne_shp_path(data_dir, name, res)
 
-        _download_ne_data(
+        download_ne_data(
             url=url,
             extract_dir=extract_dir,
             name=name,
@@ -142,13 +142,13 @@ def get_natural_earth(
         return gpd.read_file(shp_file)
     except Exception as error:
         logger.error(
-            "ne-loader: error caught fetching data with get_natural_earth():\n",
+            "ne-loader: error caught fetching data with get_natural_earth():%s",
             error,
         )
         return error_handler(error, error_mode)
 
 
-def _download_ne_data(
+def download_ne_data(
     url: str,
     extract_dir: Path,
     name: str,
@@ -178,7 +178,7 @@ def _download_ne_data(
 
     except requests.exceptions.HTTPError as error:
         logger.error(
-            "ne-loader/_download_ne_data(): "
+            "ne-loader/download_ne_data(): "
             "A HTTP error occurred while attempting to fetch data: %s\n"
             "This may cause an error when attempting to load the data.",
             error,
@@ -186,7 +186,7 @@ def _download_ne_data(
         raise
     except requests.exceptions.RequestException as error:
         logger.error(
-            "ne-loader/_download_ne_data(): "
+            "ne-loader/download_ne_data(): "
             "A request error occurred while attempting to fetch data: %s\n"
             "This may cause an error when attempting to load the data.",
             error,
@@ -196,11 +196,13 @@ def _download_ne_data(
     finally:
         with contextlib.suppress(FileNotFoundError):
             zip_path.unlink()
-        if (not shp_file.exists() and
-        extract_dir.name == build_ne_filename(name, res, suffix="")):
+
+        expected_extract_dir = build_ne_filename(name, res, suffix="")
+        if not shp_file.exists() and extract_dir.name == expected_extract_dir:
             shutil.rmtree(extract_dir, ignore_errors=True)
 
-def validate_res(res: str) -> None:
+
+def validate_res(res: Resolution) -> None:
     """Validate the resolution against "10m", "50m", "110m".
 
     Args:
@@ -211,5 +213,7 @@ def validate_res(res: str) -> None:
 
     """
     if res not in ("10m", "50m", "110m"):
-        raise ValueError(f"Invalid resolution: {res}.\
-                         \nResolution must be one of (\"10m\", \"50m\", \"110m\")")
+        raise ValueError(
+            f"Invalid resolution: {res}.\n"
+            'Resolution must be one of ("10m", "50m", "110m")'
+        )

{ne_loader-0.3.2 → ne_loader-0.4}/src/ne_loader.egg-info/PKG-INFO

@@ -1,17 +1,20 @@
 Metadata-Version: 2.4
 Name: ne-loader
-Version: 0.3.2
+Version: 0.4
 Summary: A simple loader for Natural Earth map data.
 Author-email: Eric Tunn <erictunn@icloud.com>
 Project-URL: Homepage, https://github.com/erictunn/ne-loader
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: geopandas>=0.12
 Requires-Dist: platformdirs>=4
 Requires-Dist: requests>=2.25
+Requires-Dist: click>=8.4
 
 # NE Loader
 
+[![CI](https://github.com/erictunn/NE_loader_package/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/erictunn/NE_loader_package/actions/workflows/ci.yml)
+
 A simple, robust Python package to download and load Natural Earth map data using GeoPandas.
 
 ## Features
@@ -54,6 +57,40 @@ To set an environment override for the NE data save path:
 export NATURAL_EARTH_CACHE_DIR="..."
 ```
 
+Some commands include:  
+List cached datasets.  
+
+```bash
+ne-loader list
+```
+
+Query where the cached datasets are.  
+If you change NATURAL_EARTH_CACHE_DIR, the command shows the active cache path for the current environment.
+
+```bash
+ne-loader where
+```
+
+Download a Natural Earth Dataset. Default resolution is 10m.
+
+```bash
+ne-loader download {category} {name} --res {res}
+```
+
+Example usage to download 10m_admin_0_countries
+
+```bash
+ne-loader download cultural admin_0_countries
+```
+
+Delete either one dataset or all, from current cache directory.
+
+```bash
+ne-loader rm {dataset}
+# or
+ne-loader rm --all
+```
+
 ## Tests
 
 ```bash

{ne_loader-0.3.2 → ne_loader-0.4}/src/ne_loader.egg-info/SOURCES.txt

@@ -5,11 +5,14 @@ src/ne_loader/cacher.py
 src/ne_loader/cli.py
 src/ne_loader/error_handler.py
 src/ne_loader/map_loader.py
+src/ne_loader/py.typed
 src/ne_loader.egg-info/PKG-INFO
 src/ne_loader.egg-info/SOURCES.txt
 src/ne_loader.egg-info/dependency_links.txt
 src/ne_loader.egg-info/entry_points.txt
 src/ne_loader.egg-info/requires.txt
 src/ne_loader.egg-info/top_level.txt
+tests/test_cli.py
+tests/test_download_ne_data.py
 tests/test_error_handler.py
 tests/test_map_loader.py

{ne_loader-0.3.2 → ne_loader-0.4}/src/ne_loader.egg-info/requires.txt

@@ -1,3 +1,4 @@
 geopandas>=0.12
 platformdirs>=4
 requests>=2.25
+click>=8.4

ne_loader-0.4/tests/test_cli.py

@@ -0,0 +1,49 @@
+"""Minimal tests for the CLI entrypoint."""
+
+from click.testing import CliRunner
+import pytest
+
+import ne_loader.cli as cli
+from ne_loader.map_loader import Resolution
+from ne_loader.cacher import get_cache_dir
+
+
+def test_cli_delegates_to_get_natural_earth(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Ensure the CLI forwards arguments to map_loader.get_natural_earth."""
+    called = {}
+
+    def fake_get(category: str, name: str, res: Resolution):
+        called["args"] = (category, name, res)
+
+    monkeypatch.setattr(cli.map_loader, "get_natural_earth", fake_get)
+
+    runner = CliRunner()
+    result = runner.invoke(
+        cli.main,
+        ["download", "Cultural", "admin_0_countries", "--res", "50m"],
+    )
+
+    assert result.exit_code == 0
+    assert called["args"] == ("Cultural", "admin_0_countries", "50m")
+
+def test_cli_where_errors() -> None:
+    """Ensure CLI where command returns without error."""
+    runner = CliRunner()
+    result = runner.invoke(
+        cli.main,
+        ["where"],
+    )
+
+    assert result.exit_code == 0
+    assert result.exception is None
+
+def test_cli_where_output() -> None:
+    """Ensure where command output is the same as get_cache_dir()."""
+    true_cache_dir = str(get_cache_dir()).strip()
+
+    runner = CliRunner()
+    result = runner.invoke(
+        cli.main,
+        ["where"],
+    )
+    assert true_cache_dir == str(result.output).strip()

ne_loader-0.4/tests/test_download_ne_data.py

@@ -0,0 +1,127 @@
+"""Tests for natural earth data downloader functions."""
+
+import io
+import logging
+import zipfile
+from collections.abc import Iterator
+from pathlib import Path
+
+import pytest
+import requests
+
+from ne_loader.map_loader import build_ne_filename, download_ne_data, Resolution
+
+
+def _mock_zip_bytes(name: str, res: str) -> bytes:
+    """Build an in-memory Natural Earth zip file containing one shapefile."""
+    buffer = io.BytesIO()
+    with zipfile.ZipFile(buffer, "w") as zip_file:
+        zip_file.writestr(
+            build_ne_filename(name, res, suffix=".shp"),
+            b"mock shp content",
+        )
+    return buffer.getvalue()
+
+
+class MockResponse:
+    """Mock successful response object for the downloader's requests.get call."""
+
+    def __init__(self, data: bytes) -> None:
+        """Store response bytes for chunked streaming."""
+        self._data = data
+
+    def raise_for_status(self) -> None:
+        """Match requests.Response.raise_for_status for a successful response."""
+        return None
+
+    def iter_content(self, chunk_size: int = 8192) -> Iterator[bytes]:
+        """Yield response bytes in the same shape as requests.Response."""
+        for start in range(0, len(self._data), chunk_size):
+            yield self._data[start : start + chunk_size]
+
+
+
+url = "https://example.org/fake.zip"
+name = "admin_0_countries"
+res: Resolution = "10m"
+logger = logging.getLogger("testing")
+
+def test_download_ne_data_success(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Verify download_ne_data writes the extracted shapefile on success."""
+    mocked_zip = _mock_zip_bytes(name, res)
+
+    def mock_get(request_url: str, stream: bool, timeout: int) -> MockResponse:
+        """Return a fake response and verify the downloader's request options."""
+        assert request_url == url
+        assert stream is True
+        assert timeout == 10
+        return MockResponse(mocked_zip)
+
+    monkeypatch.setattr(requests, "get", mock_get)
+    base = tmp_path / "ne-cache"
+    base.mkdir()
+    extract_dir = base / build_ne_filename(name, res, suffix="")
+    zip_path = base / build_ne_filename(name, res)
+    shp_file = extract_dir / build_ne_filename(name, res, suffix=".shp")
+
+    download_ne_data(
+        url=url,
+        extract_dir=extract_dir,
+        name=name,
+        res=res,
+        zip_path=zip_path,
+        shp_file=shp_file,
+        logger=logger,
+    )
+
+    assert shp_file.exists()
+    assert extract_dir.exists()
+    assert not zip_path.exists()
+
+
+class BadResponse:
+    """Mock unsuccessful response for the downloader's requests.get call."""
+
+    def raise_for_status(self) -> None:
+        """Mock the unsuccessful response."""
+        raise requests.exceptions.HTTPError("404 Client Error")
+
+
+def test_download_ne_data_failure(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Tests that download_ne_data leaves no artifacts upon HTTP error."""
+
+    def mock_get(request_url: str, stream: bool, timeout: int) -> BadResponse:
+        """Return a fake response and verify the downloader's request options."""
+        assert request_url == url
+        assert stream is True
+        assert timeout == 10
+        return BadResponse()
+
+    monkeypatch.setattr(requests, "get", mock_get)
+
+    base = tmp_path / "ne-cache"
+    base.mkdir()
+    extract_dir = base / build_ne_filename(name, res, suffix="")
+    zip_path = base / build_ne_filename(name, res)
+    shp_file = extract_dir / build_ne_filename(name, res, suffix=".shp")
+
+
+    with pytest.raises(requests.exceptions.HTTPError):
+        download_ne_data(
+            url=url,
+            extract_dir=extract_dir,
+            name=name,
+            res=res,
+            zip_path=zip_path,
+            shp_file=shp_file,
+            logger=logger,
+        )
+
+    assert not zip_path.exists()
+    assert not extract_dir.exists()

{ne_loader-0.3.2 → ne_loader-0.4}/tests/test_map_loader.py

@@ -51,6 +51,9 @@ def test_build_ne_shp_path() -> None:
 
 def test_validate_res() -> None:
     """Tests that validate_res(res=kaboom) raises the correct ValueError."""
-    with pytest.raises(ValueError, match=re.escape(f"Invalid resolution: kaboom.\
-                         \nResolution must be one of (\"10m\", \"50m\", \"110m\")")):
+    expected_message = (
+        'Invalid resolution: kaboom.\n'
+        'Resolution must be one of ("10m", "50m", "110m")'
+    )
+    with pytest.raises(ValueError, match=re.escape(expected_message)):
         validate_res("kaboom")

ne_loader-0.3.2/README.md

@@ -1,53 +0,0 @@
-# NE Loader
-
-A simple, robust Python package to download and load Natural Earth map data using GeoPandas.
-
-## Features
-
-- Download and cache Natural Earth datasets
-- Load shapefiles as GeoDataFrames
-
-## Installation
-
-```bash
-pip install ne-loader
-```
-
-## Usage
-
-```python
-from ne_loader import map_loader
-world = map_loader.get_natural_earth('cultural', 'admin_0_countries')
-```
-
-Errors are raised by default. To return the caught exception instead:
-
-```python
-result = map_loader.get_natural_earth(
-    'cultural',
-    'admin_0_countries',
-    error_mode='return',
-)
-```
-
-## CLI
-
-```bash
-ne-loader --help
-```
-
-To set an environment override for the NE data save path:
-
-```bash
-export NATURAL_EARTH_CACHE_DIR="..."
-```
-
-## Tests
-
-```bash
-python3 -m pytest tests
-```
-
-## License
-
-MIT

ne_loader-0.3.2/src/ne_loader/__init__.py

@@ -1,4 +0,0 @@
-"""Natural Earth Loader package.
-
-See map_loader.py for public API entrypoint.
-"""

ne_loader-0.3.2/src/ne_loader/cli.py

@@ -1,38 +0,0 @@
-"""Provides basic command line functionality."""
-
-import argparse
-
-import geopandas as gpd
-
-from . import map_loader
-
-
-def main() -> None:
-    """Run the Natural Earth loader command-line interface."""
-    parser: argparse.ArgumentParser = argparse.ArgumentParser(
-        description="Download and load Natural Earth data."
-    )
-    parser.add_argument(
-        "category",
-        choices=["cultural", "physical"],
-        help="Data category",
-    )
-    parser.add_argument("name", help="Dataset name (e.g., admin_0_countries)")
-    parser.add_argument("--res", default="10m", help="Resolution (default: 10m)")
-    parser.add_argument("--out", help="Output file to save as GeoJSON (optional)")
-    args: argparse.Namespace = parser.parse_args()
-
-    gdf: gpd.GeoDataFrame = map_loader.get_natural_earth(
-        category=args.category,
-        name=args.name,
-        res=args.res,
-    )
-    if args.out:
-        gdf.to_file(args.out, driver="GeoJSON")
-        print(f"Saved to {args.out}")
-    else:
-        print(gdf.head())
-
-
-if __name__ == "__main__":
-    main()