iporigin 1.0.0__py3-none-any.whl

iporigin/__init__.py

@@ -0,0 +1,51 @@
+"""Tell a datacenter IP from a home connection, offline.
+
+    >>> import iporigin
+    >>> iporigin.classify("52.95.110.1")
+    Origin(ip='52.95.110.1', kind='hosting', provider='Amazon AWS', source='local')
+    >>> iporigin.is_datacenter("8.8.8.8")
+    True
+
+No network calls, no API key: the answer comes from a table compiled from
+the providers' own published feeds. See iporigin.online for the optional
+live lookup that also covers consumer VPN exit nodes.
+"""
+
+from ._data import DatasetError
+from .core import (
+    ANONYMIZER_KINDS,
+    BOT,
+    CDN,
+    DATACENTER_KINDS,
+    HOSTING,
+    RESERVED,
+    TOR,
+    UNKNOWN,
+    VPN,
+    Origin,
+    classify,
+    classify_many,
+    dataset_info,
+    is_datacenter,
+)
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "ANONYMIZER_KINDS",
+    "BOT",
+    "CDN",
+    "DATACENTER_KINDS",
+    "DatasetError",
+    "HOSTING",
+    "Origin",
+    "RESERVED",
+    "TOR",
+    "UNKNOWN",
+    "VPN",
+    "classify",
+    "classify_many",
+    "dataset_info",
+    "is_datacenter",
+    "__version__",
+]

iporigin/_data.py

@@ -0,0 +1,112 @@
+"""Loading and querying the packed range table.
+
+The table is loaded once, lazily, on the first lookup — importing iporigin
+must stay cheap for a program that imports it and never calls it.
+
+Lookups are a bisect over a sorted column of range starts. Ranges never
+overlap within the merged table, so the candidate found by bisect is the
+only one that can contain the address: one comparison decides it.
+"""
+
+import bisect
+import struct
+from array import array
+from pathlib import Path
+
+MAGIC = b"IPORIGIN"
+SUPPORTED_VERSION = 1
+
+DATA_FILE = Path(__file__).parent / "data" / "ranges.bin"
+
+_HEADER = struct.Struct("<8sHQHII")
+_V4_RECORD = struct.Struct("<IIH")
+_V6_RECORD = struct.Struct("<16s16sH")
+
+
+class DatasetError(RuntimeError):
+    """The bundled dataset is missing or unreadable."""
+
+
+class _Dataset:
+    __slots__ = (
+        "built_at", "labels",
+        "v4_starts", "v4_ends", "v4_labels",
+        "v6_starts", "v6_ends", "v6_labels",
+    )
+
+    def __init__(self, blob):
+        magic, version, built_at, n_labels, n_v4, n_v6 = _HEADER.unpack_from(blob, 0)
+        if magic != MAGIC:
+            raise DatasetError("not an iporigin dataset")
+        if version != SUPPORTED_VERSION:
+            raise DatasetError(
+                "dataset format v%d, this build understands v%d — upgrade iporigin"
+                % (version, SUPPORTED_VERSION)
+            )
+
+        self.built_at = built_at
+        offset = _HEADER.size
+
+        self.labels = []
+        for _ in range(n_labels):
+            (length,) = struct.unpack_from("<H", blob, offset)
+            offset += 2
+            provider, _, kind = blob[offset:offset + length].decode("utf-8").partition("\t")
+            self.labels.append((provider, kind))
+            offset += length
+
+        # Parallel arrays rather than tuples: 21k ranges as Python tuples is
+        # several MB of objects, as arrays it is a few hundred KB.
+        self.v4_starts = array("L")
+        self.v4_ends = array("L")
+        self.v4_labels = array("H")
+        for _ in range(n_v4):
+            start, end, label = _V4_RECORD.unpack_from(blob, offset)
+            self.v4_starts.append(start)
+            self.v4_ends.append(end)
+            self.v4_labels.append(label)
+            offset += _V4_RECORD.size
+
+        # IPv6 addresses do not fit a machine word, so these stay Python ints.
+        self.v6_starts = []
+        self.v6_ends = []
+        self.v6_labels = array("H")
+        for _ in range(n_v6):
+            start, end, label = _V6_RECORD.unpack_from(blob, offset)
+            self.v6_starts.append(int.from_bytes(start, "big"))
+            self.v6_ends.append(int.from_bytes(end, "big"))
+            self.v6_labels.append(label)
+            offset += _V6_RECORD.size
+
+    def find(self, value, version):
+        """Return (provider, kind) for an address, or None."""
+        if version == 4:
+            starts, ends, labels = self.v4_starts, self.v4_ends, self.v4_labels
+        else:
+            starts, ends, labels = self.v6_starts, self.v6_ends, self.v6_labels
+
+        index = bisect.bisect_right(starts, value) - 1
+        if index < 0 or value > ends[index]:
+            return None
+        return self.labels[labels[index]]
+
+    def __len__(self):
+        return len(self.v4_starts) + len(self.v6_starts)
+
+
+_loaded = None
+
+
+def dataset():
+    global _loaded
+    if _loaded is None:
+        try:
+            blob = DATA_FILE.read_bytes()
+        except OSError as exc:
+            raise DatasetError(
+                "bundled dataset missing at %s — reinstall iporigin, or run "
+                "tools/build_dataset.py if you are working from a checkout"
+                % DATA_FILE
+            ) from exc
+        _loaded = _Dataset(blob)
+    return _loaded

iporigin/cli.py

@@ -0,0 +1,83 @@
+"""Command line front end: iporigin 8.8.8.8"""
+
+import argparse
+import json
+import sys
+
+from . import __version__, classify, dataset_info
+from .core import DatasetError
+
+
+def _read_addresses(args):
+    if args.ip:
+        return args.ip
+    # No arguments: read from stdin, so `cut -f1 access.log | iporigin` works.
+    return (line.strip() for line in sys.stdin if line.strip())
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        prog="iporigin",
+        description="Classify IP addresses as hosting, CDN, VPN or unknown.",
+    )
+    parser.add_argument("ip", nargs="*", help="addresses to classify (default: stdin)")
+    parser.add_argument("--json", action="store_true", help="output JSON lines")
+    parser.add_argument(
+        "--online",
+        action="store_true",
+        help="also query the free Unblock Master API (covers consumer VPNs)",
+    )
+    parser.add_argument(
+        "--datacenter-only",
+        action="store_true",
+        help="print only addresses that are in a datacenter range",
+    )
+    parser.add_argument("--info", action="store_true", help="show dataset provenance")
+    parser.add_argument("--version", action="version", version="iporigin " + __version__)
+    args = parser.parse_args(argv)
+
+    try:
+        if args.info:
+            print(json.dumps(dataset_info(), indent=2, sort_keys=True))
+            return 0
+
+        lookup = classify
+        if args.online:
+            from .online import classify_online as lookup  # noqa: N813
+
+        exit_code = 0
+        for raw in _read_addresses(args):
+            try:
+                origin = lookup(raw)
+            except ValueError as exc:
+                print("%s: %s" % (raw, exc), file=sys.stderr)
+                exit_code = 2
+                continue
+
+            if args.datacenter_only and not origin.is_datacenter:
+                continue
+
+            if args.json:
+                print(json.dumps({
+                    "ip": origin.ip,
+                    "kind": origin.kind,
+                    "provider": origin.provider,
+                    "source": origin.source,
+                    "is_datacenter": origin.is_datacenter,
+                }))
+            else:
+                print("%-40s %-9s %s" % (origin.ip, origin.kind, origin.provider))
+        return exit_code
+
+    except DatasetError as exc:
+        print("iporigin: %s" % exc, file=sys.stderr)
+        return 1
+    except BrokenPipeError:
+        # `iporigin < big.txt | head` is a normal thing to do.
+        return 0
+    except KeyboardInterrupt:
+        return 130
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

iporigin/core.py

@@ -0,0 +1,116 @@
+"""Classify an IP address by where it is hosted."""
+
+import ipaddress
+from dataclasses import dataclass
+
+from ._data import DatasetError, dataset  # noqa: F401 — re-exported
+
+# What a result can be. Deliberately small: a caller should be able to
+# switch on this exhaustively.
+HOSTING = "hosting"      # a machine in a cloud or hosting provider
+CDN = "cdn"              # edge infrastructure fronting other people's sites
+VPN = "vpn"              # a consumer VPN or private relay exit
+TOR = "tor"              # a Tor exit node
+BOT = "bot"              # a declared crawler (Googlebot, GPTBot, ...)
+RESERVED = "reserved"    # private, loopback, link-local, documentation...
+UNKNOWN = "unknown"      # in no list we have — most often a residential ISP
+
+#: Kinds that mean "this address is a machine, not somebody's home line".
+#: A person browsing through Mullvad is at home, but the address they arrive
+#: from is still a server — this is about the address, not the human.
+DATACENTER_KINDS = frozenset({HOSTING, CDN, VPN, TOR, BOT})
+
+#: Kinds that mean "whoever is behind this is deliberately hidden".
+#: A different decision from DATACENTER_KINDS: you might rate-limit a cloud
+#: IP but refuse a payment from an anonymised one, or the exact reverse.
+ANONYMIZER_KINDS = frozenset({VPN, TOR})
+
+
+@dataclass(frozen=True)
+class Origin:
+    """What we know about an address.
+
+    ``kind`` is always set. ``provider`` is empty when we did not match a
+    known range — absence of evidence, so do not read UNKNOWN as
+    "residential", only as "not in our data".
+    """
+
+    ip: str
+    kind: str
+    provider: str = ""
+    source: str = "local"
+
+    @property
+    def is_datacenter(self):
+        return self.kind in DATACENTER_KINDS
+
+    def __bool__(self):
+        # Guard against `if classify(ip):` reading as "is a datacenter".
+        # An Origin is always a result, so make the truthiness meaningless
+        # rather than misleading.
+        return True
+
+
+def _parse(ip):
+    if isinstance(ip, (ipaddress.IPv4Address, ipaddress.IPv6Address)):
+        return ip
+    try:
+        return ipaddress.ip_address(str(ip).strip())
+    except ValueError as exc:
+        raise ValueError("%r is not an IP address" % (ip,)) from exc
+
+
+def classify(ip):
+    """Classify one address against the bundled dataset.
+
+    >>> classify("1.1.1.1").provider
+    'Cloudflare'
+
+    Raises ValueError if ``ip`` is not an address. Never makes a network
+    request — see iporigin.online for that.
+    """
+    address = _parse(ip)
+
+    # A reserved address is not "unknown", and answering "hosting: no" for
+    # 127.0.0.1 would be technically true and completely useless.
+    if not address.is_global:
+        return Origin(str(address), RESERVED)
+
+    found = dataset().find(int(address), address.version)
+    if found is None:
+        return Origin(str(address), UNKNOWN)
+
+    provider, kind = found
+    return Origin(str(address), kind, provider)
+
+
+def is_datacenter(ip):
+    """True when the address belongs to a known hosting, CDN or VPN range.
+
+    False means "not in our data", which is not the same as "residential" —
+    our coverage is the published feeds listed in tools/sources.py.
+    """
+    return classify(ip).is_datacenter
+
+
+def classify_many(ips):
+    """Classify an iterable of addresses, yielding Origin objects.
+
+    Loads the dataset once for the whole batch, so this is the right call
+    for scanning a log file.
+    """
+    dataset()
+    for ip in ips:
+        yield classify(ip)
+
+
+def dataset_info():
+    """Provenance of the bundled data: when it was built and how big it is."""
+    data = dataset()
+    return {
+        "built_at": data.built_at,
+        "ranges": len(data),
+        "ipv4_ranges": len(data.v4_starts),
+        "ipv6_ranges": len(data.v6_starts),
+        "providers": sorted({provider for provider, _ in data.labels}),
+    }

iporigin/online.py

@@ -0,0 +1,65 @@
+"""Optional live lookup, for what the bundled dataset cannot know.
+
+The offline dataset covers published hosting and CDN ranges. It does not
+cover consumer VPN exit nodes, because no provider publishes those. When
+that matters, this asks the free Unblock Master API, which does its own
+detection:
+
+    from iporigin.online import classify_online
+    classify_online("203.0.113.10")
+
+Nothing else in iporigin makes a network request; you have to call this
+module explicitly. It needs no API key.
+"""
+
+import json
+import urllib.error
+import urllib.request
+
+from .core import HOSTING, UNKNOWN, VPN, Origin, _parse, classify
+
+API_URL = "https://www.unblockmaster.com/api/v1/ip/%s"
+USER_AGENT = "iporigin/1.0 (+https://github.com/Yuix-Networks/iporigin)"
+DEFAULT_TIMEOUT = 5
+
+
+class LookupError_(RuntimeError):
+    """The online lookup could not be completed."""
+
+
+def classify_online(ip, timeout=DEFAULT_TIMEOUT, fall_back=True):
+    """Classify an address using the live API.
+
+    ``fall_back`` returns the offline answer when the request fails, which
+    is usually what you want in a request path. Pass False to get an
+    exception instead, when a wrong answer is worse than no answer.
+    """
+    address = _parse(ip)
+    offline = classify(address)
+    if offline.kind == "reserved":
+        return offline
+
+    request = urllib.request.Request(
+        API_URL % address, headers={"User-Agent": USER_AGENT}
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            payload = json.loads(response.read().decode("utf-8"))
+    except (urllib.error.URLError, OSError, ValueError, TimeoutError) as exc:
+        if fall_back:
+            return offline
+        raise LookupError_("live lookup failed for %s: %s" % (address, exc)) from exc
+
+    # The API answers null when it could not determine the address, which is
+    # not the same as False. Only overrule the offline answer on a real yes.
+    if payload.get("is_vpn") is True:
+        # A provider name we already matched locally is more specific than
+        # anything the API returns, so keep it.
+        provider = offline.provider or payload.get("provider") or ""
+        kind = offline.kind if offline.kind in (HOSTING, "cdn") else VPN
+        return Origin(str(address), kind, provider, source="api")
+
+    if payload.get("is_vpn") is False and offline.kind == UNKNOWN:
+        return Origin(str(address), UNKNOWN, payload.get("provider") or "", source="api")
+
+    return offline

iporigin-1.0.0.dist-info/METADATA

@@ -0,0 +1,247 @@
+Metadata-Version: 2.4
+Name: iporigin
+Version: 1.0.0
+Summary: Is this IP a datacenter, VPN, Tor exit or a home connection? Offline lookup, no API key.
+Author-email: Yuix Networks <info@yuix.org>
+License: MIT
+Project-URL: Homepage, https://www.unblockmaster.com/free-ip-api/
+Project-URL: Source, https://github.com/Yuix-Networks/iporigin
+Project-URL: Issues, https://github.com/Yuix-Networks/iporigin/issues
+Project-URL: Changelog, https://github.com/Yuix-Networks/iporigin/blob/main/CHANGELOG.md
+Keywords: ip,geolocation,datacenter,hosting,vpn,proxy,cloud,cidr,abuse,fraud,bot-detection,tor,hetzner,ovh
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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: Topic :: Internet
+Classifier: Topic :: Security
+Classifier: Topic :: System :: Networking
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file
+
+# iporigin
+
+Tell a datacenter IP from a home connection — offline, with no API key.
+
+```python
+>>> import iporigin
+>>> iporigin.classify("52.95.110.1")
+Origin(ip='52.95.110.1', kind='hosting', provider='Amazon AWS', source='local')
+>>> iporigin.is_datacenter("8.8.8.8")
+True
+>>> iporigin.is_datacenter("127.0.0.1")
+False
+```
+
+No network calls. No signup. No runtime dependencies. The answer comes from
+a bundled table of 33,000 ranges covering 37 hosting providers, CDNs,
+consumer VPNs, Tor and declared crawlers.
+
+## Install
+
+```
+pip install iporigin
+```
+
+## Why
+
+"Is this visitor on a server or on a home connection?" comes up constantly —
+scoring signups, filtering scrapers out of analytics, deciding whether an
+abuse report is worth acting on, flagging logins from hosting ranges. The
+usual answers are a paid API or a hand-maintained list of CIDRs that goes
+stale in a month.
+
+This is a third option: the providers publish their own ranges, so the list
+can be compiled from source and rebuilt on a schedule. You get a local
+lookup in microseconds, and you can verify every byte of the data by
+re-running the build script.
+
+## Use
+
+### Classify one address
+
+```python
+import iporigin
+
+origin = iporigin.classify("140.82.121.4")
+origin.kind          # 'hosting'
+origin.provider      # 'GitHub'
+origin.is_datacenter # True
+```
+
+`kind` is one of:
+
+| kind | meaning | examples |
+| --- | --- | --- |
+| `hosting` | a machine in a cloud or hosting provider | AWS, Hetzner, OVHcloud |
+| `cdn` | edge infrastructure fronting other people's sites | Cloudflare, Akamai |
+| `vpn` | a consumer VPN or private relay exit | Mullvad, ProtonVPN, Apple Private Relay |
+| `tor` | a Tor exit node | |
+| `bot` | a declared crawler | Googlebot, GPTBot, ClaudeBot |
+| `reserved` | private, loopback, link-local, documentation | `127.0.0.1`, `10.0.0.0/8` |
+| `unknown` | in none of our lists — most often a residential ISP | |
+
+Two sets are exported for the common decisions:
+
+```python
+origin.kind in iporigin.DATACENTER_KINDS   # a machine, not a home line
+origin.kind in iporigin.ANONYMIZER_KINDS   # vpn or tor
+```
+
+They are deliberately different questions. Someone arriving through Mullvad
+is a person at home, but the address they arrive *from* is a server — so it
+is in both sets, and you may well want to rate-limit one and refuse the
+other.
+
+`unknown` means *absence of evidence*. It is not a positive claim that the
+address is residential, and the difference matters if you are going to block
+someone over it.
+
+### Scan a lot of them
+
+```python
+for origin in iporigin.classify_many(ip_list):
+    if origin.is_datacenter:
+        print(origin.ip, origin.provider)
+```
+
+`classify_many` loads the table once for the whole batch.
+
+### From the shell
+
+```console
+$ iporigin 8.8.8.8 140.82.121.4 192.168.1.1
+8.8.8.8                                  hosting   Google
+140.82.121.4                             hosting   GitHub
+192.168.1.1                              reserved
+
+$ cut -d' ' -f1 access.log | iporigin --datacenter-only --json
+{"ip": "34.82.1.5", "kind": "hosting", "provider": "Google Cloud", ...}
+```
+
+`iporigin --info` prints what is in the bundled dataset and when it was built.
+
+### Going beyond the bundled table
+
+The table covers the VPN providers whose exits are publicly tracked —
+Mullvad, ProtonVPN, Apple Private Relay. Most VPN companies are not in that
+set. When you need broader coverage, `iporigin.online` asks the free
+[Unblock Master IP API](https://www.unblockmaster.com/free-ip-api/), which
+does its own detection:
+
+```python
+from iporigin.online import classify_online
+
+classify_online("203.0.113.10")   # may return kind='vpn'
+```
+
+It falls back to the offline answer if the request fails, so it is safe in a
+request path. Nothing else in the library touches the network — you have to
+import this module on purpose. No key required.
+
+## What is in the dataset
+
+37 providers, in two tiers.
+
+**Published by the provider.** The authoritative tier — each of these is the
+company's own feed, fetched at build time:
+
+| Provider | Feed |
+| --- | --- |
+| Amazon AWS | `ip-ranges.amazonaws.com/ip-ranges.json` |
+| Google, Google Cloud | `gstatic.com/ipranges/goog.json`, `cloud.json` |
+| Microsoft Azure | Service Tags JSON |
+| DigitalOcean | `digitalocean.com/geo/google.csv` |
+| Linode | RFC 8805 geofeed |
+| Vultr | `geofeed.constant.com` |
+| Oracle Cloud | `public_ip_ranges.json` |
+| GitHub | `api.github.com/meta` |
+| Cloudflare | `cloudflare.com/ips-v4`, `ips-v6` |
+| Fastly | `api.fastly.com/public-ip-list` |
+
+**Community-maintained lists.** Some providers publish nothing
+machine-readable — Hetzner and OVH being the two that matter most, since a
+large share of abusive traffic comes from them. Consumer VPN exits, Tor and
+crawler ranges have the same problem for a different reason: nobody with the
+data has an interest in publishing it. Those come from two community repos,
+and are second-hand by definition:
+
+- [`rezmoss/cloud-provider-ip-addresses`](https://github.com/rezmoss/cloud-provider-ip-addresses) (CC0)
+- [`lord-alfred/ipranges`](https://github.com/lord-alfred/ipranges) (CC0)
+
+Covering Hetzner, OVHcloud, Scaleway, Alibaba Cloud, Leaseweb, UpCloud, IBM
+Cloud, Huawei Cloud, Tencent Cloud, Rackspace, Akamai, Gcore, Mullvad,
+ProtonVPN, Apple Private Relay, Tor, and ten declared crawlers.
+
+Both are CC0, which is why these two and not the half-dozen other repos
+covering the same ground. Redistributing an unlicensed list inside an MIT
+package is not something a dependency should ask of the people who install
+it.
+
+About 449,000 published prefixes collapse into 33,647 disjoint ranges
+(17,169 IPv4, 16,478 IPv6). Rebuild it yourself at any time:
+
+```
+python tools/build_dataset.py
+```
+
+A GitHub Action re-runs that weekly and opens a PR when the ranges move.
+
+### Known gaps
+
+Being explicit about these is more useful than pretending they are not there:
+
+- **Most consumer VPNs.** Only the ones whose exits are publicly tracked are
+  in the table. Use `iporigin.online` for the rest.
+- **Some provider-owned addresses** sit outside the ranges the provider
+  publishes. `1.1.1.1` is Cloudflare's resolver but is not in Cloudflare's
+  published edge list, so it comes back `unknown`.
+- **Second-hand data is second-hand.** The community tier is as good as
+  those repos are, and they are not the provider speaking.
+- The data is **as accurate as the feeds**. A range reassigned yesterday is
+  wrong until the next rebuild.
+
+## How the lookup works
+
+Ranges are stored as inclusive integer start/end pairs in sorted, *disjoint*
+order, so a lookup is one `bisect` plus one comparison.
+
+Making them disjoint is the part that matters. Feeds overlap each other —
+GitHub runs on Azure and AWS, so its prefixes sit inside theirs. A bisect
+inspects exactly one candidate, and with overlapping ranges that candidate
+can be a narrow range that ends before the address while a wider range still
+contains it, which returns `unknown` for an address plainly in the table. The
+build script therefore sweeps the ranges into a disjoint partition, and where
+they overlap the narrowest one wins — GitHub inside Azure answers GitHub,
+which is the more specific truth.
+
+The table loads lazily on the first lookup, so importing the library and
+never calling it costs nothing.
+
+## Compatibility
+
+Python 3.8+. No dependencies.
+
+## License
+
+MIT. The compiled dataset is derived from the providers' own public feeds,
+each published for exactly this purpose.
+
+---
+
+Built by [Yuix Networks](https://yuix.org), who also run
+[Unblock Master](https://www.unblockmaster.com/) and its
+[free IP lookup API](https://www.unblockmaster.com/free-ip-api/).

iporigin-1.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+iporigin/__init__.py,sha256=ND1IexQpPFE0UoRuOk4GAcfN7dtL3BYyt6q8x4Me-AE,1028
+iporigin/_data.py,sha256=yrCJZ8QoKbyb0v6MzYZgMqFP3tQ-8mXv0HukMg0K5Bw,3737
+iporigin/cli.py,sha256=JmBzTgIjc5M8N3PLTwpqLLjlxa-qMljTf9fv385XCSY,2617
+iporigin/core.py,sha256=bN-MXIIPBdCW7_2Z6Rr0XXiWy38zmZX1EtAftiq8zUo,3861
+iporigin/online.py,sha256=MOgnpGutymSGPCpg5SsJ4pRYzWHDF3xcz5kL0Og97QU,2481
+iporigin/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+iporigin/data/ranges.bin,sha256=N9R-kv4Ig8ZbZf7AFR7nb7oHW3XeQHTxAnmtNZwfbCo,732611
+iporigin-1.0.0.dist-info/licenses/LICENSE,sha256=3UvYE0zJFWjo8fFvty8TzwzFPp3y4WS5_QiQ_J4d5Ww,1074
+iporigin-1.0.0.dist-info/METADATA,sha256=U2JugzKmdoUe6Dt5O_aYHrvIs_62RAGXZgY07w9ahkw,9174
+iporigin-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+iporigin-1.0.0.dist-info/entry_points.txt,sha256=P1lx3Q9qckkC1l5O5-3GhBb0l_aQDOprPmMw9MFave8,47
+iporigin-1.0.0.dist-info/top_level.txt,sha256=7xuiCflcKCO8xd-XWVej18POAUNee7sT24IoS7la3nE,9
+iporigin-1.0.0.dist-info/RECORD,,

iporigin-1.0.0.dist-info/WHEEL

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

iporigin-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+iporigin = iporigin.cli:main

iporigin-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yuix Networks Inc
+
+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.

iporigin-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+iporigin