aiodiscover 2.2.0__py3-none-any.whl

aiodiscover/__init__.py

@@ -0,0 +1,13 @@
+"""Top-level package for Async Host discovery."""
+
+__author__ = "J. Nick Koston"
+__email__ = "nick@koston.org"
+# Do not edit this string manually, always use bumpversion
+# Details in CONTRIBUTING.md
+__version__ = "2.2.0"
+
+from .discovery import DiscoverHosts  # noqa: F401
+
+
+def get_module_version() -> str:
+    return __version__

aiodiscover/discovery.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from collections.abc import Iterable
+from contextlib import suppress
+from functools import lru_cache, partial
+from ipaddress import IPv4Address
+from itertools import islice
+from typing import TYPE_CHECKING, Any, cast
+
+from aiodns import DNSResolver
+
+from .network import SystemNetworkData
+
+if TYPE_CHECKING:
+    from pyroute2.iproute import IPRoute
+
+HOSTNAME = "hostname"
+MAC_ADDRESS = "macaddress"
+IP_ADDRESS = "ip"
+MAX_ADDRESSES = 2048
+QUERY_BUCKET_SIZE = 64
+
+DNS_RESPONSE_TIMEOUT = 2
+
+
+_LOGGER = logging.getLogger(__name__)
+
+
+@lru_cache(maxsize=MAX_ADDRESSES)
+def decode_idna(name: str) -> str:
+    """Decode an idna name."""
+    try:
+        return name.encode().decode("idna")
+    except UnicodeError:
+        return name
+
+
+def dns_message_short_hostname(dns_message: Any | None) -> str | None:
+    """Get the short hostname from a dns message."""
+    if dns_message is None:
+        return None
+    name: str = dns_message.name
+    if name.startswith("xn--"):
+        name = decode_idna(name)
+    return name.partition(".")[0]
+
+
+async def async_query_for_ptrs(
+    nameserver: str, ips_to_lookup: list[IPv4Address]
+) -> list[Any | None]:
+    """Fetch PTR records for a list of ips."""
+    resolver = DNSResolver(nameservers=[nameserver], timeout=DNS_RESPONSE_TIMEOUT)
+    results: list[Any | None] = []
+    for ip_chunk in chunked(ips_to_lookup, QUERY_BUCKET_SIZE):
+        if TYPE_CHECKING:
+            ip_chunk = cast("list[IPv4Address]", ip_chunk)
+        futures = [resolver.query(ip.reverse_pointer, "PTR") for ip in ip_chunk]
+        await asyncio.wait(futures)
+        results.extend(
+            None if future.exception() else future.result() for future in futures
+        )
+    resolver.cancel()
+    return results
+
+
+def take(take_num: int, iterable: Iterable[Any]) -> list[Any]:
+    """
+    Return first n items of the iterable as a list.
+
+    From itertools recipes
+    """
+    return list(islice(iterable, take_num))
+
+
+def chunked(iterable: Iterable[Any], chunked_num: int) -> Iterable[Any]:
+    """
+    Break *iterable* into lists of length *n*.
+
+    From more-itertools
+    """
+    return iter(partial(take, chunked_num, iter(iterable)), [])
+
+
+class DiscoverHosts:
+    """Discover hosts on the network by ARP and PTR lookup."""
+
+    def __init__(self) -> None:
+        """Init the discovery hosts."""
+        self._sys_network_data: SystemNetworkData | None = None
+
+    def _setup_sys_network_data(self) -> None:
+        ip_route: IPRoute | None = None
+        with suppress(Exception):
+            from pyroute2.iproute import (
+                IPRoute,
+            )
+
+            ip_route = IPRoute()
+        sys_network_data = SystemNetworkData(ip_route)
+        sys_network_data.setup()
+        self._sys_network_data = sys_network_data
+
+    async def async_discover(self) -> list[dict[str, str]]:
+        """Discover hosts on the network by ARP and PTR lookup."""
+        if not self._sys_network_data:
+            await asyncio.get_running_loop().run_in_executor(
+                None, self._setup_sys_network_data
+            )
+        if TYPE_CHECKING:
+            assert self._sys_network_data is not None
+        sys_network_data = self._sys_network_data
+        network = sys_network_data.network
+        if TYPE_CHECKING:
+            assert network is not None
+        if network.num_addresses > MAX_ADDRESSES:
+            _LOGGER.debug(
+                "The network %s exceeds the maximum number of addresses, %s; No scanning performed",
+                network,
+                MAX_ADDRESSES,
+            )
+            return []
+        hostnames = await self.async_get_hostnames(sys_network_data)
+        neighbours = await sys_network_data.async_get_neighbors(hostnames.keys())
+        return [
+            {
+                HOSTNAME: hostname,
+                MAC_ADDRESS: neighbours[ip],
+                IP_ADDRESS: ip,
+            }
+            for ip, hostname in hostnames.items()
+            if ip in neighbours
+        ]
+
+    async def _async_get_nameservers(
+        self, sys_network_data: SystemNetworkData
+    ) -> list[str]:
+        """Get nameservers to query."""
+        all_nameservers = list(sys_network_data.nameservers)
+        router_ip = sys_network_data.router_ip
+        assert router_ip is not None
+        if router_ip not in all_nameservers:
+            neighbours = await sys_network_data.async_get_neighbors([router_ip])
+            if router_ip in neighbours:
+                all_nameservers.insert(0, router_ip)
+        return all_nameservers
+
+    async def async_get_hostnames(
+        self, sys_network_data: SystemNetworkData
+    ) -> dict[str, str]:
+        """Lookup PTR records for all addresses in the network."""
+        all_nameservers = await self._async_get_nameservers(sys_network_data)
+        assert sys_network_data.network is not None
+        ips = list(sys_network_data.network.hosts())
+        hostnames: dict[str, str] = {}
+        for nameserver in all_nameservers:
+            ips_to_lookup = [ip for ip in ips if str(ip) not in hostnames]
+            results = await async_query_for_ptrs(nameserver, ips_to_lookup)
+            for idx, ip in enumerate(ips_to_lookup):
+                short_host = dns_message_short_hostname(results[idx])
+                if short_host is None:
+                    continue
+                hostnames[str(ip)] = short_host
+            if hostnames:
+                # As soon as we have a responsive nameserver, there
+                # is no need to query additional fallbacks
+                break
+        return hostnames

aiodiscover/network.py

@@ -0,0 +1,262 @@
+from __future__ import annotations
+
+import asyncio
+import re
+import socket
+import sys
+from collections.abc import Iterable
+from contextlib import suppress
+from ipaddress import IPv4Network, ip_network
+from typing import TYPE_CHECKING, Any
+
+import ifaddr  # type: ignore
+from cached_ipaddress import cached_ip_addresses
+
+from .util import asyncio_timeout
+
+if TYPE_CHECKING:
+    from pyroute2.iproute import IPRoute
+# Some MAC addresses will drop the leading zero so
+# our mac validation must allow a single char
+VALID_MAC_ADDRESS = re.compile("^([0-9A-Fa-f]{1,2}[:-]){5}([0-9A-Fa-f]{1,2})$")
+
+ARP_CACHE_POPULATE_TIME = 10
+ARP_TIMEOUT = 10
+
+DEFAULT_NETWORK_PREFIX = 24
+
+
+PRIVATE_AND_LOCAL_NETWORKS = (
+    ip_network("127.0.0.0/8"),
+    ip_network("10.0.0.0/8"),
+    ip_network("172.16.0.0/12"),
+    ip_network("192.168.0.0/16"),
+)
+
+DEFAULT_TARGET = "10.255.255.255"
+MDNS_TARGET_IP = "224.0.0.251"
+PUBLIC_TARGET_IP = "8.8.8.8"
+LOOPBACK_TARGET_IP = "127.0.0.1"
+
+IGNORE_MACS = {"00:00:00:00:00:00", "ff:ff:ff:ff:ff:ff"}
+
+
+def load_resolv_conf() -> list[str]:
+    """Load the resolv.conf."""
+    with open("/etc/resolv.conf") as file:
+        lines = tuple(file)
+    nameservers = set()
+    for line in lines:
+        line = line.strip()
+        if not len(line):
+            continue
+        if line[0] in ("#", ";"):
+            continue
+        key, value = line.split(None, 1)
+        if key == "nameserver":
+            if ip_addr := cached_ip_addresses(value):
+                nameservers.add(ip_addr)
+    return list(nameservers)
+
+
+def get_local_ip(target: str = DEFAULT_TARGET) -> str | None:
+    """Find the local ip address."""
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    s.setblocking(False)
+    try:
+        s.connect((target, 1))
+        return s.getsockname()[0]
+    except Exception:
+        return None
+    finally:
+        s.close()
+
+
+def get_network(local_ip: str, adapters: Any) -> IPv4Network:
+    """Search adapters for the network and broadcast ip."""
+    network_prefix = (
+        get_ip_prefix_from_adapters(local_ip, adapters) or DEFAULT_NETWORK_PREFIX
+    )
+    network = ip_network(f"{local_ip}/{network_prefix}", False)
+    if TYPE_CHECKING:
+        assert isinstance(network, IPv4Network)
+    return network
+
+
+def get_ip_prefix_from_adapters(local_ip: str, adapters: Any) -> int | None:
+    """Find the network prefix for an adapter."""
+    for adapter in adapters:
+        for ip in adapter.ips:
+            if local_ip == ip.ip:
+                return ip.network_prefix
+    return None
+
+
+def get_attrs_key(data: Any, key: Any) -> Any:
+    """Lookup an attrs key in pyroute2 data."""
+    for attr_key, attr_value in data["attrs"]:
+        if attr_key == key:
+            return attr_value
+
+
+def get_router_ip(ipr: IPRoute) -> Any:
+    """Obtain the router ip from the default route."""
+    return get_attrs_key(ipr.get_default_routes()[0], "RTA_GATEWAY")
+
+
+def _fill_neighbor(neighbours: dict[str, str], ip: str, mac: str) -> None:
+    """Add a neighbor if it is valid."""
+    if not (ip_addr := cached_ip_addresses(ip)):
+        return
+    if (
+        ip_addr.is_loopback
+        or ip_addr.is_link_local
+        or ip_addr.is_multicast
+        or ip_addr.is_unspecified
+    ):
+        return
+    if not VALID_MAC_ADDRESS.match(mac):
+        return
+    mac = ":".join([i.zfill(2) for i in mac.split(":")])
+    if mac in IGNORE_MACS:
+        return
+    neighbours[ip] = mac
+
+
+def async_populate_arp(ip_addresses: Iterable[str]) -> socket.socket:
+    """Send an empty packet to a host to populate the arp cache."""
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, 0)
+    sock.setblocking(False)
+    for ip_addr in ip_addresses:
+        try:
+            sock.sendto(b"", (ip_addr, 80))
+        except Exception:
+            pass
+    return sock
+
+
+class SystemNetworkData:
+    """Gather system network data."""
+
+    def __init__(self, ip_route: IPRoute | None, local_ip: str | None = None) -> None:
+        """Init system network data."""
+        self.ip_route = ip_route
+        self.local_ip = local_ip
+        self.broadcast_ip: str | None = None
+        self.router_ip: str | None = None
+        self.network: IPv4Network | None = None
+        self.adapters: Any = None
+        self.nameservers: list[str] = []
+
+    def setup(self) -> None:
+        """Obtain the local network data."""
+        try:
+            resolvers = load_resolv_conf()
+        except FileNotFoundError:
+            if sys.platform != "win32":
+                raise
+        else:
+            self.nameservers = [
+                str(ip_addr)
+                for ip_addr in resolvers
+                if any(ip_addr in network for network in PRIVATE_AND_LOCAL_NETWORKS)
+            ]
+        self.adapters = ifaddr.get_adapters()
+        if not self.local_ip:
+            self.local_ip = (
+                get_local_ip(DEFAULT_TARGET)
+                or get_local_ip(MDNS_TARGET_IP)
+                or get_local_ip(PUBLIC_TARGET_IP)
+                or get_local_ip(LOOPBACK_TARGET_IP)
+            )
+        assert self.local_ip is not None
+        self.network = get_network(self.local_ip, self.adapters)
+        if self.ip_route:
+            try:
+                self.router_ip = get_router_ip(self.ip_route)
+            except Exception:
+                pass
+        if not self.router_ip:
+            # On MacOS netifaces is the only reliable way to get the default gateway
+            with suppress(Exception):
+                import netifaces  # type: ignore # pylint: disable=import-outside-toplevel
+
+                self.router_ip = netifaces.gateways()["default"][netifaces.AF_INET][0]
+        if not self.router_ip:
+            network_address = str(self.network.network_address)
+            self.router_ip = f"{network_address[:-1]}1"
+
+    async def async_get_neighbors(self, ips: Iterable[str]) -> dict[str, str]:
+        """Get neighbors with best available method."""
+        neighbors = await self._async_get_neighbors()
+        ips_missing_arp = [ip for ip in ips if ip not in neighbors]
+        if not ips_missing_arp:
+            return neighbors
+        sock = async_populate_arp(ips_missing_arp)
+        await asyncio.sleep(ARP_CACHE_POPULATE_TIME)
+        sock.close()
+        neighbors.update(await self._async_get_neighbors())
+        return neighbors
+
+    async def _async_get_neighbors(self) -> dict[str, str]:
+        """Get neighbors from the arp table."""
+        if self.ip_route:
+            return await self._async_get_neighbors_ip_route()
+        return await self._async_get_neighbors_arp()
+
+    async def _async_get_neighbors_arp(self) -> dict[str, str]:
+        """Get neighbors with arp command."""
+        neighbours: dict[str, str] = {}
+        arp = await asyncio.create_subprocess_exec(
+            "arp",
+            "-a",
+            "-n",
+            stdin=None,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            close_fds=False,
+        )
+        try:
+            async with asyncio_timeout(ARP_TIMEOUT):
+                out_data, _ = await arp.communicate()
+        except asyncio.TimeoutError:
+            if arp:
+                with suppress(TypeError):
+                    await arp.kill()  # type: ignore
+                del arp
+            return neighbours
+        except AttributeError:
+            return neighbours
+
+        for line in out_data.decode().splitlines():
+            chomped = line.strip()
+            data = chomped.split()
+            if len(data) < 4:
+                continue
+            ip = data[1].strip("()")
+            mac = data[3]
+            _fill_neighbor(neighbours, ip, mac)
+
+        return neighbours
+
+    async def _async_get_neighbors_ip_route(self) -> dict[str, str]:
+        """Get neighbors with pyroute2."""
+        neighbours: dict[str, str] = {}
+        loop = asyncio.get_running_loop()
+        # This shouldn't ever block but it does
+        # interact with netlink so its safer to run
+        # in the executor
+        if TYPE_CHECKING:
+            assert self.ip_route is not None
+        for neighbour in await loop.run_in_executor(None, self.ip_route.get_neighbours):
+            ip = None
+            mac = None
+            for key, value in neighbour["attrs"]:
+                if key == "NDA_DST":
+                    ip = value
+                elif key == "NDA_LLADDR":
+                    mac = value
+            if ip and mac:
+                _fill_neighbor(neighbours, ip, mac)
+
+        return neighbours

aiodiscover/tests/__init__.py

@@ -0,0 +1 @@
+"""Unit test package for aiodiscover."""

aiodiscover/tests/conftest.py

@@ -0,0 +1 @@
+#!/usr/bin/env python

aiodiscover/tests/test_discovery.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python
+import asyncio
+import sys
+from dataclasses import dataclass
+from ipaddress import IPv4Address, IPv4Network
+from typing import Any
+from unittest.mock import patch
+
+import pytest
+
+from aiodiscover import discovery
+
+if sys.platform == "win32":
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
+
+@pytest.mark.asyncio
+async def test_async_discover_hosts() -> None:
+    """Verify discover hosts does not throw."""
+    discover_hosts = discovery.DiscoverHosts()
+    with patch.object(discovery, "MAX_ADDRESSES", 16):
+        hosts = await discover_hosts.async_discover()
+    assert isinstance(hosts, list)
+
+
+@pytest.mark.asyncio
+async def test_async_discover_hosts_with_dns_mock() -> None:
+    """Verify discover hosts does not throw."""
+    discover_hosts = discovery.DiscoverHosts()
+    with (
+        patch.object(discovery, "MAX_ADDRESSES", 2),
+        patch(
+            "aiodiscover.discovery.dns_message_short_hostname", return_value="router"
+        ),
+    ):
+        hosts = await discover_hosts.async_discover()
+    assert isinstance(hosts, list)
+
+
+@pytest.mark.asyncio
+async def test_async_discover_hosts_with_dns_mock_neighbor_mock() -> None:
+    """Verify discover hosts does not throw."""
+    discover_hosts = discovery.DiscoverHosts()
+
+    async def _async_get_hostnames(sys_network_data: Any) -> dict[str, str]:
+        return {"1.2.3.4": "router", "4.5.5.6": "any"}
+
+    discover_hosts.async_get_hostnames = _async_get_hostnames  # type: ignore
+    with (
+        patch(
+            "aiodiscover.network.SystemNetworkData.async_get_neighbors",
+            return_value={
+                "1.2.3.4": "aa:bb:cc:dd:ee:ff",
+                "4.5.5.6": "ff:bb:cc:0d:ee:ff",
+            },
+        ),
+        patch(
+            "aiodiscover.network.get_network",
+            return_value=IPv4Network("1.2.3.0/24", False),
+        ),
+    ):
+        hosts = await discover_hosts.async_discover()
+
+    assert hosts == [
+        {"hostname": "router", "ip": "1.2.3.4", "macaddress": "aa:bb:cc:dd:ee:ff"},
+        {"hostname": "any", "ip": "4.5.5.6", "macaddress": "ff:bb:cc:0d:ee:ff"},
+    ]
+
+
+@pytest.mark.asyncio
+async def test_async_query_for_ptrs() -> None:
+    """Test async_query_for_ptrs handles missing ips."""
+    loop = asyncio.get_running_loop()
+    count = 0
+
+    @dataclass
+    class MockReply:
+        name: str
+
+    def mock_query(*args: Any, **kwargs: Any) -> Any:
+        nonlocal count
+        count += 1
+        future = loop.create_future()
+        if count == 2:
+            future.set_exception(Exception("test"))
+        else:
+            future.set_result(MockReply(name=f"name{count}"))
+        return future
+
+    with (
+        patch.object(discovery, "DNS_RESPONSE_TIMEOUT", 0),
+        patch("aiodiscover.discovery.DNSResolver.query", mock_query),
+    ):
+        response = await discovery.async_query_for_ptrs(
+            "192.168.107.1",
+            [
+                IPv4Address("192.168.107.2"),
+                IPv4Address("192.168.107.3"),
+                IPv4Address("192.168.107.4"),
+            ],
+        )
+
+    assert len(response) == 3
+    assert response[0].name == "name1"  # type: ignore
+    assert response[1] is None  # type: ignore
+    assert response[2].name == "name3"  # type: ignore
+
+
+@pytest.mark.asyncio
+async def test_async_query_for_ptrs_chunked() -> None:
+    """Test async_query_for_ptrs chunkeds."""
+    loop = asyncio.get_running_loop()
+    count = 0
+
+    @dataclass
+    class MockReply:
+        name: str
+
+    def mock_query(*args: Any, **kwargs: Any) -> Any:
+        nonlocal count
+        count += 1
+        future = loop.create_future()
+        if count == 2:
+            future.set_exception(Exception("test"))
+        else:
+            future.set_result(MockReply(name=f"name{count}"))
+        return future
+
+    with (
+        patch.object(discovery, "DNS_RESPONSE_TIMEOUT", 0),
+        patch("aiodiscover.discovery.DNSResolver.query", mock_query),
+        patch.object(discovery, "QUERY_BUCKET_SIZE", 1),
+    ):
+        response = await discovery.async_query_for_ptrs(
+            "192.168.107.1",
+            [
+                IPv4Address("192.168.107.2"),
+                IPv4Address("192.168.107.3"),
+                IPv4Address("192.168.107.4"),
+            ],
+        )
+
+    assert len(response) == 3
+    assert response[0].name == "name1"  # type: ignore
+    assert response[1] is None
+    assert response[2].name == "name3"  # type: ignore

aiodiscover/tests/test_init.py

@@ -0,0 +1,8 @@
+#!/usr/bin/env python
+
+import aiodiscover
+
+
+def test_get_module_version() -> None:
+    """Verify get_module_version does not throw."""
+    assert aiodiscover.get_module_version() == aiodiscover.__version__

aiodiscover/util.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+import sys
+
+if sys.version_info[:2] < (3, 11):
+    from async_timeout import timeout as asyncio_timeout
+else:
+    from asyncio import timeout as asyncio_timeout  # noqa: F401

aiodiscover-2.2.0.dist-info/LICENSE

@@ -0,0 +1,15 @@
+Apache Software License 2.0
+
+Copyright (c) 2021, J. Nick Koston
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

aiodiscover-2.2.0.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.1
+Name: aiodiscover
+Version: 2.2.0
+Summary: Discover hosts by arp and ptr lookup
+Home-page: https://github.com/uilibs/aiodiscover
+Author: J. Nick Koston
+Author-email: nick@koston.org
+Requires-Python: >=3.9,<4.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+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: Topic :: Software Development :: Libraries
+Requires-Dist: aiodns (>=3.1.1)
+Requires-Dist: async_timeout (>=4.0.1)
+Requires-Dist: cached_ipaddress (>=0.2.0)
+Requires-Dist: ifaddr (>0.0.0)
+Requires-Dist: netifaces (>=0.11.0)
+Requires-Dist: pyroute2 (>=0.7.3)
+Project-URL: Bug Tracker, https://github.com/bdraco/aiodiscover/issues
+Project-URL: Changelog, https://github.com/bdraco/aiodiscover/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://aiodiscover.readthedocs.io
+Project-URL: Repository, https://github.com/uilibs/aiodiscover
+Description-Content-Type: text/markdown
+
+# Async Host discovery
+
+[![Build Status](https://github.com/bdraco/aiodiscover/workflows/Build%20Main/badge.svg)](https://github.com/bdraco/aiodiscover/actions)
+[![Documentation](https://github.com/bdraco/aiodiscover/workflows/Documentation/badge.svg)](https://bdraco.github.io/aiodiscover/)
+[![Code Coverage](https://codecov.io/gh/bdraco/aiodiscover/branch/main/graph/badge.svg)](https://codecov.io/gh/bdraco/aiodiscover)
+
+Discover hosts by arp and ptr lookup
+
+---
+
+## Features
+
+- Discover hosts on the network via ARP and PTR lookup
+
+## Quick Start
+
+```python
+import asyncio
+import pprint
+from aiodiscover import DiscoverHosts
+
+discover_hosts = DiscoverHosts()
+hosts = asyncio.run(discover_hosts.async_discover())
+pprint.pprint(hosts)
+```
+
+## Installation
+
+**Stable Release:** `pip install aiodiscover`<br>
+**Development Head:** `pip install git+https://github.com/bdraco/aiodiscover.git`
+
+## Documentation
+
+For full package documentation please visit [bdraco.github.io/aiodiscover](https://bdraco.github.io/aiodiscover).
+
+## Development
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for information related to developing the code.
+
+## The Four Commands You Need To Know
+
+1. `pip install -e .[dev]`
+
+   This will install your package in editable mode with all the required development
+   dependencies (i.e. `tox`).
+
+2. `make build`
+
+   This will run `tox` which will run all your tests in both Python 3.7
+   and Python 3.8 as well as linting your code.
+
+3. `make clean`
+
+   This will clean up various Python and build generated files so that you can ensure
+   that you are working in a clean environment.
+
+4. `make docs`
+
+   This will generate and launch a web browser to view the most up-to-date
+   documentation for your Python package.
+
+#### Additional Optional Setup Steps:
+
+- Turn your project into a GitHub repository:
+  - Make an account on [github.com](https://github.com)
+  - Go to [make a new repository](https://github.com/new)
+  - _Recommendations:_
+    - _It is strongly recommended to make the repository name the same as the Python
+      package name_
+    - _A lot of the following optional steps are *free* if the repository is Public,
+      plus open source is cool_
+  - After a GitHub repo has been created, run the commands listed under:
+    "...or push an existing repository from the command line"
+- Register your project with Codecov:
+  - Make an account on [codecov.io](https://codecov.io)(Recommended to sign in with GitHub)
+    everything else will be handled for you.
+- Ensure that you have set GitHub pages to build the `gh-pages` branch by selecting the
+  `gh-pages` branch in the dropdown in the "GitHub Pages" section of the repository settings.
+  ([Repo Settings](https://github.com/bdraco/aiodiscover/settings))
+- Register your project with PyPI:
+  - Make an account on [pypi.org](https://pypi.org)
+  - Go to your GitHub repository's settings and under the
+    [Secrets tab](https://github.com/bdraco/aiodiscover/settings/secrets/actions),
+    add a secret called `PYPI_TOKEN` with your password for your PyPI account.
+    Don't worry, no one will see this password because it will be encrypted.
+  - Next time you push to the branch `main` after using `bump2version`, GitHub
+    actions will build and deploy your Python package to PyPI.
+
+#### Suggested Git Branch Strategy
+
+1. `main` is for the most up-to-date development, very rarely should you directly
+   commit to this branch. GitHub Actions will run on every push and on a CRON to this
+   branch but still recommended to commit to your development branches and make pull
+   requests to main. If you push a tagged commit with bumpversion, this will also release to PyPI.
+2. Your day-to-day work should exist on branches separate from `main`. Even if it is
+   just yourself working on the repository, make a PR from your working branch to `main`
+   so that you can ensure your commits don't break the development head. GitHub Actions
+   will run on every push to any branch or any pull request from any branch to any other
+   branch.
+3. It is recommended to use "Squash and Merge" commits when committing PR's. It makes
+   each set of changes to `main` atomic and as a side effect naturally encourages small
+   well defined PR's.
+
+**Apache Software License 2.0**
+

aiodiscover-2.2.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+aiodiscover/__init__.py,sha256=6vpH6FNQRJyhHExxDYDMv5e1dYZoIgxLV4MB-dt357g,331
+aiodiscover/discovery.py,sha256=x-G54ilyP5jmF17wZ-ZTvgCrlPVyH8JjEinUibHE4co,5608
+aiodiscover/network.py,sha256=-Tj7FK5uDrhAWwdnYchF6s2x5BnfcmcujvEAmutWQrg,8486
+aiodiscover/tests/__init__.py,sha256=muJYZG2c0S4gX2epuq-XqFa4x2bU2pkRU84m24p63is,41
+aiodiscover/tests/conftest.py,sha256=-JIt3g1eBf4bVQNNQd4JBeQNA7o0LK0W9tYKKX_r5s8,22
+aiodiscover/tests/test_discovery.py,sha256=zNpAKIIcCKTdMXfzczE3VC3aQbxfhpSCVHLAd-g2IgI,4461
+aiodiscover/tests/test_init.py,sha256=UKj1UfbDaeQ1m47P8-AXObkT35SCpHtevM_My0mvDg0,206
+aiodiscover/util.py,sha256=zDWuAJhWkZtz_J0IqpE6sGFJXzjViGxQJKUfdjHogdY,211
+aiodiscover-2.2.0.dist-info/LICENSE,sha256=CRuitFRo3zhJ7rtke-w2aMSDaveQ0nEURZfVd_rFDs0,585
+aiodiscover-2.2.0.dist-info/METADATA,sha256=M3Ioccqhi6bmstFbYqUDhWqrZsgLl_rHfsQn6EXUfMU,5571
+aiodiscover-2.2.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+aiodiscover-2.2.0.dist-info/RECORD,,

aiodiscover-2.2.0.dist-info/WHEEL

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