ipv4-conversions 0.1.0__tar.gz

ipv4_conversions-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Marco S. Tornabene
+
+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.

ipv4_conversions-0.1.0/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: ipv4-conversions
+Version: 0.1.0
+Summary: Convert IPv4 addresses between dotted decimal and dotted binary notation
+Author: Marco S. Tornabene
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/JustM4rk123/ipv4_conversions
+Keywords: ipv4,binary,decimal,conversions
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bin-dec-conversions>=1.0.0
+Requires-Dist: questionary
+Provides-Extra: dev
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# IPv4 Conversions
+
+`ipv4-conversions` converts an IPv4 address between dotted-decimal notation and four dotted 8-bit binary octets. It is available as a Python library, a command-line tool, and an interactive prompt.
+
+## Requirements
+
+- Python 3.10 or newer
+- [`bin-dec-conversions`](https://pypi.org/project/bin-dec-conversions/), which supplies the binary/decimal conversions for each octet
+- [`questionary`](https://pypi.org/project/questionary/), used by the interactive prompt
+
+## Installation
+
+```bash
+pip install .
+```
+
+## Library usage
+
+```python
+from ipv4_conversions import binary_to_ipv4, ipv4_to_binary
+
+ipv4_to_binary("192.168.1.1")
+# "11000000.10101000.00000001.00000001"
+
+binary_to_ipv4("11000000.10101000.00000001.00000001")
+# "192.168.1.1"
+```
+
+Both functions require exactly four octets. Decimal octets must be in the range `0` to `255`; binary octets must each contain exactly eight `0` or `1` characters. Invalid input raises `ValueError`.
+
+| Function | Description |
+| --- | --- |
+| `ipv4_to_binary(ipv4: str) -> str` | Converts dotted-decimal IPv4 notation to four zero-padded, dotted binary octets. |
+| `binary_to_ipv4(binary: str) -> str` | Converts four dotted 8-bit binary octets to dotted-decimal IPv4 notation. |
+
+## Command line
+
+```bash
+# Binary address to dotted decimal
+ipv4-conversions --to-decimal 11000000.10101000.00000001.00000001
+# The dotted-decimal equivalent of ... is: 192.168.1.1
+
+# Dotted decimal to binary address
+ipv4-conversions --to-binary 192.168.1.1
+# The binary equivalent of 192.168.1.1 is: 11000000.10101000.00000001.00000001
+```
+
+The short options are `-d` for `--to-decimal` and `-b` for `--to-binary`. The options are mutually exclusive. Running `ipv4-conversions` without options opens the interactive menu.
+
+## Interactive menu
+
+Run the command without any options to open the interactive menu:
+
+```bash
+ipv4-conversions
+```
+
+Choose **Binary address to dotted decimal** or **Dotted decimal to binary address**, then enter the address when prompted. Choose **Exit** to quit.
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest
+ruff check .
+```
+
+## License
+
+Released under the MIT License. See [LICENSE](LICENSE).

ipv4_conversions-0.1.0/README.md

@@ -0,0 +1,70 @@
+# IPv4 Conversions
+
+`ipv4-conversions` converts an IPv4 address between dotted-decimal notation and four dotted 8-bit binary octets. It is available as a Python library, a command-line tool, and an interactive prompt.
+
+## Requirements
+
+- Python 3.10 or newer
+- [`bin-dec-conversions`](https://pypi.org/project/bin-dec-conversions/), which supplies the binary/decimal conversions for each octet
+- [`questionary`](https://pypi.org/project/questionary/), used by the interactive prompt
+
+## Installation
+
+```bash
+pip install .
+```
+
+## Library usage
+
+```python
+from ipv4_conversions import binary_to_ipv4, ipv4_to_binary
+
+ipv4_to_binary("192.168.1.1")
+# "11000000.10101000.00000001.00000001"
+
+binary_to_ipv4("11000000.10101000.00000001.00000001")
+# "192.168.1.1"
+```
+
+Both functions require exactly four octets. Decimal octets must be in the range `0` to `255`; binary octets must each contain exactly eight `0` or `1` characters. Invalid input raises `ValueError`.
+
+| Function | Description |
+| --- | --- |
+| `ipv4_to_binary(ipv4: str) -> str` | Converts dotted-decimal IPv4 notation to four zero-padded, dotted binary octets. |
+| `binary_to_ipv4(binary: str) -> str` | Converts four dotted 8-bit binary octets to dotted-decimal IPv4 notation. |
+
+## Command line
+
+```bash
+# Binary address to dotted decimal
+ipv4-conversions --to-decimal 11000000.10101000.00000001.00000001
+# The dotted-decimal equivalent of ... is: 192.168.1.1
+
+# Dotted decimal to binary address
+ipv4-conversions --to-binary 192.168.1.1
+# The binary equivalent of 192.168.1.1 is: 11000000.10101000.00000001.00000001
+```
+
+The short options are `-d` for `--to-decimal` and `-b` for `--to-binary`. The options are mutually exclusive. Running `ipv4-conversions` without options opens the interactive menu.
+
+## Interactive menu
+
+Run the command without any options to open the interactive menu:
+
+```bash
+ipv4-conversions
+```
+
+Choose **Binary address to dotted decimal** or **Dotted decimal to binary address**, then enter the address when prompted. Choose **Exit** to quit.
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest
+ruff check .
+```
+
+## License
+
+Released under the MIT License. See [LICENSE](LICENSE).

ipv4_conversions-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ipv4-conversions"
+description = "Convert IPv4 addresses between dotted decimal and dotted binary notation"
+version = "0.1.0"
+requires-python = ">=3.10"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = ["ipv4", "binary", "decimal", "conversions"]
+authors = [
+    {name = "Marco S. Tornabene"}
+]
+dependencies = [
+    "bin-dec-conversions>=1.0.0",
+    "questionary",
+]
+
+[project.optional-dependencies]
+dev = [
+    "ruff",
+    "pytest",
+]
+
+[project.urls]
+Homepage = "https://github.com/JustM4rk123/ipv4_conversions"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[project.scripts]
+ipv4-conversions = "ipv4_conversions.cli:main"

ipv4_conversions-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ipv4_conversions-0.1.0/src/ipv4_conversions/__init__.py

@@ -0,0 +1,10 @@
+from importlib.metadata import PackageNotFoundError, version
+
+from .core import binary_to_ipv4, ipv4_to_binary
+
+try:
+    __version__ = version("ipv4-conversions")
+except PackageNotFoundError:
+    __version__ = "unknown"
+
+__all__ = ["__version__", "binary_to_ipv4", "ipv4_to_binary"]

ipv4_conversions-0.1.0/src/ipv4_conversions/cli.py

@@ -0,0 +1,85 @@
+import argparse
+import sys
+
+import questionary
+
+from .core import binary_to_ipv4, ipv4_to_binary
+
+
+def main():
+    parser = argparse.ArgumentParser(prog="ipv4-conversions")
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument(
+        "-d",
+        "--to-decimal",
+        dest="to_decimal",
+        metavar="BINARY",
+        type=str,
+        help="Convert a binary IPv4 address to dotted-decimal notation",
+    )
+    group.add_argument(
+        "-b",
+        "--to-binary",
+        dest="to_binary",
+        metavar="DECIMAL",
+        type=str,
+        help="Convert a dotted-decimal IPv4 address to binary",
+    )
+
+    args = parser.parse_args()
+
+    if args.to_decimal is not None:
+        try:
+            result = binary_to_ipv4(args.to_decimal)
+        except ValueError as e:
+            parser.error(str(e))
+        print(f"The dotted-decimal equivalent of {args.to_decimal} is: {result}")
+    elif args.to_binary is not None:
+        try:
+            result = ipv4_to_binary(args.to_binary)
+        except ValueError as e:
+            parser.error(str(e))
+        print(f"The binary equivalent of {args.to_binary} is: {result}")
+    else:
+        conversion = questionary.select(
+            "Which conversion do you want to perform?",
+            choices=[
+                "Binary address to dotted decimal",
+                "Dotted decimal to binary address",
+                "Exit",
+            ],
+        ).ask()
+
+        match conversion:
+            case "Binary address to dotted decimal":
+                while True:
+                    try:
+                        binary = input(
+                            "Insert four dotted 8-bit binary octets: "
+                        ).strip()
+                        print(
+                            f"The dotted-decimal equivalent of {binary} is: "
+                            f"{binary_to_ipv4(binary)}"
+                        )
+                    except ValueError as e:
+                        print(f"Invalid input: {e}")
+                    else:
+                        break
+            case "Dotted decimal to binary address":
+                while True:
+                    try:
+                        ipv4 = input("Insert a dotted-decimal IPv4 address: ").strip()
+                        print(
+                            f"The binary address equivalent of {ipv4} is: "
+                            f"{ipv4_to_binary(ipv4)}"
+                        )
+                    except ValueError as e:
+                        print(f"Invalid input: {e}")
+                    else:
+                        break
+            case "Exit":
+                sys.exit("Program terminated")
+
+
+if __name__ == "__main__":
+    main()

ipv4_conversions-0.1.0/src/ipv4_conversions/core.py

@@ -0,0 +1,55 @@
+from bin_dec_conversions import binary_to_decimal, decimal_to_binary
+
+
+def ipv4_to_binary(ipv4: str) -> str:
+    """Convert a dotted-decimal IPv4 address to four 8-bit binary octets."""
+    if not ipv4:
+        raise ValueError("The input is empty. Enter an IPv4 address with four octets")
+
+    octets = ipv4.split(".")
+    if len(octets) != 4:
+        raise ValueError(
+            f"'{ipv4}' is not a valid IPv4 address: exactly four decimal octets are required"
+        )
+
+    binary_octets = []
+    for octet in octets:
+        if not octet or not octet.isascii() or not octet.isdigit():
+            raise ValueError(
+                f"'{ipv4}' is not a valid IPv4 address: "
+                f"'{octet}' is not a decimal octet"
+            )
+
+        decimal = int(octet)
+        if decimal > 255:
+            raise ValueError(
+                f"'{ipv4}' is not a valid IPv4 address: "
+                f"octet '{octet}' is outside the range 0-255"
+            )
+        binary_octets.append(decimal_to_binary(decimal, 8))
+
+    return ".".join(binary_octets)
+
+
+def binary_to_ipv4(binary: str) -> str:
+    """Convert four dotted 8-bit binary octets to a dotted-decimal IPv4 address."""
+    if not binary:
+        raise ValueError("The input is empty. Enter four 8-bit binary octets")
+
+    octets = binary.split(".")
+    if len(octets) != 4:
+        raise ValueError(
+            f"'{binary}' is not a valid IPv4 binary address: "
+            "exactly four 8-bit binary octets are required"
+        )
+
+    decimal_octets = []
+    for octet in octets:
+        if len(octet) != 8:
+            raise ValueError(
+                f"'{binary}' is not a valid IPv4 binary address: "
+                f"octet '{octet}' must contain exactly 8 bits"
+            )
+        decimal_octets.append(str(binary_to_decimal(octet)))
+
+    return ".".join(decimal_octets)

ipv4_conversions-0.1.0/src/ipv4_conversions.egg-info/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: ipv4-conversions
+Version: 0.1.0
+Summary: Convert IPv4 addresses between dotted decimal and dotted binary notation
+Author: Marco S. Tornabene
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/JustM4rk123/ipv4_conversions
+Keywords: ipv4,binary,decimal,conversions
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bin-dec-conversions>=1.0.0
+Requires-Dist: questionary
+Provides-Extra: dev
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# IPv4 Conversions
+
+`ipv4-conversions` converts an IPv4 address between dotted-decimal notation and four dotted 8-bit binary octets. It is available as a Python library, a command-line tool, and an interactive prompt.
+
+## Requirements
+
+- Python 3.10 or newer
+- [`bin-dec-conversions`](https://pypi.org/project/bin-dec-conversions/), which supplies the binary/decimal conversions for each octet
+- [`questionary`](https://pypi.org/project/questionary/), used by the interactive prompt
+
+## Installation
+
+```bash
+pip install .
+```
+
+## Library usage
+
+```python
+from ipv4_conversions import binary_to_ipv4, ipv4_to_binary
+
+ipv4_to_binary("192.168.1.1")
+# "11000000.10101000.00000001.00000001"
+
+binary_to_ipv4("11000000.10101000.00000001.00000001")
+# "192.168.1.1"
+```
+
+Both functions require exactly four octets. Decimal octets must be in the range `0` to `255`; binary octets must each contain exactly eight `0` or `1` characters. Invalid input raises `ValueError`.
+
+| Function | Description |
+| --- | --- |
+| `ipv4_to_binary(ipv4: str) -> str` | Converts dotted-decimal IPv4 notation to four zero-padded, dotted binary octets. |
+| `binary_to_ipv4(binary: str) -> str` | Converts four dotted 8-bit binary octets to dotted-decimal IPv4 notation. |
+
+## Command line
+
+```bash
+# Binary address to dotted decimal
+ipv4-conversions --to-decimal 11000000.10101000.00000001.00000001
+# The dotted-decimal equivalent of ... is: 192.168.1.1
+
+# Dotted decimal to binary address
+ipv4-conversions --to-binary 192.168.1.1
+# The binary equivalent of 192.168.1.1 is: 11000000.10101000.00000001.00000001
+```
+
+The short options are `-d` for `--to-decimal` and `-b` for `--to-binary`. The options are mutually exclusive. Running `ipv4-conversions` without options opens the interactive menu.
+
+## Interactive menu
+
+Run the command without any options to open the interactive menu:
+
+```bash
+ipv4-conversions
+```
+
+Choose **Binary address to dotted decimal** or **Dotted decimal to binary address**, then enter the address when prompted. Choose **Exit** to quit.
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest
+ruff check .
+```
+
+## License
+
+Released under the MIT License. See [LICENSE](LICENSE).

ipv4_conversions-0.1.0/src/ipv4_conversions.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/ipv4_conversions/__init__.py
+src/ipv4_conversions/cli.py
+src/ipv4_conversions/core.py
+src/ipv4_conversions.egg-info/PKG-INFO
+src/ipv4_conversions.egg-info/SOURCES.txt
+src/ipv4_conversions.egg-info/dependency_links.txt
+src/ipv4_conversions.egg-info/entry_points.txt
+src/ipv4_conversions.egg-info/requires.txt
+src/ipv4_conversions.egg-info/top_level.txt
+tests/test_conversions.py
+tests/test_invalid.py

ipv4_conversions-0.1.0/src/ipv4_conversions.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ipv4_conversions-0.1.0/src/ipv4_conversions.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ipv4-conversions = ipv4_conversions.cli:main

ipv4_conversions-0.1.0/src/ipv4_conversions.egg-info/requires.txt

@@ -0,0 +1,6 @@
+bin-dec-conversions>=1.0.0
+questionary
+
+[dev]
+ruff
+pytest

ipv4_conversions-0.1.0/src/ipv4_conversions.egg-info/top_level.txt

@@ -0,0 +1 @@
+ipv4_conversions

ipv4_conversions-0.1.0/tests/test_conversions.py

@@ -0,0 +1,35 @@
+import pytest
+
+from ipv4_conversions import binary_to_ipv4, ipv4_to_binary
+
+
+@pytest.mark.parametrize(
+    "ipv4, expected",
+    [
+        ("0.0.0.0", "00000000.00000000.00000000.00000000"),
+        ("255.255.255.255", "11111111.11111111.11111111.11111111"),
+        ("192.168.1.1", "11000000.10101000.00000001.00000001"),
+        ("10.0.0.5", "00001010.00000000.00000000.00000101"),
+    ],
+)
+def test_ipv4_to_binary(ipv4, expected):
+    assert ipv4_to_binary(ipv4) == expected
+
+
+@pytest.mark.parametrize(
+    "binary, expected",
+    [
+        ("00000000.00000000.00000000.00000000", "0.0.0.0"),
+        ("11111111.11111111.11111111.11111111", "255.255.255.255"),
+        ("11000000.10101000.00000001.00000001", "192.168.1.1"),
+        ("00001010.00000000.00000000.00000101", "10.0.0.5"),
+    ],
+)
+def test_binary_to_ipv4(binary, expected):
+    assert binary_to_ipv4(binary) == expected
+
+
+@pytest.mark.parametrize("octet", range(256))
+def test_round_trip_each_octet(octet):
+    ipv4 = f"{octet}.0.127.255"
+    assert binary_to_ipv4(ipv4_to_binary(ipv4)) == ipv4

ipv4_conversions-0.1.0/tests/test_invalid.py

@@ -0,0 +1,34 @@
+import re
+
+import pytest
+
+from ipv4_conversions import binary_to_ipv4, ipv4_to_binary
+
+
+@pytest.mark.parametrize(
+    "invalid, expected_in_message",
+    [
+        ("", "empty"),
+        ("192.168.1", "four decimal octets"),
+        ("192.168.1.256", "outside the range 0-255"),
+        ("192.168.a.1", "not a decimal octet"),
+        ("192..1.1", "not a decimal octet"),
+    ],
+)
+def test_ipv4_to_binary_invalid_input(invalid, expected_in_message):
+    with pytest.raises(ValueError, match=re.escape(expected_in_message)):
+        ipv4_to_binary(invalid)
+
+
+@pytest.mark.parametrize(
+    "invalid, expected_in_message",
+    [
+        ("", "empty"),
+        ("11000000.10101000.00000001", "four 8-bit binary octets"),
+        ("1100000.10101000.00000001.00000001", "exactly 8 bits"),
+        ("11000000.10101000.0000000a.00000001", "invalid character"),
+    ],
+)
+def test_binary_to_ipv4_invalid_input(invalid, expected_in_message):
+    with pytest.raises(ValueError, match=re.escape(expected_in_message)):
+        binary_to_ipv4(invalid)