ipsubnet 1.0.1__py3-none-any.whl

ipsubnet/__init__.py

@@ -0,0 +1,3 @@
+"""IP subnetting and addressing calculator."""
+
+__version__ = "1.0.1"

ipsubnet/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from ipsubnet.cli import main
+
+sys.exit(main())

ipsubnet/cli.py

@@ -0,0 +1,298 @@
+"""Command-line interface for ipsubnet."""
+
+import argparse
+import json
+import os
+import sys
+from typing import List, Optional
+
+from . import __version__
+from .core import (SubnetError, describe, parse, resolve_new_prefix, subnet_count,
+                   subnet_rows)
+
+DEFAULT_LIMIT = 64
+
+EXAMPLES = """\
+examples:
+  ipsubnet 192.168.1.10/24
+  ipsubnet 192.168.1.10 255.255.255.0
+  ipsubnet 10.0.0.0/16 --subnets 8
+  ipsubnet 172.16.0.0/22 --hosts 100
+  ipsubnet 192.168.0.0/24 --prefix 27
+  ipsubnet 2001:db8::1/48 --prefix 52
+  ipsubnet 192.168.1.10/24 --json
+
+Run without arguments for interactive mode.
+"""
+
+
+class Style:
+    """ANSI colours, switched off when output isn't a terminal or NO_COLOR is set."""
+
+    def __init__(self, enabled: bool):
+        self.enabled = enabled
+
+    def _wrap(self, code: str, text: str) -> str:
+        return "\033[{}m{}\033[0m".format(code, text) if self.enabled else text
+
+    def bold(self, t): return self._wrap("1", t)
+    def dim(self, t): return self._wrap("2", t)
+    def cyan(self, t): return self._wrap("36", t)
+    def green(self, t): return self._wrap("32", t)
+    def yellow(self, t): return self._wrap("33", t)
+    def red(self, t): return self._wrap("31", t)
+    def magenta(self, t): return self._wrap("35", t)
+
+
+def _enable_windows_ansi() -> bool:
+    if os.name != "nt":
+        return True
+    try:
+        import ctypes
+        kernel32 = ctypes.windll.kernel32
+        handle = kernel32.GetStdHandle(-11)
+        mode = ctypes.c_uint32()
+        if not kernel32.GetConsoleMode(handle, ctypes.byref(mode)):
+            return False
+        return bool(kernel32.SetConsoleMode(handle, mode.value | 0x0004))
+    except Exception:
+        return False
+
+
+def make_style(no_color: bool) -> Style:
+    if no_color or os.environ.get("NO_COLOR") or not sys.stdout.isatty():
+        return Style(False)
+    return Style(_enable_windows_ansi())
+
+
+def fmt_int(n: int) -> str:
+    return "{:,}".format(n)
+
+
+def render_binary(bits: str, prefix: int, s: Style) -> str:
+    """Colour network bits and host bits differently."""
+    out, seen = [], 0
+    for ch in bits:
+        if ch == ".":
+            out.append(s.dim("."))
+            continue
+        out.append(s.cyan(ch) if seen < prefix else s.yellow(ch))
+        seen += 1
+    return "".join(out)
+
+
+def render_summary(info: dict, s: Style) -> str:
+    rows = [("Address", info["address"])]
+    rows.append(("Network", s.green(info["cidr"])))
+    if info["version"] == 4:
+        rows += [
+            ("Netmask", "{}  (/{})".format(info["netmask"], info["prefix"])),
+            ("Wildcard", info["wildcard"]),
+            ("Network address", info["network"]),
+            ("Broadcast", info["broadcast"]),
+        ]
+    else:
+        rows += [
+            ("Expanded", info["expanded"]),
+            ("Prefix length", "/{}".format(info["prefix"])),
+            ("Network address", info["network"]),
+        ]
+    rows += [
+        ("Usable range", s.green("{} - {}".format(info["first_host"], info["last_host"]))),
+        ("Usable hosts", fmt_int(info["usable_hosts"])),
+        ("Total addresses", fmt_int(info["total_addresses"])),
+    ]
+    if info["version"] == 4:
+        rows.append(("Class", info["class"]))
+    rows.append(("Type", info["scope"]))
+
+    width = max(len(k) for k, _ in rows)
+    lines = ["  {}  {}".format(s.bold(k.ljust(width)), v) for k, v in rows]
+
+    if info["version"] == 4:
+        b = info["binary"]
+        lines += ["", "  " + s.bold("Binary") + s.dim("  (network bits | host bits)")]
+        for label in ("address", "netmask", "network", "broadcast"):
+            lines.append("  {}  {}".format(
+                label.capitalize().ljust(width),
+                render_binary(b[label], info["prefix"], s)))
+    return "\n".join(lines)
+
+
+def render_table(rows: List[dict], s: Style) -> str:
+    ipv4 = rows and rows[0]["broadcast"] is not None
+    headers = ["#", "Subnet", "First host", "Last host"]
+    if ipv4:
+        headers.append("Broadcast")
+    headers.append("Usable")
+
+    data = []
+    for r in rows:
+        line = [str(r["index"]), r["network"], r["first_host"], r["last_host"]]
+        if ipv4:
+            line.append(r["broadcast"])
+        line.append(fmt_int(r["usable_hosts"]))
+        data.append(line)
+
+    widths = [max(len(h), *(len(d[i]) for d in data)) for i, h in enumerate(headers)]
+
+    def fmt(cells, color=None):
+        parts = []
+        for i, (c, w) in enumerate(zip(cells, widths)):
+            # Right-align numeric columns.
+            cell = c.rjust(w) if i in (0, len(cells) - 1) else c.ljust(w)
+            parts.append(cell)
+        text = "  ".join(parts)
+        return color(text) if color else text
+
+    out = ["  " + fmt(headers, s.bold), "  " + s.dim("  ".join("-" * w for w in widths))]
+    out += ["  " + fmt(d) for d in data]
+    return "\n".join(out)
+
+
+def run(address: str, mask: Optional[str], new_prefix: Optional[int], subnets: Optional[int],
+        hosts: Optional[int], limit: Optional[int], as_json: bool, s: Style) -> None:
+    iface, note = parse(address, mask)
+    info = describe(iface)
+    net = iface.network
+
+    split_wanted = any(x is not None for x in (new_prefix, subnets, hosts))
+    target = resolve_new_prefix(net, new_prefix, subnets, hosts) if split_wanted else None
+
+    if as_json:
+        payload = dict(info)
+        if note:
+            payload["note"] = note
+        if target is not None:
+            payload["subnetting"] = {
+                "new_prefix": target,
+                "subnet_count": subnet_count(net, target),
+                "subnets": subnet_rows(net, target, limit),
+                "truncated": limit is not None and subnet_count(net, target) > limit,
+            }
+        print(json.dumps(payload, indent=2))
+        return
+
+    print()
+    if note:
+        print("  " + s.yellow(note))
+        print()
+    print(render_summary(info, s))
+
+    if target is not None:
+        count = subnet_count(net, target)
+        rows = subnet_rows(net, target, limit)
+        per = rows[0]["usable_hosts"]
+        print()
+        print("  {}  {} into /{}: {} subnet{}, {} usable host{} each".format(
+            s.bold("Subnets"), info["cidr"], target, fmt_int(count), "" if count == 1 else "s",
+            fmt_int(per), "" if per == 1 else "s"))
+        print()
+        print(render_table(rows, s))
+        if count > len(rows):
+            print()
+            print("  " + s.dim("... showing {} of {} subnets. Use --limit N or --all to see more."
+                               .format(fmt_int(len(rows)), fmt_int(count))))
+    print()
+
+
+def _ask(prompt: str, s: Style) -> str:
+    try:
+        return input(s.magenta("? ") + prompt).strip()
+    except EOFError:
+        raise KeyboardInterrupt from None
+
+
+def interactive(s: Style, limit: Optional[int]) -> int:
+    print()
+    print("  " + s.bold("ipsubnet {}".format(__version__)) + " - IP subnetting calculator")
+    print("  " + s.dim("Press Enter on an empty line or Ctrl+C to quit."))
+    while True:
+        print()
+        try:
+            address = _ask("IP address (e.g. 192.168.1.10 or 192.168.1.10/24): ", s)
+            if not address:
+                return 0
+            mask = None
+            if "/" not in address:
+                mask = _ask("Subnet mask or CIDR (e.g. 255.255.255.0 or 24, Enter for default): ", s) or None
+            split = _ask("Split into subnets? Enter /prefix, N subnets ('8s'), N hosts ('50h'), "
+                         "or Enter to skip: ", s).lower()
+        except KeyboardInterrupt:
+            print()
+            return 0
+
+        new_prefix = subnets = hosts = None
+        try:
+            if split:
+                if split.endswith("s") and split[:-1].isdigit():
+                    subnets = int(split[:-1])
+                elif split.endswith("h") and split[:-1].isdigit():
+                    hosts = int(split[:-1])
+                elif split.lstrip("/").isdigit():
+                    new_prefix = int(split.lstrip("/"))
+                else:
+                    raise SubnetError("didn't understand '{}'".format(split))
+            run(address, mask, new_prefix, subnets, hosts, limit, False, s)
+        except SubnetError as e:
+            print("  " + s.red("error: ") + str(e))
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="ipsubnet",
+        description="IP subnetting and addressing calculator for IPv4 and IPv6. "
+                    "Shows the network address, broadcast, usable host range and "
+                    "can split a network into subnets.",
+        epilog=EXAMPLES,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    p.add_argument("address", nargs="?",
+                   help="IP address, optionally with CIDR (192.168.1.10/24) or mask (192.168.1.10/255.255.255.0)")
+    p.add_argument("mask", nargs="?",
+                   help="subnet mask or prefix if not included in the address (255.255.255.0 or 24)")
+
+    g = p.add_argument_group("subnetting (pick one)")
+    ex = g.add_mutually_exclusive_group()
+    ex.add_argument("-p", "--prefix", type=int, metavar="N", help="split into subnets of prefix /N")
+    ex.add_argument("-s", "--subnets", type=int, metavar="N", help="split into at least N equal subnets")
+    ex.add_argument("-H", "--hosts", type=int, metavar="N",
+                    help="split into the smallest subnets that fit N usable hosts each")
+
+    o = p.add_argument_group("output")
+    o.add_argument("-l", "--limit", type=int, default=DEFAULT_LIMIT, metavar="N",
+                   help="max subnets to list (default {})".format(DEFAULT_LIMIT))
+    o.add_argument("-a", "--all", action="store_true", help="list every subnet (can be huge)")
+    o.add_argument("-j", "--json", action="store_true", help="print JSON instead of a table")
+    o.add_argument("--no-color", action="store_true", help="disable coloured output")
+    p.add_argument("-V", "--version", action="version", version="ipsubnet " + __version__)
+    return p
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    args = build_parser().parse_args(argv)
+    s = make_style(args.no_color or args.json)
+    limit = None if args.all else max(args.limit, 1)
+
+    if args.address is None:
+        if sys.stdin.isatty():
+            return interactive(s, limit)
+        build_parser().print_help()
+        return 2
+
+    try:
+        run(args.address, args.mask, args.prefix, args.subnets, args.hosts, limit, args.json, s)
+    except SubnetError as e:
+        print("ipsubnet: error: {}".format(e), file=sys.stderr)
+        return 1
+    except KeyboardInterrupt:
+        return 130
+    except BrokenPipeError:
+        # e.g. `ipsubnet ... --all | head`
+        sys.stderr.close()
+        return 0
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ipsubnet/core.py

@@ -0,0 +1,244 @@
+"""Subnet math: parsing input, describing a network, and splitting it into subnets."""
+
+import ipaddress
+import math
+from typing import Iterator, List, Optional, Tuple, Union
+
+Interface = Union[ipaddress.IPv4Interface, ipaddress.IPv6Interface]
+Network = Union[ipaddress.IPv4Network, ipaddress.IPv6Network]
+
+
+class SubnetError(ValueError):
+    """Raised for any input the calculator cannot work with."""
+
+
+def classful_prefix(ip: ipaddress.IPv4Address) -> Optional[int]:
+    """Default prefix for the IPv4 address class (A=/8, B=/16, C=/24), or None for D/E."""
+    first = int(ip) >> 24
+    if first < 128:
+        return 8
+    if first < 192:
+        return 16
+    if first < 224:
+        return 24
+    return None
+
+
+def _parse_mask(mask: str, version: int) -> int:
+    """Turn '24', '/24', '255.255.255.0' or a wildcard like '0.0.0.255' into a prefix length."""
+    mask = mask.strip().lstrip("/")
+    if not mask:
+        raise SubnetError("empty subnet mask")
+    if mask.isdigit():
+        prefix = int(mask)
+        limit = 32 if version == 4 else 128
+        if not 0 <= prefix <= limit:
+            raise SubnetError("prefix /{} is out of range (0-{})".format(prefix, limit))
+        return prefix
+    if version == 6:
+        raise SubnetError("IPv6 needs a prefix length such as /64, not a dotted mask")
+    try:
+        # ipaddress accepts both netmasks and wildcard (host) masks here.
+        return ipaddress.IPv4Network("0.0.0.0/" + mask).prefixlen
+    except ValueError:
+        raise SubnetError("'{}' is not a valid subnet mask".format(mask)) from None
+
+
+def parse(address: str, mask: Optional[str] = None) -> Tuple[Interface, Optional[str]]:
+    """Parse user input into an interface (address + prefix).
+
+    Returns the interface and an optional note to show the user (e.g. when a
+    default mask was assumed).
+    """
+    address = address.strip()
+    if "/" in address:
+        if mask:
+            raise SubnetError("give the mask either as /CIDR or as a separate argument, not both")
+        address, mask = address.split("/", 1)
+
+    try:
+        ip = ipaddress.ip_address(address)
+    except ValueError:
+        raise SubnetError("'{}' is not a valid IPv4 or IPv6 address".format(address)) from None
+
+    note = None
+    if mask is None:
+        if ip.version == 4:
+            prefix = classful_prefix(ip)
+            if prefix is None:
+                raise SubnetError(
+                    "{} is a class D/E address and has no default mask; please give one".format(ip)
+                )
+            note = "No mask given; assumed the classful default /{}.".format(prefix)
+        else:
+            prefix = 64
+            note = "No prefix given; assumed /64."
+    else:
+        prefix = _parse_mask(mask, ip.version)
+
+    return ipaddress.ip_interface("{}/{}".format(ip, prefix)), note
+
+
+def ip_class(ip: ipaddress.IPv4Address) -> str:
+    first = int(ip) >> 24
+    if first < 128:
+        return "A"
+    if first < 192:
+        return "B"
+    if first < 224:
+        return "C"
+    if first < 240:
+        return "D (multicast)"
+    return "E (reserved)"
+
+
+DOCUMENTATION_NETS = [ipaddress.ip_network(n) for n in (
+    "192.0.2.0/24", "198.51.100.0/24", "203.0.113.0/24", "2001:db8::/32")]
+
+
+def ip_scope(ip: Union[ipaddress.IPv4Address, ipaddress.IPv6Address]) -> str:
+    if ip.is_loopback:
+        return "Loopback"
+    if ip.is_link_local:
+        return "Link-local"
+    if ip.is_multicast:
+        return "Multicast"
+    if ip.is_unspecified:
+        return "Unspecified"
+    if any(ip.version == n.version and ip in n for n in DOCUMENTATION_NETS):
+        return "Documentation (example range)"
+    if ip.version == 4 and ip in ipaddress.IPv4Network("100.64.0.0/10"):
+        return "Shared address space (CGNAT)"
+    if ip.is_private:
+        return "Private"
+    if ip.is_reserved:
+        return "Reserved"
+    if ip.is_global:
+        return "Public"
+    return "Special-purpose"
+
+
+def host_range(net: Network) -> Tuple[object, object, int]:
+    """First usable, last usable and usable count for a network.
+
+    IPv4 /31 links use both addresses (RFC 3021); /32 is a single host.
+    IPv6 has no broadcast address, so every address is usable.
+    """
+    total = net.num_addresses
+    if net.version == 6 or net.prefixlen >= net.max_prefixlen - 1:
+        return net.network_address, net.broadcast_address, total
+    return net.network_address + 1, net.broadcast_address - 1, total - 2
+
+
+def to_binary(ip: ipaddress.IPv4Address) -> str:
+    bits = format(int(ip), "032b")
+    return ".".join(bits[i:i + 8] for i in range(0, 32, 8))
+
+
+def describe(iface: Interface) -> dict:
+    """All the facts about an address and the network it sits in."""
+    net = iface.network
+    ip = iface.ip
+    first, last, usable = host_range(net)
+    info = {
+        "version": ip.version,
+        "address": str(ip),
+        "cidr": "{}/{}".format(net.network_address, net.prefixlen),
+        "prefix": net.prefixlen,
+        "network": str(net.network_address),
+        "first_host": str(first),
+        "last_host": str(last),
+        "total_addresses": net.num_addresses,
+        "usable_hosts": usable,
+        "scope": ip_scope(ip),
+    }
+    if ip.version == 4:
+        info.update({
+            "netmask": str(net.netmask),
+            "wildcard": str(net.hostmask),
+            "broadcast": str(net.broadcast_address),
+            "class": ip_class(ip),
+            "binary": {
+                "address": to_binary(ip),
+                "netmask": to_binary(net.netmask),
+                "network": to_binary(net.network_address),
+                "broadcast": to_binary(net.broadcast_address),
+            },
+        })
+    else:
+        info.update({
+            "netmask": None,
+            "wildcard": None,
+            "broadcast": None,
+            "expanded": ip.exploded,
+        })
+    return info
+
+
+def resolve_new_prefix(net: Network, new_prefix: Optional[int] = None,
+                       subnets: Optional[int] = None, hosts: Optional[int] = None) -> int:
+    """Work out the target prefix from exactly one of: new prefix, subnet count, hosts per subnet."""
+    given = [x is not None for x in (new_prefix, subnets, hosts)]
+    if sum(given) != 1:
+        raise SubnetError("choose exactly one of --prefix, --subnets or --hosts")
+
+    max_len = net.max_prefixlen
+    if new_prefix is not None:
+        if not net.prefixlen <= new_prefix <= max_len:
+            raise SubnetError(
+                "new prefix must be between /{} and /{}".format(net.prefixlen, max_len)
+            )
+        return new_prefix
+
+    if subnets is not None:
+        if subnets < 1:
+            raise SubnetError("number of subnets must be at least 1")
+        borrowed = math.ceil(math.log2(subnets)) if subnets > 1 else 0
+        result = net.prefixlen + borrowed
+        if result > max_len:
+            raise SubnetError(
+                "/{} cannot be split into {} subnets (at most {})".format(
+                    net.prefixlen, subnets, 2 ** (max_len - net.prefixlen))
+            )
+        return result
+
+    if hosts < 1:
+        raise SubnetError("hosts per subnet must be at least 1")
+    # IPv4 subnets reserve network + broadcast (textbook rule; a single host gets /32).
+    if net.version == 4 and hosts > 1:
+        needed = hosts + 2
+    else:
+        needed = hosts
+    host_bits = math.ceil(math.log2(needed)) if needed > 1 else 0
+    result = max_len - host_bits
+    if result < net.prefixlen:
+        raise SubnetError(
+            "/{} is too small for {} hosts per subnet (it has {} usable)".format(
+                net.prefixlen, hosts, host_range(net)[2])
+        )
+    return result
+
+
+def split(net: Network, new_prefix: int) -> Iterator[Network]:
+    return net.subnets(new_prefix=new_prefix)
+
+
+def subnet_count(net: Network, new_prefix: int) -> int:
+    return 2 ** (new_prefix - net.prefixlen)
+
+
+def subnet_rows(net: Network, new_prefix: int, limit: Optional[int]) -> List[dict]:
+    rows = []
+    for i, sub in enumerate(split(net, new_prefix), 1):
+        if limit is not None and i > limit:
+            break
+        first, last, usable = host_range(sub)
+        rows.append({
+            "index": i,
+            "network": str(sub),
+            "first_host": str(first),
+            "last_host": str(last),
+            "broadcast": str(sub.broadcast_address) if sub.version == 4 else None,
+            "usable_hosts": usable,
+        })
+    return rows

ipsubnet-1.0.1.dist-info/METADATA

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: ipsubnet
+Version: 1.0.1
+Summary: IP subnetting and addressing calculator for the command line (IPv4 and IPv6)
+Author: Shazan Hussain Zaidi, Harshit Agrawal, Prabhat Bhati
+License: MIT
+Project-URL: Homepage, https://github.com/ShazanZaidii/ipsubnet
+Keywords: subnet,cidr,ip,network,calculator,cli
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ipsubnet
+
+An IP subnetting and addressing calculator for the command line. Give it an IP address with a subnet mask or CIDR prefix. It prints the network address, broadcast address, usable host range and host counts, and it can split the network into a list of subnets. It works with IPv4 and IPv6 on Windows, macOS and Linux.
+
+## Install
+
+**Windows** (PowerShell):
+
+```powershell
+irm https://raw.githubusercontent.com/ShazanZaidii/ipsubnet/main/scripts/install.ps1 | iex
+```
+
+**macOS / Linux**:
+
+```sh
+curl -fsSL https://raw.githubusercontent.com/ShazanZaidii/ipsubnet/main/scripts/install.sh | sh
+```
+
+**With Python** (any OS, Python 3.8+):
+
+```sh
+pip install ipsubnet
+```
+
+or, to keep it isolated from other packages, `pipx install ipsubnet`.
+
+You can also download a ready-to-run binary from the [Releases page](https://github.com/ShazanZaidii/ipsubnet/releases/latest):
+
+| OS | File |
+|---|---|
+| Windows | `ipsubnet-windows-x64.exe` |
+| macOS (Apple Silicon) | `ipsubnet-macos-arm64` |
+| macOS (Intel) | `ipsubnet-macos-x64` |
+| Linux (x64) | `ipsubnet-linux-x64` |
+| Linux (ARM64) | `ipsubnet-linux-arm64` |
+
+On macOS and Linux, run `chmod +x` on the file first. On macOS, if you downloaded it with a browser, also run `xattr -d com.apple.quarantine <file>`.
+
+## Usage
+
+```
+ipsubnet ADDRESS[/PREFIX] [MASK] [--prefix N | --subnets N | --hosts N] [options]
+```
+
+| Input | Meaning |
+|---|---|
+| `192.168.1.10/24` | Address with a CIDR prefix |
+| `192.168.1.10 255.255.255.0` | Address and a dotted subnet mask |
+| `192.168.1.10 24` | Address and a prefix length |
+| `192.168.1.10` | Uses the classful default mask (A=/8, B=/16, C=/24) |
+| `2001:db8::1/48` | IPv6 |
+
+| Option | Description |
+|---|---|
+| `-p, --prefix N` | Split into subnets of size /N |
+| `-s, --subnets N` | Split into at least N equal subnets |
+| `-H, --hosts N` | Split into the smallest subnets that fit N usable hosts each |
+| `-l, --limit N` | Show at most N subnets (default 64) |
+| `-a, --all` | Show every subnet |
+| `-j, --json` | Output JSON |
+| `--no-color` | Turn off colours |
+
+If you run `ipsubnet` with no arguments, it starts in interactive mode and asks for each value. This is also what happens when you double-click the Windows `.exe`.
+
+### Example
+
+```
+$ ipsubnet 192.168.1.10/24 --hosts 50
+
+  Address          192.168.1.10
+  Network          192.168.1.0/24
+  Netmask          255.255.255.0  (/24)
+  Wildcard         0.0.0.255
+  Network address  192.168.1.0
+  Broadcast        192.168.1.255
+  Usable range     192.168.1.1 - 192.168.1.254
+  Usable hosts     254
+  Total addresses  256
+  Class            C
+  Type             Private
+
+  Binary  (network bits | host bits)
+  Address          11000000.10101000.00000001.00001010
+  Netmask          11111111.11111111.11111111.00000000
+  Network          11000000.10101000.00000001.00000000
+  Broadcast        11000000.10101000.00000001.11111111
+
+  Subnets  192.168.1.0/24 into /26: 4 subnets, 62 usable hosts each
+
+  #  Subnet            First host     Last host      Broadcast      Usable
+  -  ----------------  -------------  -------------  -------------  ------
+  1  192.168.1.0/26    192.168.1.1    192.168.1.62   192.168.1.63       62
+  2  192.168.1.64/26   192.168.1.65   192.168.1.126  192.168.1.127      62
+  3  192.168.1.128/26  192.168.1.129  192.168.1.190  192.168.1.191      62
+  4  192.168.1.192/26  192.168.1.193  192.168.1.254  192.168.1.255      62
+```
+
+## How it works
+
+- **Network address**: the IP AND the subnet mask (all host bits set to 0).
+- **Broadcast address**: the network address with all host bits set to 1.
+- **Usable hosts**: 2^(32 − prefix) − 2 for IPv4, because the network and broadcast addresses can't be assigned to hosts. A /31 has 2 usable addresses (point-to-point links, RFC 3021) and a /32 has 1.
+- **Subnetting**: borrowing *b* host bits creates 2^b subnets of prefix + *b*.
+  - `--subnets N` borrows ⌈log₂ N⌉ bits.
+  - `--hosts N` keeps ⌈log₂(N + 2)⌉ host bits.
+- **IPv6** has no broadcast address, so every address in the prefix is counted as usable.
+
+## Development
+
+```sh
+pip install -e .
+python -m unittest discover -s tests -v
+```
+
+Pushing a tag like `v1.0.1` makes GitHub Actions run the tests on all three operating systems, build the binaries and publish a release.
+
+## Authors
+
+Group 4: Shazan Hussain Zaidi, Harshit Agrawal, Prabhat Bhati

ipsubnet-1.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+ipsubnet/__init__.py,sha256=CPSYTvFM_bjsaEJ5Vc3gqyKJC4rAMwOA2WdxODyxl_s,70
+ipsubnet/__main__.py,sha256=VDDt6PjW8FfNVs0yz8nIRMQ5bhcldgv9menjS59yQsA,60
+ipsubnet/cli.py,sha256=p5Ehgn8jQfdpt5kuJgBxE4JDnSF9SGZuIjQfJMNyeSk,10775
+ipsubnet/core.py,sha256=xElqJyUEVyuAa3BlONamKqhtXFIV_AvNIy2YyDwCnfg,8409
+ipsubnet-1.0.1.dist-info/licenses/LICENSE,sha256=nwyiEOEuxSwucb81U5Pf-swWbfXtX6AWrGp9WlIKebY,1109
+ipsubnet-1.0.1.dist-info/METADATA,sha256=61l1JrbBQKwAs9wVjFHetgV1r3hybPlZ18-pn9GUuRo,5003
+ipsubnet-1.0.1.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+ipsubnet-1.0.1.dist-info/entry_points.txt,sha256=L9vLkbQeV78mwA1uSunCoPJ7rgtCVJ5xIBAGbbOLzAQ,47
+ipsubnet-1.0.1.dist-info/top_level.txt,sha256=4sv85yzG4QCydDa5rhkKnHcPNVngGRBhkxlfJyDpsu8,9
+ipsubnet-1.0.1.dist-info/RECORD,,

ipsubnet-1.0.1.dist-info/WHEEL

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

ipsubnet-1.0.1.dist-info/entry_points.txt

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

ipsubnet-1.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shazan Hussain Zaidi, Harshit Agrawal, Prabhat Bhati
+
+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.

ipsubnet-1.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+ipsubnet