honeydb 2.0.0__py3-none-any.whl

honeydb/__init__.py

@@ -0,0 +1,25 @@
+"""HoneyDB — Python API wrapper and CLI for the HoneyDB API.
+
+See https://honeydb.io for more information.
+"""
+
+from honeydb.api.client import DATACENTER_PROVIDERS, IPINFO_SOURCES, Client
+from honeydb.exceptions import (
+    HoneyDBAuthError,
+    HoneyDBError,
+    HoneyDBNotFoundError,
+    HoneyDBRateLimitError,
+)
+
+__version__ = "2.0.0"
+
+__all__ = [
+    "Client",
+    "DATACENTER_PROVIDERS",
+    "IPINFO_SOURCES",
+    "HoneyDBError",
+    "HoneyDBAuthError",
+    "HoneyDBNotFoundError",
+    "HoneyDBRateLimitError",
+    "__version__",
+]

honeydb/api/__init__.py

@@ -0,0 +1,5 @@
+"""HoneyDB API module."""
+
+from honeydb.api.client import DATACENTER_PROVIDERS, IPINFO_SOURCES, Client
+
+__all__ = ["Client", "DATACENTER_PROVIDERS", "IPINFO_SOURCES"]

honeydb/api/client.py

@@ -0,0 +1,518 @@
+"""HoneyDB API client.
+
+A thin, typed wrapper around the HoneyDB REST API (https://honeydb.io).
+Requests are made over a pooled :class:`requests.Session` with automatic
+retries on transient failures.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote
+
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+from honeydb.exceptions import (
+    HoneyDBAuthError,
+    HoneyDBError,
+    HoneyDBNotFoundError,
+    HoneyDBRateLimitError,
+)
+
+__all__ = ["Client", "DATACENTER_PROVIDERS", "IPINFO_SOURCES"]
+
+#: IP list sources supported by the ``/ipinfo/<source>`` endpoints.
+IPINFO_SOURCES: tuple[str, ...] = (
+    "bogon",
+    "tor",
+    "sansip",
+    "ciarmy",
+    "et-compromised",
+    "project-honeypot",
+    "pallebone",
+    "threatfox",
+    "blocklist_net_ua",
+)
+
+#: Datacenter/cloud providers supported by the ``/datacenter/<provider>`` endpoint.
+DATACENTER_PROVIDERS: tuple[str, ...] = (
+    "aws",
+    "azure",
+    "azure/china",
+    "azure/germany",
+    "azure/gov",
+    "cloudflare",
+    "gcp",
+    "ibm",
+    "oracle",
+)
+
+JSON = Any
+
+
+class Client:
+    """Client for the HoneyDB API.
+
+    Args:
+        api_id: Your HoneyDB API ID.
+        api_key: Your HoneyDB API key.
+        timeout: Per-request timeout in seconds.
+        base_url: Base URL of the API (override for testing/proxies).
+        session: An existing :class:`requests.Session` to reuse. If omitted, a
+            pooled session with retries is created and owned by this client.
+        retries: Number of automatic retries for transient errors (429/5xx).
+
+    Example:
+        >>> from honeydb import Client
+        >>> with Client("api_id", "api_key") as honeydb:
+        ...     hosts = honeydb.bad_hosts()
+    """
+
+    DEFAULT_BASE_URL = "https://honeydb.io/api"
+
+    def __init__(
+        self,
+        api_id: str,
+        api_key: str,
+        *,
+        timeout: float = 30.0,
+        base_url: str = DEFAULT_BASE_URL,
+        session: requests.Session | None = None,
+        retries: int = 3,
+    ) -> None:
+        self.api_id = api_id
+        self.api_key = api_key
+        self.timeout = timeout
+        self.base_url = base_url.rstrip("/")
+
+        self._owns_session = session is None
+        self.session = session or self._build_session(retries)
+        self.session.headers.update(
+            {
+                "X-HoneyDb-ApiId": self.api_id,
+                "X-HoneyDb-ApiKey": self.api_key,
+                "Accept": "application/json",
+            }
+        )
+
+    # -- infrastructure ---------------------------------------------------
+
+    @staticmethod
+    def _build_session(retries: int) -> requests.Session:
+        session = requests.Session()
+        retry = Retry(
+            total=retries,
+            connect=retries,
+            read=retries,
+            status=retries,
+            backoff_factor=0.5,
+            status_forcelist=(429, 500, 502, 503, 504),
+            allowed_methods=frozenset({"GET", "PUT", "DELETE"}),
+            respect_retry_after_header=True,
+            raise_on_status=False,
+        )
+        adapter = HTTPAdapter(max_retries=retry)
+        session.mount("https://", adapter)
+        session.mount("http://", adapter)
+        return session
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json: Any | None = None,
+    ) -> JSON:
+        """Send a request and return the parsed JSON body.
+
+        Raises:
+            HoneyDBAuthError: On HTTP 401/403.
+            HoneyDBNotFoundError: On HTTP 404.
+            HoneyDBRateLimitError: On HTTP 429.
+            HoneyDBError: On any other HTTP or transport error, or an
+                unparseable response body.
+        """
+        url = f"{self.base_url}{path}"
+        try:
+            response = self.session.request(
+                method,
+                url,
+                params=params,
+                json=json,
+                timeout=self.timeout,
+            )
+        except requests.RequestException as error:
+            raise HoneyDBError(f"Request to {url} failed: {error}") from error
+
+        self._raise_for_status(response)
+
+        # Some endpoints (e.g. datacenter feeds with no entitlement/data) return
+        # an empty or whitespace-only body with a success status; treat as None.
+        if not response.content or not response.text.strip():
+            return None
+        try:
+            return response.json()
+        except ValueError as error:
+            raise HoneyDBError(
+                f"Response from {url} was not valid JSON",
+                status_code=response.status_code,
+                response=response.text,
+            ) from error
+
+    @staticmethod
+    def _raise_for_status(response: requests.Response) -> None:
+        if response.ok:
+            return
+
+        status = response.status_code
+        body = response.text
+        message = f"HoneyDB API returned HTTP {status}: {body[:200]}"
+
+        if status in (401, 403):
+            raise HoneyDBAuthError(message, status_code=status, response=body)
+        if status == 404:
+            raise HoneyDBNotFoundError(message, status_code=status, response=body)
+        if status == 429:
+            retry_after = response.headers.get("Retry-After")
+            raise HoneyDBRateLimitError(
+                message,
+                status_code=status,
+                response=body,
+                retry_after=float(retry_after) if retry_after else None,
+            )
+        raise HoneyDBError(message, status_code=status, response=body)
+
+    @staticmethod
+    def _seg(value: Any) -> str:
+        """URL-encode a single path segment."""
+        return quote(str(value), safe="")
+
+    # -- lifecycle --------------------------------------------------------
+
+    def close(self) -> None:
+        """Close the underlying session if this client owns it."""
+        if self._owns_session:
+            self.session.close()
+
+    def __enter__(self) -> Client:
+        return self
+
+    def __exit__(self, *_exc: object) -> None:
+        self.close()
+
+    # -- bad hosts --------------------------------------------------------
+
+    def bad_hosts(self, mydata: bool = False) -> JSON:
+        """Return bad hosts seen in the last 24 hours.
+
+        Args:
+            mydata: If ``True``, return only data from sensors you operate.
+        """
+        path = "/bad-hosts/mydata" if mydata else "/bad-hosts"
+        return self._request("GET", path)
+
+    def bad_hosts_by_service(self, service: str, mydata: bool = False) -> JSON:
+        """Return bad hosts for a given service (last 24 hours).
+
+        Args:
+            service: Service/protocol name to filter on.
+            mydata: If ``True``, return only data from sensors you operate.
+        """
+        path = f"/bad-hosts/{self._seg(service)}"
+        if mydata:
+            path += "/mydata"
+        return self._request("GET", path)
+
+    # -- ip context -------------------------------------------------------
+
+    def ip(self, ip_address: str) -> JSON:
+        """Return full context for an IP (netinfo, threat, history, scanner...)."""
+        return self._request("GET", f"/ip/{self._seg(ip_address)}")
+
+    def ip_geo(self, ip_address: str) -> JSON:
+        """Return geolocation information for an IP."""
+        return self._request("GET", f"/ip/{self._seg(ip_address)}/geo")
+
+    def ip_netinfo(self, ip_address: str) -> JSON:
+        """Return AS number, organization and location data for an IP."""
+        return self._request("GET", f"/ip/{self._seg(ip_address)}/netinfo")
+
+    def ip_threatinfo(self, ip_address: str) -> JSON:
+        """Return threat intel information for an IP."""
+        return self._request("GET", f"/ip/{self._seg(ip_address)}/threatinfo")
+
+    def ip_internet_scanner(self, ip_address: str) -> JSON:
+        """Return whether an IP is a known internet scanner."""
+        return self._request("GET", f"/ip/{self._seg(ip_address)}/internet-scanner")
+
+    def ip_history(self, ip_address: str) -> JSON:
+        """Return history of an IP's interactions with the HoneyDB network."""
+        return self._request("GET", f"/ip/{self._seg(ip_address)}/history")
+
+    def ip_cve(self, ip_address: str) -> JSON:
+        """Return CVEs observed from an IP."""
+        return self._request("GET", f"/ip/{self._seg(ip_address)}/cve")
+
+    def ip_cidr(self, cidr: str) -> JSON:
+        """Return all IP addresses within a network range (CIDR)."""
+        return self._request("GET", f"/ip/cidr/{self._seg(cidr)}")
+
+    # -- asn --------------------------------------------------------------
+
+    def asn(self, as_number: int | str) -> JSON:
+        """Return AS number and organization name. Does not count against limits."""
+        return self._request("GET", f"/asn/{self._seg(as_number)}")
+
+    def asn_prefixes(self, as_number: int | str) -> JSON:
+        """Return IP prefixes for an ASN. Does not count against limits."""
+        return self._request("GET", f"/asn/{self._seg(as_number)}/prefixes")
+
+    def asns(self) -> JSON:
+        """Return ASNs that interacted with the network in the previous day."""
+        return self._request("GET", "/asns")
+
+    def asns_7d(self) -> JSON:
+        """Return ASNs that interacted with the network in the last 7 days."""
+        return self._request("GET", "/asns-7d")
+
+    # -- cve --------------------------------------------------------------
+
+    def cve(self, cve: str) -> JSON:
+        """Return IP history for a given CVE."""
+        return self._request("GET", f"/cve/{self._seg(cve)}")
+
+    def cve_ip(self, ip_address: str) -> JSON:
+        """Return CVE history for a given IP address."""
+        return self._request("GET", f"/cve/ip/{self._seg(ip_address)}")
+
+    # -- sensor data ------------------------------------------------------
+
+    def sensor_data(
+        self,
+        sensor_data_date: str,
+        from_id: int | str | None = None,
+        mydata: bool = True,
+    ) -> JSON:
+        """Return sensor event data for a given date.
+
+        Args:
+            sensor_data_date: Date in ``YYYY-MM-DD`` format.
+            from_id: Continue retrieving records after this event id (paging).
+            mydata: If ``True`` (default), return only data from your sensors.
+        """
+        path = "/sensor-data/mydata" if mydata else "/sensor-data"
+        params: dict[str, Any] = {"sensor-data-date": sensor_data_date}
+        if from_id is not None:
+            params["from-id"] = from_id
+        return self._request("GET", path, params=params)
+
+    def sensor_data_count(self, sensor_data_date: str, mydata: bool = True) -> JSON:
+        """Return a count of sensor event data for a given date.
+
+        Args:
+            sensor_data_date: Date in ``YYYY-MM-DD`` format.
+            mydata: If ``True`` (default), count only data from your sensors.
+        """
+        path = "/sensor-data/count/mydata" if mydata else "/sensor-data/count"
+        return self._request("GET", path, params={"sensor-data-date": sensor_data_date})
+
+    # -- services / stats -------------------------------------------------
+
+    def services(self) -> JSON:
+        """Return the network services (protocols) emulated by sensors."""
+        return self._request("GET", "/services")
+
+    def stats(self, year: int, month: int) -> JSON:
+        """Return summary stats for a given year and month."""
+        return self._request("GET", "/stats", params={"year": year, "month": month})
+
+    # -- monitors ---------------------------------------------------------
+
+    def monitors(self) -> JSON:
+        """Return the list of current monitors."""
+        return self._request("GET", "/monitors")
+
+    def create_monitors(self, monitors: list[dict[str, Any]]) -> JSON:
+        """Create one or more monitors.
+
+        Args:
+            monitors: A list of monitor definitions. Each is a dict such as
+                ``{"monitor_type": "ip_address", "ip_address": "1.2.3.4",
+                "description": "..."}``. Supported ``monitor_type`` values include
+                ``ip_address``, ``ip_range``, ``asn`` and ``string``.
+        """
+        return self._request("PUT", "/monitors", json=monitors)
+
+    def delete_monitors(self, ids: list[int]) -> JSON:
+        """Delete monitors by id.
+
+        Args:
+            ids: List of monitor ids to delete.
+        """
+        return self._request("DELETE", "/monitors", json={"ids": ids})
+
+    def monitors_logs(self) -> JSON:
+        """Return all monitor logs."""
+        return self._request("GET", "/monitors/logs")
+
+    def monitors_notifications(self) -> JSON:
+        """Return the list of configured monitor notifications."""
+        return self._request("GET", "/monitors/notifications")
+
+    # -- nodes ------------------------------------------------------------
+
+    def nodes(self, mydata: bool = False) -> JSON:
+        """Return honeydb-agent nodes seen in the last 3 days.
+
+        Args:
+            mydata: If ``True``, return only your nodes.
+        """
+        path = "/nodes/mydata" if mydata else "/nodes"
+        return self._request("GET", path)
+
+    # -- payload history --------------------------------------------------
+
+    def payload_history_remote_hosts(self) -> JSON:
+        """Return remote hosts from which payload data was extracted, by year."""
+        return self._request("GET", "/payload-history/remote-hosts")
+
+    def payload_history_attributes(self) -> JSON:
+        """Return the list of attributes extracted from payload data."""
+        return self._request("GET", "/payload-history/attributes")
+
+    def payload_history_attribute(self, attribute: str) -> JSON:
+        """Return historical payload data grouped by the given attribute."""
+        return self._request(
+            "GET", f"/payload-history/attributes/{self._seg(attribute)}"
+        )
+
+    def payload_history(self, year: int, month: int | None = None) -> JSON:
+        """Return payload data for a year (and optional month).
+
+        .. deprecated::
+            This endpoint is deprecated by the HoneyDB API and may be removed.
+        """
+        path = f"/payload-history/{self._seg(year)}"
+        if month is not None:
+            path += f"/{self._seg(month)}"
+        return self._request("GET", path)
+
+    def payload_history_services(self) -> JSON:
+        """Return services from which payload data was extracted.
+
+        .. deprecated:: Deprecated by the HoneyDB API.
+        """
+        return self._request("GET", "/payload-history/services")
+
+    def payload_history_service(self, service: str) -> JSON:
+        """Return payload data for a given service.
+
+        .. deprecated:: Deprecated by the HoneyDB API.
+        """
+        return self._request("GET", f"/payload-history/{self._seg(service)}")
+
+    def payload_history_hash(self, hash: str) -> JSON:
+        """Return payload data for a given hash.
+
+        .. deprecated:: Deprecated by the HoneyDB API.
+        """
+        return self._request("GET", f"/payload-history/{self._seg(hash)}")
+
+    def payload_history_hash_remote_hosts(self, hash: str, year: int) -> JSON:
+        """Return remote hosts for a given hash and year.
+
+        .. deprecated:: Deprecated by the HoneyDB API.
+        """
+        return self._request(
+            "GET",
+            f"/payload-history/{self._seg(hash)}/remote-hosts/{self._seg(year)}",
+        )
+
+    def payload_history_remote_host(self, remote_host: str) -> JSON:
+        """Return payload data hashes for a given remote host.
+
+        .. deprecated:: Deprecated by the HoneyDB API.
+        """
+        return self._request(
+            "GET", f"/payload-history/remote-hosts/{self._seg(remote_host)}"
+        )
+
+    # -- internet scanner -------------------------------------------------
+
+    def internet_scanner(self, ip_address: str) -> JSON:
+        """Return whether an IP is part of a known internet scanning service."""
+        return self._request("GET", f"/internet-scanner/{self._seg(ip_address)}")
+
+    def internet_scanner_info(self, ip_address: str) -> JSON:
+        """Return internet-scanner status plus details about the scanning entity."""
+        return self._request("GET", f"/internet-scanner/info/{self._seg(ip_address)}")
+
+    # -- ipinfo -----------------------------------------------------------
+
+    def ipinfo(self, ip_address: str) -> JSON:
+        """Return whether an IP is present on any of the known IP lists."""
+        return self._request("GET", f"/ipinfo/{self._seg(ip_address)}")
+
+    def ipinfo_source(self, source: str, ip_address: str) -> JSON:
+        """Return whether an IP is present on a specific IP list.
+
+        Args:
+            source: One of :data:`IPINFO_SOURCES` (e.g. ``"tor"``, ``"bogon"``).
+            ip_address: The IP address to look up.
+
+        Raises:
+            ValueError: If ``source`` is not a recognized IP list.
+        """
+        if source not in IPINFO_SOURCES:
+            raise ValueError(
+                f"Unknown ipinfo source {source!r}; "
+                f"expected one of {', '.join(IPINFO_SOURCES)}"
+            )
+        return self._request(
+            "GET", f"/ipinfo/{self._seg(source)}/{self._seg(ip_address)}"
+        )
+
+    # -- netinfo (no monthly limit) --------------------------------------
+
+    def netinfo_lookup(self, ip_address: str) -> JSON:
+        """Return AS, network info and geolocation for an IP. No monthly limit."""
+        return self._request("GET", f"/netinfo/lookup/{self._seg(ip_address)}")
+
+    def netinfo_network_addresses(self, cidr: str) -> JSON:
+        """Return all IP addresses within a network range. No monthly limit."""
+        return self._request("GET", f"/netinfo/network-addresses/{self._seg(cidr)}")
+
+    def netinfo_prefixes(self, asn: int | str) -> JSON:
+        """Return all prefixes advertised for an AS network. No monthly limit."""
+        return self._request("GET", f"/netinfo/prefixes/{self._seg(asn)}")
+
+    def netinfo_as_name(self, asn: int | str) -> JSON:
+        """Return the name of an AS network. No monthly limit."""
+        return self._request("GET", f"/netinfo/as-name/{self._seg(asn)}")
+
+    def netinfo_geolocation(self, ip_address: str) -> JSON:
+        """Return geolocation information for an IP. No monthly limit."""
+        return self._request("GET", f"/netinfo/geolocation/{self._seg(ip_address)}")
+
+    # -- datacenter -------------------------------------------------------
+
+    def datacenter(self, provider: str) -> JSON:
+        """Return datacenter/cloud IP ranges for a provider. No monthly limit.
+
+        Args:
+            provider: One of :data:`DATACENTER_PROVIDERS` (e.g. ``"aws"``,
+                ``"gcp"``, ``"azure/china"``).
+
+        Raises:
+            ValueError: If ``provider`` is not recognized.
+        """
+        if provider not in DATACENTER_PROVIDERS:
+            raise ValueError(
+                f"Unknown datacenter provider {provider!r}; "
+                f"expected one of {', '.join(DATACENTER_PROVIDERS)}"
+            )
+        # provider may contain a sub-path (e.g. "azure/china"); keep the slash.
+        return self._request("GET", f"/datacenter/{provider}")

honeydb/cli.py

@@ -0,0 +1,425 @@
+"""Command-line interface for the HoneyDB API.
+
+Credentials are read from ``--api-id`` / ``--api-key`` or, if not given, from
+the ``HONEYDB_API_ID`` / ``HONEYDB_API_KEY`` environment variables.
+
+Run ``honeydb --help`` to see the available commands.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from collections.abc import Sequence
+from typing import Any
+
+from honeydb import __version__
+from honeydb.api.client import DATACENTER_PROVIDERS, IPINFO_SOURCES, Client
+from honeydb.exceptions import HoneyDBError
+
+PROG = "honeydb"
+
+
+def emit(data: Any, pretty: bool) -> None:
+    """Print JSON data, optionally pretty-printed."""
+    if pretty:
+        print(json.dumps(data, indent=2, sort_keys=True))
+    else:
+        print(json.dumps(data))
+
+
+# --------------------------------------------------------------------------
+# Command handlers. Each takes (client, args) and returns the API response.
+# --------------------------------------------------------------------------
+
+
+def _cmd_bad_hosts(client: Client, args: argparse.Namespace) -> Any:
+    if args.service:
+        return client.bad_hosts_by_service(args.service, mydata=args.mydata)
+    return client.bad_hosts(mydata=args.mydata)
+
+
+def _cmd_ip(client: Client, args: argparse.Namespace) -> Any:
+    dispatch = {
+        "geo": client.ip_geo,
+        "netinfo": client.ip_netinfo,
+        "threatinfo": client.ip_threatinfo,
+        "scanner": client.ip_internet_scanner,
+        "history": client.ip_history,
+        "cve": client.ip_cve,
+    }
+    if args.view:
+        return dispatch[args.view](args.ip_address)
+    return client.ip(args.ip_address)
+
+
+def _cmd_ip_cidr(client: Client, args: argparse.Namespace) -> Any:
+    return client.ip_cidr(args.cidr)
+
+
+def _cmd_asn(client: Client, args: argparse.Namespace) -> Any:
+    if args.prefixes:
+        return client.asn_prefixes(args.as_number)
+    return client.asn(args.as_number)
+
+
+def _cmd_asns(client: Client, args: argparse.Namespace) -> Any:
+    return client.asns_7d() if args.days == 7 else client.asns()
+
+
+def _cmd_cve(client: Client, args: argparse.Namespace) -> Any:
+    return client.cve(args.cve)
+
+
+def _cmd_cve_ip(client: Client, args: argparse.Namespace) -> Any:
+    return client.cve_ip(args.ip_address)
+
+
+def _cmd_sensor_data(client: Client, args: argparse.Namespace) -> Any:
+    if args.count:
+        return client.sensor_data_count(args.date, mydata=args.mydata)
+    return client.sensor_data(args.date, from_id=args.from_id, mydata=args.mydata)
+
+
+def _cmd_services(client: Client, _args: argparse.Namespace) -> Any:
+    return client.services()
+
+
+def _cmd_stats(client: Client, args: argparse.Namespace) -> Any:
+    return client.stats(year=args.year, month=args.month)
+
+
+def _cmd_monitors(client: Client, args: argparse.Namespace) -> Any:
+    if args.action == "list":
+        return client.monitors()
+    if args.action == "logs":
+        return client.monitors_logs()
+    if args.action == "notifications":
+        return client.monitors_notifications()
+    if args.action == "create":
+        payload = _load_json_arg(args.file, args.json)
+        if not isinstance(payload, list):
+            payload = [payload]
+        return client.create_monitors(payload)
+    if args.action == "delete":
+        return client.delete_monitors(args.id)
+    raise ValueError(f"Unknown monitors action: {args.action}")
+
+
+def _cmd_nodes(client: Client, args: argparse.Namespace) -> Any:
+    return client.nodes(mydata=args.mydata)
+
+
+def _cmd_payload_history(client: Client, args: argparse.Namespace) -> Any:
+    action = args.action
+    if action == "remote-hosts":
+        return client.payload_history_remote_hosts()
+    if action == "attributes":
+        if args.attribute:
+            return client.payload_history_attribute(args.attribute)
+        return client.payload_history_attributes()
+    if action == "year":
+        return client.payload_history(args.year, args.month)
+    if action == "services":
+        return client.payload_history_services()
+    if action == "service":
+        return client.payload_history_service(args.name)
+    if action == "hash":
+        return client.payload_history_hash(args.value)
+    raise ValueError(f"Unknown payload-history action: {action}")
+
+
+def _cmd_internet_scanner(client: Client, args: argparse.Namespace) -> Any:
+    if args.info:
+        return client.internet_scanner_info(args.ip_address)
+    return client.internet_scanner(args.ip_address)
+
+
+def _cmd_ipinfo(client: Client, args: argparse.Namespace) -> Any:
+    if args.source:
+        return client.ipinfo_source(args.source, args.ip_address)
+    return client.ipinfo(args.ip_address)
+
+
+def _cmd_netinfo(client: Client, args: argparse.Namespace) -> Any:
+    dispatch = {
+        "lookup": client.netinfo_lookup,
+        "network-addresses": client.netinfo_network_addresses,
+        "prefixes": client.netinfo_prefixes,
+        "as-name": client.netinfo_as_name,
+        "geolocation": client.netinfo_geolocation,
+    }
+    return dispatch[args.action](args.value)
+
+
+def _cmd_datacenter(client: Client, args: argparse.Namespace) -> Any:
+    return client.datacenter(args.provider)
+
+
+def _load_json_arg(file: str | None, raw: str | None) -> Any:
+    """Load JSON payload from a file, an inline string, or stdin ('-')."""
+    if file:
+        if file == "-":
+            return json.load(sys.stdin)
+        with open(file, encoding="utf-8") as handle:
+            return json.load(handle)
+    if raw:
+        return json.loads(raw)
+    raise SystemExit("error: provide --file or --json with the monitor definition")
+
+
+# --------------------------------------------------------------------------
+# Parser construction
+# --------------------------------------------------------------------------
+
+
+def build_parser() -> argparse.ArgumentParser:
+    # Global options live on a shared parent parser (with SUPPRESS defaults) so
+    # they may be given either before or after the subcommand, e.g. both
+    # ``honeydb --pretty services`` and ``honeydb services --pretty`` work.
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument(
+        "--api-id",
+        default=argparse.SUPPRESS,
+        help="HoneyDB API ID (default: HONEYDB_API_ID env var).",
+    )
+    common.add_argument(
+        "--api-key",
+        default=argparse.SUPPRESS,
+        help="HoneyDB API key (default: HONEYDB_API_KEY env var).",
+    )
+    common.add_argument(
+        "-p",
+        "--pretty",
+        action="store_true",
+        default=argparse.SUPPRESS,
+        help="Pretty-print JSON output.",
+    )
+    common.add_argument(
+        "--timeout",
+        type=float,
+        default=argparse.SUPPRESS,
+        help="Per-request timeout in seconds (default: 30).",
+    )
+
+    parser = argparse.ArgumentParser(
+        prog=PROG,
+        parents=[common],
+        description="CLI for the HoneyDB API (https://honeydb.io).",
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"%(prog)s {__version__}"
+    )
+    # Defaults are resolved in main() via getattr rather than set_defaults, so
+    # that a value given before the subcommand is not clobbered by the
+    # subparser (a known argparse interaction with parent parsers).
+
+    sub = parser.add_subparsers(dest="command", metavar="<command>")
+
+    def add(name: str, **kwargs: Any) -> argparse.ArgumentParser:
+        return sub.add_parser(name, parents=[common], **kwargs)
+
+    # bad-hosts
+    p = add("bad-hosts", help="Get bad hosts (last 24h).")
+    p.add_argument("--service", help="Filter by service/protocol name.")
+    p.add_argument("--mydata", action="store_true", help="Only data from your sensors.")
+    p.set_defaults(func=_cmd_bad_hosts)
+
+    # ip
+    p = add("ip", help="Get context for an IP address.")
+    p.add_argument("ip_address", help="IP address to look up.")
+    view = p.add_mutually_exclusive_group()
+    for name, flag in (
+        ("geo", "--geo"),
+        ("netinfo", "--netinfo"),
+        ("threatinfo", "--threatinfo"),
+        ("scanner", "--scanner"),
+        ("history", "--history"),
+        ("cve", "--cve"),
+    ):
+        view.add_argument(
+            flag,
+            dest="view",
+            action="store_const",
+            const=name,
+            help=f"Return only the {name} view.",
+        )
+    p.set_defaults(func=_cmd_ip, view=None)
+
+    # ip-cidr
+    p = add("ip-cidr", help="Get all IPs within a CIDR range.")
+    p.add_argument("cidr", help="Network range in CIDR notation.")
+    p.set_defaults(func=_cmd_ip_cidr)
+
+    # asn
+    p = add("asn", help="Get ASN organization info.")
+    p.add_argument("as_number", help="Autonomous System number.")
+    p.add_argument(
+        "--prefixes", action="store_true", help="Return IP prefixes for the ASN."
+    )
+    p.set_defaults(func=_cmd_asn)
+
+    # asns
+    p = add("asns", help="List ASNs seen interacting with the network.")
+    p.add_argument(
+        "--days",
+        type=int,
+        choices=(1, 7),
+        default=1,
+        help="Window in days: 1 (previous day, default) or 7.",
+    )
+    p.set_defaults(func=_cmd_asns)
+
+    # cve
+    p = add("cve", help="Get IP history for a CVE.")
+    p.add_argument("cve", help="CVE identifier, e.g. CVE-2021-44228.")
+    p.set_defaults(func=_cmd_cve)
+
+    # cve-ip
+    p = add("cve-ip", help="Get CVE history for an IP.")
+    p.add_argument("ip_address", help="IP address to look up.")
+    p.set_defaults(func=_cmd_cve_ip)
+
+    # sensor-data
+    p = add("sensor-data", help="Get your sensor event data for a date.")
+    p.add_argument("--date", required=True, help="Date in YYYY-MM-DD format.")
+    p.add_argument("--from-id", dest="from_id", help="Continue paging from this id.")
+    p.add_argument(
+        "--count", action="store_true", help="Return a count instead of records."
+    )
+    p.add_argument(
+        "--all",
+        dest="mydata",
+        action="store_false",
+        help="Query all sensor data instead of only yours.",
+    )
+    p.set_defaults(func=_cmd_sensor_data, mydata=True)
+
+    # services
+    p = add("services", help="List emulated services (last 24h).")
+    p.set_defaults(func=_cmd_services)
+
+    # stats
+    p = add("stats", help="Get summary stats for a year/month.")
+    p.add_argument("--year", type=int, required=True, help="Year, e.g. 2024.")
+    p.add_argument("--month", type=int, required=True, help="Month (1-12).")
+    p.set_defaults(func=_cmd_stats)
+
+    # monitors
+    p = add("monitors", help="Manage monitors.")
+    msub = p.add_subparsers(dest="action", metavar="<action>", required=True)
+
+    def madd(name: str, **kwargs: Any) -> argparse.ArgumentParser:
+        return msub.add_parser(name, parents=[common], **kwargs)
+
+    madd("list", help="List current monitors.")
+    madd("logs", help="Show monitor logs.")
+    madd("notifications", help="Show monitor notifications.")
+    mc = madd("create", help="Create monitor(s) from JSON.")
+    mc.add_argument("--file", help="Path to a JSON file ('-' for stdin).")
+    mc.add_argument("--json", help="Inline JSON monitor definition.")
+    md = madd("delete", help="Delete monitor(s) by id.")
+    md.add_argument("--id", type=int, nargs="+", required=True, help="Monitor id(s).")
+    p.set_defaults(func=_cmd_monitors)
+
+    # nodes
+    p = add("nodes", help="List honeydb-agent nodes (last 3 days).")
+    p.add_argument("--mydata", action="store_true", help="Only your nodes.")
+    p.set_defaults(func=_cmd_nodes)
+
+    # payload-history
+    p = add("payload-history", help="Query payload history data.")
+    psub = p.add_subparsers(dest="action", metavar="<action>", required=True)
+
+    def padd(name: str, **kwargs: Any) -> argparse.ArgumentParser:
+        return psub.add_parser(name, parents=[common], **kwargs)
+
+    padd("remote-hosts", help="Remote hosts grouped by year.")
+    pa = padd("attributes", help="List attributes, or one attribute.")
+    pa.add_argument("--attribute", help="Group historical data by this attribute.")
+    py = padd("year", help="[deprecated] Payload data by year/month.")
+    py.add_argument("year", type=int, help="Year, e.g. 2024.")
+    py.add_argument("month", type=int, nargs="?", help="Optional month (1-12).")
+    padd("services", help="[deprecated] Services with payload data.")
+    ps = padd("service", help="[deprecated] Payload data by service.")
+    ps.add_argument("name", help="Service name.")
+    ph = padd("hash", help="[deprecated] Payload data by hash.")
+    ph.add_argument("value", help="Payload hash.")
+    p.set_defaults(func=_cmd_payload_history)
+
+    # internet-scanner
+    p = add("internet-scanner", help="Check if an IP is a scanner.")
+    p.add_argument("ip_address", help="IP address to look up.")
+    p.add_argument(
+        "--info", action="store_true", help="Include details about the scanner."
+    )
+    p.set_defaults(func=_cmd_internet_scanner)
+
+    # ipinfo
+    p = add("ipinfo", help="Check an IP against known IP lists.")
+    p.add_argument("ip_address", help="IP address to look up.")
+    p.add_argument(
+        "--source",
+        choices=IPINFO_SOURCES,
+        help="Check a single IP list instead of all.",
+    )
+    p.set_defaults(func=_cmd_ipinfo)
+
+    # netinfo
+    p = add("netinfo", help="Network info lookups (do not count against limits).")
+    p.add_argument(
+        "action",
+        choices=(
+            "lookup",
+            "network-addresses",
+            "prefixes",
+            "as-name",
+            "geolocation",
+        ),
+        help="Lookup type.",
+    )
+    p.add_argument("value", help="IP, CIDR or ASN depending on the lookup type.")
+    p.set_defaults(func=_cmd_netinfo)
+
+    # datacenter
+    p = add("datacenter", help="Get datacenter/cloud IP ranges.")
+    p.add_argument("provider", choices=DATACENTER_PROVIDERS, help="Cloud provider.")
+    p.set_defaults(func=_cmd_datacenter)
+
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if not getattr(args, "func", None):
+        parser.print_help()
+        return 2
+
+    api_id = getattr(args, "api_id", None) or os.environ.get("HONEYDB_API_ID")
+    api_key = getattr(args, "api_key", None) or os.environ.get("HONEYDB_API_KEY")
+    pretty = getattr(args, "pretty", False)
+    timeout = getattr(args, "timeout", 30.0)
+
+    if not api_id or not api_key:
+        parser.error(
+            "API credentials required: set HONEYDB_API_ID and HONEYDB_API_KEY "
+            "environment variables, or pass --api-id and --api-key."
+        )
+
+    try:
+        with Client(api_id, api_key, timeout=timeout) as client:
+            result = args.func(client, args)
+    except HoneyDBError as error:
+        print(f"error: {error}", file=sys.stderr)
+        return 1
+
+    emit(result, pretty)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

honeydb/exceptions.py

@@ -0,0 +1,54 @@
+"""Exceptions raised by the HoneyDB API client."""
+
+from __future__ import annotations
+
+
+class HoneyDBError(Exception):
+    """Base class for all HoneyDB API errors.
+
+    Attributes:
+        status_code: HTTP status code returned by the API, if available.
+        response: The raw text body of the response, if available.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: int | None = None,
+        response: str | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.response = response
+
+
+class HoneyDBAuthError(HoneyDBError):
+    """Raised on authentication/authorization failures (HTTP 401/403).
+
+    Usually indicates a missing or invalid ``api_id`` / ``api_key``.
+    """
+
+
+class HoneyDBNotFoundError(HoneyDBError):
+    """Raised when a requested resource is not found (HTTP 404)."""
+
+
+class HoneyDBRateLimitError(HoneyDBError):
+    """Raised when the API rate/quota limit is exceeded (HTTP 429).
+
+    Attributes:
+        retry_after: Seconds to wait before retrying, from the
+            ``Retry-After`` header, if provided.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: int | None = None,
+        response: str | None = None,
+        retry_after: float | None = None,
+    ) -> None:
+        super().__init__(message, status_code=status_code, response=response)
+        self.retry_after = retry_after

honeydb-2.0.0.dist-info/METADATA

@@ -0,0 +1,252 @@
+Metadata-Version: 2.4
+Name: honeydb
+Version: 2.0.0
+Summary: A Python API wrapper and CLI tool for HoneyDB.
+Project-URL: Homepage, https://honeydb.io
+Project-URL: Repository, https://github.com/honeydbio/honeydb-python
+Author: foospidy
+License: MIT
+License-File: LICENSE
+Keywords: api,cli,honeydb,library,threat-intelligence,wrapper
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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 :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: requests>=2.31
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: requests-mock; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# honeydb-python
+
+[![Format, Lint & Test](https://github.com/honeydbio/honeydb-python/actions/workflows/format-lint.yml/badge.svg?branch=master)](https://github.com/honeydbio/honeydb-python/actions/workflows/format-lint.yml?query=branch%3Amaster)
+[![PyPI version](https://img.shields.io/pypi/v/honeydb.svg)](https://pypi.org/project/honeydb/)
+[![Python versions](https://img.shields.io/pypi/pyversions/honeydb.svg)](https://pypi.org/project/honeydb/)
+
+A Python API wrapper and command-line tool for the [HoneyDB](https://honeydb.io) API.
+
+HoneyDB provides real-time threat intelligence collected from a distributed network of
+honeypots — bad hosts, IP reputation, ASN activity, CVE sightings, network info, cloud/datacenter
+IP ranges, and more.
+
+- **Full API coverage** — every current HoneyDB endpoint is exposed.
+- **Modern & typed** — Python 3.10+, full type hints, ships a `py.typed` marker.
+- **Robust HTTP** — pooled `requests.Session` with automatic retries and typed exceptions.
+- **Ergonomic CLI** — a git-style subcommand interface: `honeydb ip 8.8.8.8`.
+
+## Requirements
+
+- Python 3.10+
+- A HoneyDB API ID and API key ([sign in](https://honeydb.io) to get yours).
+
+## Installation
+
+```bash
+pip install honeydb
+```
+
+## Authentication
+
+All requests require an API ID and API key. Provide them via environment variables:
+
+```bash
+export HONEYDB_API_ID=<your api id>
+export HONEYDB_API_KEY=<your api key>
+```
+
+The CLI also accepts `--api-id` / `--api-key`, and the library takes them as constructor
+arguments.
+
+## CLI usage
+
+```bash
+# Bad hosts seen in the last 24 hours
+honeydb bad-hosts
+
+# Full context for an IP (pretty-printed)
+honeydb ip 8.8.8.8 --pretty
+
+# Just the geolocation view of that IP
+honeydb ip 8.8.8.8 --geo
+
+# ASN organization + its prefixes
+honeydb asn 15169
+honeydb asn 15169 --prefixes
+
+# Check an IP against a specific list
+honeydb ipinfo 185.220.101.1 --source tor
+
+# Cloud/datacenter IP ranges (does not count against monthly limits)
+honeydb datacenter aws
+
+# Your own sensor data for a date
+honeydb sensor-data --date 2025-04-01
+honeydb sensor-data --date 2025-04-01 --count
+
+# Manage monitors
+honeydb monitors list
+honeydb monitors create --json '[{"monitor_type":"asn","monitor_value":"401120","description":"ASN Example"}]'
+honeydb monitors delete --id 122 123
+```
+
+Run `honeydb --help` or `honeydb <command> --help` for the full command tree. Global flags
+`--pretty/-p` and `--timeout` apply to any command. Output is JSON on stdout; errors go to
+stderr with a non-zero exit code.
+
+### Commands
+
+| Command | Description |
+| --- | --- |
+| `bad-hosts [--service S] [--mydata]` | Bad hosts (last 24h), optionally by service. |
+| `ip <ip> [--geo\|--netinfo\|--threatinfo\|--scanner\|--history\|--cve]` | IP context, or a single view. |
+| `ip-cidr <cidr>` | All IP addresses within a network range. |
+| `asn <n> [--prefixes]` | ASN organization info or its prefixes. |
+| `asns [--days 1\|7]` | ASNs seen in the last 1 (default) or 7 days. |
+| `cve <cve>` | IP history for a CVE. |
+| `cve-ip <ip>` | CVE history for an IP. |
+| `sensor-data --date D [--from-id ID] [--count] [--all]` | Your sensor event data for a date. |
+| `services` | Emulated services (last 24h). |
+| `stats --year Y --month M` | Summary stats for a year/month. |
+| `monitors {list,logs,notifications,create,delete}` | Manage monitors. |
+| `nodes [--mydata]` | honeydb-agent nodes (last 3 days). |
+| `payload-history {remote-hosts,attributes,...}` | Payload history data. |
+| `internet-scanner <ip> [--info]` | Whether an IP is a known internet scanner. |
+| `ipinfo <ip> [--source SRC]` | Check an IP against known IP lists. |
+| `netinfo {lookup,network-addresses,prefixes,as-name,geolocation} <arg>` | Network info (no monthly limit). |
+| `datacenter <provider>` | Cloud/datacenter IP ranges (no monthly limit). |
+
+`ipinfo --source` values: `bogon`, `tor`, `sansip`, `ciarmy`, `et-compromised`,
+`project-honeypot`, `pallebone`, `threatfox`, `blocklist_net_ua`.
+
+`datacenter` providers: `aws`, `azure`, `azure/china`, `azure/germany`, `azure/gov`,
+`cloudflare`, `gcp`, `ibm`, `oracle`.
+
+## Library usage
+
+```python
+from honeydb import Client
+
+with Client("api_id", "api_key") as honeydb:
+    hosts = honeydb.bad_hosts()
+    context = honeydb.ip("8.8.8.8")
+    is_tor = honeydb.ipinfo_source("tor", "185.220.101.1")
+    ranges = honeydb.datacenter("aws")
+```
+
+The client can also be used without the context manager (call `.close()` when done), and
+you can pass a shared `requests.Session`, a custom `timeout`, or a different `base_url`:
+
+```python
+client = Client("api_id", "api_key", timeout=10, retries=5)
+try:
+    print(client.services())
+finally:
+    client.close()
+```
+
+### Error handling
+
+Every failed request raises a typed exception, all subclasses of `HoneyDBError`:
+
+```python
+from honeydb import (
+    Client,
+    HoneyDBError,
+    HoneyDBAuthError,
+    HoneyDBNotFoundError,
+    HoneyDBRateLimitError,
+)
+
+with Client("api_id", "api_key") as honeydb:
+    try:
+        honeydb.ip("8.8.8.8")
+    except HoneyDBAuthError:
+        print("Check your API credentials.")
+    except HoneyDBRateLimitError as error:
+        print(f"Rate limited; retry after {error.retry_after}s")
+    except HoneyDBError as error:
+        print(f"Request failed with HTTP {error.status_code}: {error}")
+```
+
+### Monitors
+
+```python
+with Client("api_id", "api_key") as honeydb:
+    honeydb.create_monitors([
+        {"monitor_type": "ip_address", "ip_address": "196.251.81.54",
+         "description": "IP Address Example"},
+        {"monitor_type": "asn", "monitor_value": "401120",
+         "description": "ASN Example"},
+    ])
+    monitors = honeydb.monitors()
+    honeydb.delete_monitors([m["id"] for m in monitors])
+```
+
+## API reference
+
+The `Client` exposes one method per endpoint, grouped below.
+
+- **Bad hosts:** `bad_hosts(mydata=False)`, `bad_hosts_by_service(service, mydata=False)`
+- **IP context:** `ip(ip)`, `ip_geo(ip)`, `ip_netinfo(ip)`, `ip_threatinfo(ip)`,
+  `ip_internet_scanner(ip)`, `ip_history(ip)`, `ip_cve(ip)`, `ip_cidr(cidr)`
+- **ASN:** `asn(n)`, `asn_prefixes(n)`, `asns()`, `asns_7d()`
+- **CVE:** `cve(cve)`, `cve_ip(ip)`
+- **Sensor data:** `sensor_data(date, from_id=None, mydata=True)`, `sensor_data_count(date, mydata=True)`
+- **Services / stats:** `services()`, `stats(year, month)`
+- **Monitors:** `monitors()`, `create_monitors(list)`, `delete_monitors(ids)`,
+  `monitors_logs()`, `monitors_notifications()`
+- **Nodes:** `nodes(mydata=False)`
+- **Payload history:** `payload_history_remote_hosts()`, `payload_history_attributes()`,
+  `payload_history_attribute(attr)` (plus API-deprecated helpers)
+- **Internet scanner:** `internet_scanner(ip)`, `internet_scanner_info(ip)`
+- **IP info lists:** `ipinfo(ip)`, `ipinfo_source(source, ip)`
+- **Net info (no monthly limit):** `netinfo_lookup(ip)`, `netinfo_network_addresses(cidr)`,
+  `netinfo_prefixes(asn)`, `netinfo_as_name(asn)`, `netinfo_geolocation(ip)`
+- **Datacenter (no monthly limit):** `datacenter(provider)`
+
+See the [HoneyDB API documentation](https://honeydb.io/threats) for endpoint details and
+response formats.
+
+## Migrating from v1.x
+
+v2.0.0 is a ground-up rewrite. Notable changes:
+
+- **New import surface.** `from honeydb import Client` (the `from honeydb import api;
+  api.Client(...)` form still works).
+- **The CLI is now subcommand-based.** For example, `honeydb --bad-hosts` becomes
+  `honeydb bad-hosts`, and `honeydb --netinfo-lookup 1.2.3.4` becomes
+  `honeydb netinfo lookup 1.2.3.4`.
+- **Replaced endpoints were dropped** in favor of their modern equivalents:
+  the old `ip_history()` / `ip-context` top-level methods are replaced by `ip()` and
+  `ip_history()` under the `/ip/<ip>` family, and `stats_asn()` is replaced by `asns()`.
+- **Errors now raise typed exceptions** (`HoneyDBError` and subclasses) instead of returning
+  raw response bodies.
+
+## Development
+
+```bash
+make env           # create .env venv and install with dev extras
+make format        # ruff format
+make lint          # ruff check
+make test          # pytest (uses mocked HTTP, no API keys needed)
+make build         # build sdist + wheel
+```
+
+This project uses [ruff](https://docs.astral.sh/ruff/) for both formatting and linting.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

honeydb-2.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+honeydb/__init__.py,sha256=1KqJC_ga-3SSHe2GQqcmPnhxdWQ12d8xxuRUFr1aTUI,540
+honeydb/cli.py,sha256=skIX33ztmPy8QPr1UsyT5OWavqDcHD_LJFLmEvDqMrY,14788
+honeydb/exceptions.py,sha256=GN435o-SJU3TUe73We3tRuP46JKBMQ0mIVcDq5ebCnM,1463
+honeydb/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+honeydb/api/__init__.py,sha256=bK3G9YhLbWR6WXPJ9hIAWnQB4i_nNu1Jp-Td00b9giU,167
+honeydb/api/client.py,sha256=FvAex8cdOuf8ZcLyIbkW1cXWgph3uTE_VsL8UKHWH8Q,19145
+honeydb-2.0.0.dist-info/METADATA,sha256=pb0bmqPJPh4h-pO-RWC5hiLsj9d_yNMUmzy-1uR7f-w,9509
+honeydb-2.0.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+honeydb-2.0.0.dist-info/entry_points.txt,sha256=b1d4UURHVLS5EpOhoeZnwa9AOXtAQefSRujOLUlgaAo,45
+honeydb-2.0.0.dist-info/licenses/LICENSE,sha256=AbmIZiGE9mwAr03H-2D5qYYgFtvEFl7iLNgQSzSLicw,1062
+honeydb-2.0.0.dist-info/RECORD,,

honeydb-2.0.0.dist-info/WHEEL

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

honeydb-2.0.0.dist-info/entry_points.txt

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

honeydb-2.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Px Mx
+
+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.