maxminddb-rust 0.9.0__cp315-cp315-win_amd64.whl

maxminddb_rust/__init__.py

@@ -0,0 +1,5 @@
+from .maxminddb_rust import *
+
+__doc__ = maxminddb_rust.__doc__
+if hasattr(maxminddb_rust, "__all__"):
+    __all__ = maxminddb_rust.__all__

maxminddb_rust/__init__.pyi

@@ -0,0 +1,323 @@
+"""Type stubs for maxminddb_rust.
+
+This module provides a high-performance alternative to the maxminddb Python package,
+implemented in Rust using PyO3 with 100% API compatibility.
+"""
+
+from collections.abc import Iterable, Iterator, Sequence
+from ipaddress import IPv4Address, IPv4Network, IPv6Address, IPv6Network
+from os import PathLike
+from types import TracebackType
+from typing import Any, BinaryIO, Literal
+
+__all__ = [  # noqa: RUF022 - Match the extension export order.
+    "Reader",
+    "Metadata",
+    "InvalidDatabaseError",
+    "open_database",
+    "MODE_AUTO",
+    "MODE_MMAP_EXT",
+    "MODE_MMAP",
+    "MODE_FILE",
+    "MODE_MEMORY",
+    "MODE_FD",
+]
+
+# Mode constants
+MODE_AUTO: Literal[0]
+MODE_MMAP_EXT: Literal[1]
+MODE_MMAP: Literal[2]
+MODE_FILE: Literal[4]
+MODE_MEMORY: Literal[8]
+MODE_FD: Literal[16]
+
+class InvalidDatabaseError(RuntimeError):
+    """Exception raised when the MaxMind DB file is invalid or corrupt."""
+
+class Metadata:
+    """Metadata about a MaxMind DB database."""
+
+    binary_format_major_version: int
+    """The major version number of the binary format used when creating the database."""
+
+    binary_format_minor_version: int
+    """The minor version number of the binary format used when creating the database."""
+
+    build_epoch: int
+    """The Unix epoch timestamp for when the database was built."""
+
+    database_type: str
+    """A string identifying the database type (e.g., 'GeoIP2-City',
+    'GeoLite2-Country')."""
+
+    ip_version: int
+    """The IP version of the data in a database. A value of 4 means IPv4 only; 6
+    supports both IPv4 and IPv6."""
+
+    node_count: int
+    """The number of nodes in the search tree."""
+
+    record_size: int
+    """The record size in bits (24, 28, or 32)."""
+
+    @property
+    def description(self) -> dict[str, str]:
+        """A dictionary from locale codes to the database description in that locale."""
+
+    @property
+    def languages(self) -> list[str]:
+        """List the locale codes supported by the database."""
+
+    @property
+    def node_byte_size(self) -> int:
+        """The size of a node in bytes."""
+
+    @property
+    def search_tree_size(self) -> int:
+        """The size of the search tree in bytes."""
+
+class Reader:
+    """A MaxMind DB database reader.
+
+    Provides methods to query IP address information from MaxMind DB files.
+    Supports memory-mapped files (MODE_AUTO/MODE_MMAP/MODE_MMAP_EXT) and
+    read-file modes (MODE_FILE/MODE_MEMORY/MODE_FD). MODE_AUTO currently
+    resolves to MODE_MMAP, and MODE_MMAP_EXT uses the same Rust memory-mapped
+    reader as MODE_MMAP.
+    """
+
+    def __init__(
+        self, database: str | PathLike[str] | BinaryIO, mode: int = ...
+    ) -> None:
+        """Initialize a Reader for a MaxMind DB file.
+
+        Args:
+            database: Path to the MaxMind DB file, or a readable binary object
+                for MODE_FD. Raw integer OS file descriptors are not accepted.
+            mode: The mode to use when opening the database. Defaults to MODE_AUTO.
+
+        Raises:
+            FileNotFoundError: If the database file does not exist.
+            IOError: If the database file cannot be read or memory-mapped.
+            InvalidDatabaseError: If the file is not a valid MaxMind DB file.
+            ValueError: If an unsupported mode is specified.
+
+        """
+
+    @property
+    def closed(self) -> bool:
+        """True if the database has been closed, False otherwise."""
+
+    def get(self, ip_address: str | IPv4Address | IPv6Address) -> Any | None:  # noqa: ANN401 - Records have database-defined shapes.
+        """Query the database for information about an IP address.
+
+        Args:
+            ip_address: The IP address to look up. May be a string (e.g., '1.2.3.4')
+                or an ipaddress.IPv4Address or ipaddress.IPv6Address object.
+
+        Returns:
+            The database record value for the IP address, or None if the address
+            is not in the database.
+
+        Raises:
+            ValueError: If the database has been closed or the IP address is invalid.
+            InvalidDatabaseError: If the database data is corrupt or invalid.
+
+        """
+
+    def get_with_prefix_len(
+        self, ip_address: str | IPv4Address | IPv6Address
+    ) -> tuple[Any | None, int]:
+        """Look up an IP address and its network prefix length.
+
+        Args:
+            ip_address: The IP address to look up. May be a string (e.g., '1.2.3.4')
+                or an ipaddress.IPv4Address or ipaddress.IPv6Address object.
+
+        Returns:
+            A tuple of (record, prefix_length) where record is the database
+            record value (or None if not found), and prefix_length is an integer
+            representing the network prefix length associated with the record.
+
+        Raises:
+            ValueError: If the database has been closed or the IP address is invalid.
+            InvalidDatabaseError: If the database data is corrupt or invalid.
+
+        """
+
+    def get_path(
+        self,
+        ip_address: str | IPv4Address | IPv6Address,
+        path: Sequence[str | int],
+    ) -> Any | None:  # noqa: ANN401 - Records have database-defined shapes.
+        """Query the database for a specific path within the record.
+
+        This method is more efficient than get() when you only need a specific field
+        (e.g., country code) from the record, as it avoids decoding the entire record.
+
+        Args:
+            ip_address: The IP address to look up.
+            path: A sequence (tuple or list) of strings or integers
+            representing the path to the data.
+
+        Returns:
+            The value at the specified path, or None if the IP address or
+            path is not found.
+
+        Example:
+            >>> reader.get_path('8.8.8.8', ('country', 'iso_code'))
+            'US'
+            >>> reader.get_path('8.8.8.8', ('subdivisions', 0, 'iso_code'))
+            'CA'
+
+        """
+
+    def get_many(
+        self, ips: Iterable[str | IPv4Address | IPv6Address]
+    ) -> list[Any | None]:
+        """Query the database for multiple IP addresses in a single batch operation.
+
+        This is an extension method not available in the original maxminddb module.
+        It provides better performance than calling get() repeatedly by reducing
+        call overhead. This method keeps the GIL for the duration of the batch.
+
+        Args:
+            ips: An iterable of IP address strings or ipaddress objects to look up
+                (e.g., ['1.2.3.4', '8.8.8.8']).
+
+        Returns:
+            A list of database record values for each IP address.
+            Elements will be None for IP addresses not found in the database.
+            The order of results matches the order of input IPs.
+
+        Raises:
+            ValueError: If the database has been closed or any IP address is invalid.
+            InvalidDatabaseError: If the database data is corrupt or invalid.
+
+        """
+
+    def get_many_path(
+        self,
+        ips: Iterable[str | IPv4Address | IPv6Address],
+        path: Sequence[str | int],
+    ) -> list[Any | None]:
+        """Query the database for a specific path for multiple IP addresses.
+
+        This extension combines get_many() batching with get_path() selective
+        decoding. It parses the path once and avoids decoding full records when
+        only one field is needed.
+
+        Args:
+            ips: An iterable of IP address strings or ipaddress objects to look up
+                (e.g., ['1.2.3.4', '8.8.8.8']).
+            path: A sequence of strings or integers representing the path to the data.
+
+        Returns:
+            A list of values at the specified path. Elements will be None for IP
+            addresses or paths not found in the database.
+
+        Raises:
+            ValueError: If the database has been closed or any IP address is invalid.
+            InvalidDatabaseError: If the database data is corrupt or invalid.
+
+        """
+
+    def metadata(self) -> Metadata:
+        """Get metadata about the MaxMind DB database.
+
+        Returns:
+            A Metadata object containing information about the database.
+
+        Raises:
+            OSError: If the database has been closed.
+
+        """
+
+    def close(self) -> None:
+        """Close the database and release resources.
+
+        Closes the MaxMind DB file handle and releases associated resources.
+        After calling this method, attempting to call get() or other query
+        methods will raise a ValueError.
+        """
+
+    def __enter__(self) -> Reader:  # noqa: PYI034 - Reader cannot be subclassed.
+        """Enter the context manager (for use with 'with' statement).
+
+        Returns:
+            The Reader object itself.
+
+        Raises:
+            ValueError: If attempting to reopen a closed database.
+
+        """
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Exit the context manager (for use with 'with' statement).
+
+        Automatically closes the database when exiting the 'with' block.
+        """
+
+    def __iter__(
+        self,
+    ) -> Iterator[tuple[IPv4Network | IPv6Network, Any]]:
+        """Iterate over all networks in the database.
+
+        Returns an iterator that yields (network, data) tuples for all networks
+        in the database. Networks are represented as ipaddress.IPv4Network or
+        ipaddress.IPv6Network objects.
+
+        Yields:
+            Tuples of (network, record) for each entry in the database.
+
+        Raises:
+            ValueError: If the database has been closed.
+
+        """
+
+def open_database(database: str | PathLike[str] | BinaryIO, mode: int = ...) -> Reader:
+    """Open a MaxMind DB database file.
+
+    Args:
+        database: Path to the MaxMind DB file, or a readable binary object for
+            MODE_FD. Raw integer OS file descriptors are not accepted.
+        mode: The mode to use when opening the database. Defaults to MODE_AUTO.
+            Available modes:
+            - MODE_AUTO (0): Currently resolves to MODE_MMAP
+            - MODE_MMAP (2): Use memory-mapped file I/O (default, best performance)
+            - MODE_MMAP_EXT (1): Compatibility alias for the same Rust mmap
+              reader as MODE_MMAP
+            - MODE_FILE (4): Read the database file into memory
+            - MODE_MEMORY (8): Load entire database into memory
+            - MODE_FD (16): Read bytes from a file-like object into memory
+
+    Returns:
+        A Reader object that can be used to query the database.
+
+    Raises:
+        FileNotFoundError: If the database file does not exist.
+        IOError: If the database file cannot be read or memory-mapped.
+        InvalidDatabaseError: If the file is not a valid MaxMind DB file.
+        ValueError: If an unsupported mode is specified.
+
+    Example:
+        >>> import maxminddb_rust
+        >>> reader = maxminddb_rust.open_database('/path/to/GeoIP2-City.mmdb')
+        >>> reader.get('8.8.8.8')
+        {'city': {'names': {'en': 'Mountain View'}}, ...}
+        >>> reader.close()
+
+        >>> # Using context manager
+        >>> with maxminddb_rust.open_database('/path/to/GeoIP2-City.mmdb') as reader:
+        ...     result = reader.get('8.8.8.8')
+
+        >>> # Specify mode explicitly
+        >>> reader = maxminddb_rust.open_database('/path/to/GeoIP2-City.mmdb',
+        ...                                       mode=maxminddb_rust.MODE_MEMORY)
+
+    """

maxminddb_rust-0.9.0.dist-info/METADATA

@@ -0,0 +1,334 @@
+Metadata-Version: 2.4
+Name: maxminddb-rust
+Version: 0.9.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: WebAssembly :: Emscripten
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: ISC License (ISCL)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Database
+Classifier: Topic :: Internet
+Requires-Dist: pytest>=8.4.2,<9.0.0 ; python_full_version < '3.10' and extra == 'test'
+Requires-Dist: pytest>=9.0.2 ; python_full_version >= '3.10' and extra == 'test'
+Provides-Extra: test
+License-File: LICENSE
+Summary: Rust-based Python binding for MaxMind DB - high-performance alternative to maxminddb
+Keywords: maxmind,geoip,geolocation,ip-address,mmdb
+Author-email: Gregory Oschwald <oschwald@gmail.com>
+License: ISC
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Bug Tracker, https://github.com/oschwald/maxminddb-rust-python/issues
+Project-URL: Changelog, https://github.com/oschwald/maxminddb-rust-python/blob/main/CHANGELOG.md
+Project-URL: Contributing, https://github.com/oschwald/maxminddb-rust-python/blob/main/CONTRIBUTING.md
+Project-URL: Homepage, https://github.com/oschwald/maxminddb-rust-python
+Project-URL: Migration Guide, https://github.com/oschwald/maxminddb-rust-python/blob/main/MIGRATION.md
+Project-URL: Repository, https://github.com/oschwald/maxminddb-rust-python
+
+# maxminddb-rust
+
+A Rust-backed Python module for reading MaxMind DB files.
+
+It mirrors the public API of the official
+[`maxminddb`](https://github.com/maxmind/MaxMind-DB-Reader-python) package and
+keeps the same programming model with the `maxminddb_rust` import name.
+
+## Performance
+
+This project is intended to provide performance comparable to the `maxminddb` C
+extension while keeping API compatibility.
+
+Performance depends on the database, lookup pattern, and hardware. Run the
+benchmark scripts in `benchmarks/` against your own databases to measure
+expected throughput in your environment.
+
+The reader is thread-safe and can be shared across threads. On standard CPython
+builds, CPU-bound lookups from Python threads remain constrained by the GIL.
+Free-threaded CPython 3.14 and 3.15 wheels allow lookup threads to run concurrently;
+scaling depends on the database and workload.
+
+## Features
+
+### API Compatibility
+
+This package provides API compatibility with the official
+[`maxminddb`](https://github.com/maxmind/MaxMind-DB-Reader-python) Python
+module.
+
+Supported:
+
+- `Reader` class with `get()`, `get_with_prefix_len()`, `metadata()`, and
+  `close()` methods
+- `open_database()` function
+- Context manager support (`with` statement)
+- MODE\_\* constants (`MODE_AUTO`, `MODE_MMAP`, `MODE_MMAP_EXT`, `MODE_FILE`,
+  `MODE_MEMORY`, and `MODE_FD`)
+- `InvalidDatabaseError` exception
+- `Metadata` class with all attributes and computed properties
+- Support for string IP addresses and `ipaddress.IPv4Address`/`IPv6Address`
+  objects
+- `closed` attribute
+- Iterator support (`__iter__`) for iterating all database records
+
+Extensions (not in the original package):
+
+- `get_many()` for batch lookups
+- `get_path()` for retrieving a specific field from a record (for example,
+  `('country', 'iso_code')`) without decoding the entire record
+- `get_many_path()` for retrieving a specific field for many IP addresses
+
+## Installation
+
+### From PyPI
+
+```bash
+pip install maxminddb-rust
+```
+
+### From Source
+
+```bash
+git clone https://github.com/oschwald/maxminddb-rust-python.git
+cd maxminddb-rust-python
+uv run --with maturin maturin develop --release
+```
+
+## Usage
+
+This module follows the same API as `maxminddb`, with a different import name:
+
+```python
+import ipaddress
+
+import maxminddb_rust
+
+# Open the database and release resources automatically when done.
+with maxminddb_rust.open_database("/var/lib/GeoIP/GeoIP2-City.mmdb") as reader:
+    result = reader.get("8.8.8.8")
+    print(result)
+
+    result, prefix_len = reader.get_with_prefix_len("8.8.8.8")
+    print(f"Result: {result}, Prefix: {prefix_len}")
+
+    ip = ipaddress.IPv4Address("8.8.8.8")
+    result = reader.get(ip)
+    print(result)
+
+    metadata = reader.metadata()
+    print(f"Database type: {metadata.database_type}")
+    print(f"Node count: {metadata.node_count}")
+```
+
+### Batch Lookup (Extension)
+
+`get_many()` is an extension that is not available in the original `maxminddb`
+module:
+
+```python
+import maxminddb_rust
+
+with maxminddb_rust.open_database("/var/lib/GeoIP/GeoIP2-City.mmdb") as reader:
+    ips = ["8.8.8.8", "1.1.1.1", "208.67.222.222"]
+    results = reader.get_many(ips)
+
+    for ip, result in zip(ips, results):
+        print(f"{ip}: {result}")
+```
+
+### Selective Field Lookup (Extension)
+
+`get_path()` retrieves a specific field from a record:
+
+```python
+import maxminddb_rust
+
+with maxminddb_rust.open_database("/var/lib/GeoIP/GeoIP2-City.mmdb") as reader:
+    # Retrieve a specific field without decoding the entire record.
+    # Path elements can be strings (map keys) or integers (array indices).
+    iso_code = reader.get_path("8.8.8.8", ("country", "iso_code"))
+    print(f"ISO Code: {iso_code}")
+
+    subdivision = reader.get_path("8.8.8.8", ("subdivisions", 0, "iso_code"))
+    print(f"Subdivision: {subdivision}")
+
+    ips = ["8.8.8.8", "1.1.1.1", "208.67.222.222"]
+    iso_codes = reader.get_many_path(ips, ("country", "iso_code"))
+    print(iso_codes)
+```
+
+### Iterator Support
+
+Iterate over all networks in the database:
+
+```python
+import maxminddb_rust
+
+with maxminddb_rust.open_database("/var/lib/GeoIP/GeoLite2-Country.mmdb") as reader:
+    for network, data in reader:
+        print(f"{network}: {data['country']['iso_code']}")
+```
+
+### Database Modes
+
+Choose between memory-mapped files (default) and read-file modes:
+
+```python
+import maxminddb_rust
+
+# MODE_AUTO: currently resolves to MODE_MMAP.
+reader = maxminddb_rust.open_database(
+    "/var/lib/GeoIP/GeoIP2-City.mmdb", mode=maxminddb_rust.MODE_AUTO
+)
+
+# MODE_MMAP: explicitly use memory-mapped files.
+reader = maxminddb_rust.open_database(
+    "/var/lib/GeoIP/GeoIP2-City.mmdb", mode=maxminddb_rust.MODE_MMAP
+)
+
+# MODE_MMAP_EXT: accepted for compatibility; same Rust mmap reader as MODE_MMAP.
+reader = maxminddb_rust.open_database(
+    "/var/lib/GeoIP/GeoIP2-City.mmdb", mode=maxminddb_rust.MODE_MMAP_EXT
+)
+
+# MODE_MEMORY: load the database file into memory.
+reader = maxminddb_rust.open_database(
+    "/var/lib/GeoIP/GeoIP2-City.mmdb", mode=maxminddb_rust.MODE_MEMORY
+)
+
+# MODE_FILE: compatibility mode that also reads the file into memory.
+reader = maxminddb_rust.open_database(
+    "/var/lib/GeoIP/GeoIP2-City.mmdb", mode=maxminddb_rust.MODE_FILE
+)
+
+# MODE_FD: read from a file-like object into memory.
+with open("/var/lib/GeoIP/GeoIP2-City.mmdb", "rb") as database:
+    reader = maxminddb_rust.open_database(database, mode=maxminddb_rust.MODE_FD)
+```
+
+`MODE_FD` follows the official package's pure Python behavior: pass a readable
+binary object and the reader calls `read()` from its current position. Raw
+integer OS file descriptors are not accepted directly.
+
+`MODE_MMAP_EXT` is accepted for official-package compatibility. This package
+does not have a separate C extension backend, so it uses the same Rust
+memory-mapped reader as `MODE_MMAP`.
+
+## Examples
+
+The `examples/` directory contains complete working examples:
+
+- **[basic_usage.py](examples/basic_usage.py)**: simple IP lookups, metadata
+  access, and database lifecycle
+- **[context_manager.py](examples/context_manager.py)**:
+  using `with` for automatic cleanup
+- **[iterator_demo.py](examples/iterator_demo.py)**:
+  iterating over all networks in the database
+- **[batch_processing.py](examples/batch_processing.py)**: batch lookups with
+  `get_many()`
+
+Run any example:
+
+```bash
+uv run python examples/basic_usage.py
+uv run python examples/batch_processing.py
+```
+
+## Documentation
+
+- **API documentation**: classes and methods include docstrings. Use `help()`:
+
+  ```python
+  import maxminddb_rust
+
+  help(maxminddb_rust.open_database)
+  help(maxminddb_rust.Reader.get)
+  ```
+
+- **Type hints**: full type stub file (`maxminddb_rust.pyi`) is included for
+  IDE autocomplete and type checking
+- **Changelog**: see [CHANGELOG.md](CHANGELOG.md) for version history and
+  release notes
+- **Migration Guide**: see [MIGRATION.md](MIGRATION.md) for migrating from the
+  official `maxminddb` package
+
+## Benchmarking
+
+Benchmark scripts are consolidated in the `benchmarks/` directory.
+They default to commonly installed databases under `/var/lib/GeoIP`, preferring
+GeoLite2 City when available. Pass `--file /path/to/database.mmdb` to benchmark
+a different database. The comprehensive benchmark accepts `--file` more than
+once.
+
+Run the included benchmarks after building from source:
+
+```bash
+# Single lookup benchmark
+uv run python benchmarks/benchmark.py --count 250000
+
+# Comprehensive benchmark across multiple databases
+uv run python benchmarks/benchmark_comprehensive.py --count 250000
+
+# Batch lookup benchmark
+uv run python benchmarks/benchmark_batch.py --batch-size 100
+
+# Threaded lookup benchmark (shared Reader across Python threads, default DB set)
+uv run python benchmarks/benchmark_parallel.py --count 500000 --workers 1,2,4,8
+
+# get() vs get_path() benchmark
+uv run python benchmarks/benchmark_path.py --count 250000
+
+# Compare benchmark throughput between two git refs
+uv run python benchmarks/compare_refs.py --baseline-ref origin/main --candidate-ref HEAD
+
+# CI-friendly comparison with JSON output and a 5% regression threshold
+uv run python benchmarks/compare_refs.py --json-output bench.json --max-regression-pct 5
+
+# Force successful lookups, including when using a sparse test database
+uv run python benchmarks/compare_refs.py --workload database-hits
+
+# Path cache profiling: cached tuple, new tuple per call, list path per call
+uv run python benchmarks/compare_refs.py --case get_path --case get_path_new_tuple --case get_path_list
+```
+
+## Testing
+
+This project includes Python tests, Rust unit tests, and adapted upstream
+compatibility tests from
+[MaxMind-DB-Reader-python](https://github.com/maxmind/MaxMind-DB-Reader-python).
+
+```bash
+# Initialize test data submodule (first time only)
+git submodule update --init --recursive
+
+# Run Python tests.
+uv run pytest
+
+# Run Rust unit tests.
+cargo test --all-targets --all-features
+
+# Run configured linters and formatters.
+uv run precious lint .
+```
+
+For upstream test compatibility and syncing instructions, see
+[tests/maxmind/README.md](tests/maxmind/README.md).
+
+## License
+
+ISC License. See [LICENSE](LICENSE) for details.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, code quality
+guidelines, and pull request procedures.
+

maxminddb_rust-0.9.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+maxminddb_rust/__init__.py,sha256=CdGbXQ9SetxY7Dc9As9djUQOGHvkWXUQ3rVc2FdG3XY,139
+maxminddb_rust/__init__.pyi,sha256=IqJ4Qtf-bi9HUxoss-H4sF9R9AS4IvIa8Qopmy-VFic,11800
+maxminddb_rust/maxminddb_rust.cp315-win_amd64.pyd,sha256=uL0cP598uVfRCwH_kldfFZri1yFSquoLVjnfvLxBVIs,674816
+maxminddb_rust/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maxminddb_rust-0.9.0.dist-info/METADATA,sha256=S89D-owe959YZA9lQQiX1ElhRf1i4XDOCDtrPj16hDs,11519
+maxminddb_rust-0.9.0.dist-info/WHEEL,sha256=Q5QdGvjBfn8x6ihg-B4VQuuGKk7DT67L9DVrwEH_qj8,97
+maxminddb_rust-0.9.0.dist-info/licenses/LICENSE,sha256=UXMzEE2L7LGBOeGjwe5NcFoX7waI76pJwJY0rohW-k4,787
+maxminddb_rust-0.9.0.dist-info/sboms/maxminddb-rust.cyclonedx.json,sha256=lwFmgOpOy8Yfv-AOfyhYtzsWt9TeT1yS-tbjkmt0NBg,31681
+maxminddb_rust.pyi,sha256=IqJ4Qtf-bi9HUxoss-H4sF9R9AS4IvIa8Qopmy-VFic,11800
+py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maxminddb_rust-0.9.0.dist-info/RECORD,,

maxminddb_rust-0.9.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.16.0)
+Root-Is-Purelib: false
+Tag: cp315-cp315-win_amd64