netforge-network-toolkit 0.1.0__tar.gz

netforge_network_toolkit-0.1.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: netforge-network-toolkit
+Version: 0.1.0
+Summary: A Python network and system toolkit
+Author: NetForge Contributors
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: psutil>=5.9
+Requires-Dist: certifi>=2024.2.2
+
+# NetForge
+
+Python Network & System Toolkit.
+
+## Features
+
+- System information
+- Network interfaces
+- TCP and UDP sockets
+- HTTP requests
+- Port diagnostics
+- Server creation
+- Network diagnostics
+
+## Installation
+
+pip install netforge

netforge_network_toolkit-0.1.0/README.md

@@ -0,0 +1,17 @@
+# NetForge
+
+Python Network & System Toolkit.
+
+## Features
+
+- System information
+- Network interfaces
+- TCP and UDP sockets
+- HTTP requests
+- Port diagnostics
+- Server creation
+- Network diagnostics
+
+## Installation
+
+pip install netforge

netforge_network_toolkit-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "netforge-network-toolkit"
+readme = { file = "README.md", content-type = "text/markdown" }
+version = "0.1.0"
+description = "A Python network and system toolkit"
+requires-python = ">=3.10"
+dependencies = [
+    "psutil>=5.9",
+    "certifi>=2024.2.2",
+]
+license = "MIT"
+authors = [
+    {name = "NetForge Contributors"}
+]
+
+[tool.setuptools.packages.find]
+where = ["src/"]

netforge_network_toolkit-0.1.0/setup.cfg

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

netforge_network_toolkit-0.1.0/src/netforge/__init__.py

@@ -0,0 +1,19 @@
+from . import system
+from . import network
+from . import sockets
+from . import http
+from . import ports
+from . import servers
+from . import diagnostics
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "system",
+    "network",
+    "sockets",
+    "http",
+    "ports",
+    "servers",
+    "diagnostics",
+]

netforge_network_toolkit-0.1.0/src/netforge/diagnostics.py

@@ -0,0 +1,180 @@
+
+"""
+NetForge - Network Diagnostics
+
+DNS resolution, TCP connectivity checks and port diagnostics.
+"""
+
+import socket
+import time
+
+from dataclasses import dataclass
+
+from . import ports
+
+
+@dataclass(frozen=True)
+class DNSInfo:
+    hostname: str
+    ipv4: tuple[str, ...]
+    ipv6: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class ConnectivityResult:
+    host: str
+    port: int
+    reachable: bool
+    latency_ms: float | None = None
+    error: str | None = None
+
+
+@dataclass(frozen=True)
+class DiagnosticReport:
+    host: str
+    dns: DNSInfo | None
+    connectivity: ConnectivityResult
+    ports: tuple[ports.PortResult, ...]
+
+    @property
+    def reachable(self) -> bool:
+        return self.connectivity.reachable
+
+
+def resolve(host: str) -> DNSInfo:
+    """
+    Resolve a hostname into IPv4 and IPv6 addresses.
+    """
+
+    if not isinstance(host, str) or not host.strip():
+        raise ValueError("Host must be a non-empty string")
+
+    try:
+        records = socket.getaddrinfo(
+            host,
+            None,
+            family=socket.AF_UNSPEC,
+            type=socket.SOCK_STREAM,
+        )
+    except socket.gaierror as error:
+        raise OSError(f"DNS resolution failed for {host}: {error}") from error
+
+    ipv4 = set()
+    ipv6 = set()
+
+    for family, _, _, _, address in records:
+        if family == socket.AF_INET:
+            ipv4.add(address[0])
+        elif family == socket.AF_INET6:
+            ipv6.add(address[0])
+
+    return DNSInfo(
+        hostname=host,
+        ipv4=tuple(sorted(ipv4)),
+        ipv6=tuple(sorted(ipv6)),
+    )
+
+
+def check_connectivity(
+    host: str,
+    port: int = 443,
+    timeout: float = 3.0,
+) -> ConnectivityResult:
+    """
+    Test TCP connectivity to a host and port.
+
+    This is a TCP connection test, not an ICMP ping.
+    """
+
+    if not isinstance(host, str) or not host.strip():
+        raise ValueError("Host must be a non-empty string")
+
+    if (
+        isinstance(port, bool)
+        or not isinstance(port, int)
+        or not 1 <= port <= 65535
+    ):
+        raise ValueError("Port must be between 1 and 65535")
+
+    if timeout <= 0:
+        raise ValueError("Timeout must be greater than zero")
+
+    start = time.perf_counter()
+
+    try:
+        with socket.create_connection(
+            (host, port),
+            timeout=timeout,
+        ):
+            latency = (time.perf_counter() - start) * 1000
+
+            return ConnectivityResult(
+                host=host,
+                port=port,
+                reachable=True,
+                latency_ms=round(latency, 2),
+            )
+
+    except OSError as error:
+        return ConnectivityResult(
+            host=host,
+            port=port,
+            reachable=False,
+            error=str(error),
+        )
+
+
+def inspect(
+    host: str,
+    scan_ports: tuple[int, ...] | list[int] = (80, 443),
+    connectivity_port: int = 443,
+    timeout: float = 3.0,
+    max_workers: int = 10,
+) -> DiagnosticReport:
+    """
+    Generate a network diagnostic report for a host.
+
+    Args:
+        host: Hostname or IP address.
+        scan_ports: TCP ports to inspect.
+        connectivity_port: Port used for the connectivity test.
+        timeout: Timeout for each network operation.
+        max_workers: Maximum concurrent port checks.
+
+    Returns:
+        A DiagnosticReport containing DNS, connectivity and port results.
+    """
+
+    if not isinstance(host, str) or not host.strip():
+        raise ValueError("Host must be a non-empty string")
+
+    if timeout <= 0:
+        raise ValueError("Timeout must be greater than zero")
+
+    dns_info = None
+
+    try:
+        dns_info = resolve(host)
+    except OSError:
+        # Connectivity and port checks may still work with an IP address.
+        pass
+
+    connectivity = check_connectivity(
+        host,
+        port=connectivity_port,
+        timeout=timeout,
+    )
+
+    port_results = ports.scan_ports(
+        host,
+        scan_ports,
+        timeout=timeout,
+        max_workers=max_workers,
+    )
+
+    return DiagnosticReport(
+        host=host,
+        dns=dns_info,
+        connectivity=connectivity,
+        ports=tuple(port_results),
+    )

netforge_network_toolkit-0.1.0/src/netforge/http.py

@@ -0,0 +1,237 @@
+
+import json as json_module
+
+import urllib.request
+import urllib.error
+
+from urllib.parse import urlencode, urlsplit, urlunsplit
+from dataclasses import dataclass
+from typing import Optional, Any
+import ssl
+import warnings
+import certifi
+
+class HTTPError(Exception):
+    """Raised when an HTTP response has an unsuccessful status."""
+
+    def __init__(self, status_code: int, url: str, body: str = ""):
+        self.status_code = status_code
+        self.url = url
+        self.body = body
+
+        super().__init__(
+            f"HTTP {status_code} returned by {url}"
+        )
+
+
+class NetworkError(Exception):
+    """Raised when an HTTP request cannot reach its destination."""
+
+
+@dataclass
+class HTTPResponse:
+    """Represents an HTTP response."""
+
+    status_code: int
+    url: str
+    headers: dict[str, str]
+    content: bytes
+
+    @property
+    def ok(self) -> bool:
+        return 200 <= self.status_code < 400
+
+    @property
+    def text(self) -> str:
+        content_type = self.headers.get("Content-Type", "")
+
+        charset = "utf-8"
+
+        for part in content_type.split(";")[1:]:
+            key, separator, value = part.strip().partition("=")
+
+            if separator and key.lower() == "charset":
+                charset = value.strip("\"'")
+                break
+
+        try:
+            return self.content.decode(charset)
+        except LookupError:
+            return self.content.decode("utf-8", errors="replace")
+
+    def json(self) -> Any:
+        """Decode the response as JSON."""
+        return json_module.loads(self.text)
+
+    def raise_for_status(self):
+        """Raise HTTPError if the status is unsuccessful."""
+
+        if not self.ok:
+            raise HTTPError(
+                self.status_code,
+                self.url,
+                self.text
+            )
+
+
+def _append_params(url: str, params: Optional[dict]) -> str:
+    """Append query parameters to an URL."""
+
+    if not params:
+        return url
+
+    parts = urlsplit(url)
+    query = urlencode(params, doseq=True)
+
+    if parts.query:
+        query = parts.query + "&" + query
+
+    return urlunsplit((
+        parts.scheme,
+        parts.netloc,
+        parts.path,
+        query,
+        parts.fragment
+    ))
+
+
+def request(
+    method: str,
+    url: str,
+    params: Optional[dict] = None,
+    headers: Optional[dict] = None,
+    data: Optional[Any] = None,
+    json: Optional[Any] = None,
+    timeout: float = 10.0,
+    verify=True,
+    ca_certs=None
+) -> HTTPResponse:
+    """
+    Perform an HTTP request.
+
+    Supported methods:
+    GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS.
+    """
+
+    if not isinstance(method, str):
+        raise TypeError("Method must be a string")
+
+    method = method.upper()
+
+    allowed_methods = {
+        "GET", "POST", "PUT", "PATCH",
+        "DELETE", "HEAD", "OPTIONS"
+    }
+
+    if method not in allowed_methods:
+        raise ValueError(f"Unsupported HTTP method: {method}")
+
+    if not isinstance(url, str):
+        raise TypeError("URL must be a string")
+
+    if not url.startswith(("http://", "https://")):
+        raise ValueError("URL must use HTTP or HTTPS")
+
+    if timeout <= 0:
+        raise ValueError("Timeout must be positive")
+
+    if data is not None and json is not None:
+        raise ValueError("Use either data or json, not both")
+
+    final_url = _append_params(url, params)
+
+    request_headers = dict(headers or {})
+    body = None
+
+    if json is not None:
+        body = json_module.dumps(json).encode("utf-8")
+
+        if not any(
+            key.lower() == "content-type"
+            for key in request_headers
+        ):
+            request_headers["Content-Type"] = "application/json"
+
+    elif data is not None:
+        if isinstance(data, str):
+            body = data.encode("utf-8")
+        elif isinstance(data, bytes):
+            body = data
+        else:
+            raise TypeError("data must be str or bytes")
+
+    req = urllib.request.Request(
+        final_url,
+        data=body,
+        headers=request_headers,
+        method=method
+    )
+
+    try:
+        if verify:
+            # Utilise certifi par défaut ou le certificat CA fourni.
+            context = ssl.create_default_context(
+            cafile=ca_certs or certifi.where()
+        )
+        else:
+            warnings.warn(
+                "SSL certificate verification is disabled. "
+                "This connection is insecure.",
+                RuntimeWarning,
+                stacklevel=2,
+            )
+        context = ssl._create_unverified_context()
+        with urllib.request.urlopen(
+            req,
+            timeout=timeout,
+            context=context
+        ) as response:
+
+            return HTTPResponse(
+                status_code=response.status,
+                url=response.geturl(),
+                headers=dict(response.headers.items()),
+                content=response.read()
+            )
+
+    except urllib.error.HTTPError as error:
+        # HTTP errors such as 404 and 500 are still valid responses.
+        return HTTPResponse(
+            status_code=error.code,
+            url=error.geturl(),
+            headers=dict(error.headers.items()),
+            content=error.read()
+        )
+
+    except urllib.error.URLError as error:
+        raise NetworkError(
+            f"Unable to reach {url}: {error.reason}"
+        ) from error
+
+
+def get(url: str, **kwargs) -> HTTPResponse:
+    return request("GET", url, **kwargs)
+
+
+def post(url: str, **kwargs) -> HTTPResponse:
+    return request("POST", url, **kwargs)
+
+
+def put(url: str, **kwargs) -> HTTPResponse:
+    return request("PUT", url, **kwargs)
+
+
+def patch(url: str, **kwargs) -> HTTPResponse:
+    return request("PATCH", url, **kwargs)
+
+
+def delete(url: str, **kwargs) -> HTTPResponse:
+    return request("DELETE", url, **kwargs)
+
+
+def head(url: str, **kwargs) -> HTTPResponse:
+    return request("HEAD", url, **kwargs)
+
+
+def options(url: str, **kwargs) -> HTTPResponse:
+    return request("OPTIONS", url, **kwargs)

netforge_network_toolkit-0.1.0/src/netforge/network.py

@@ -0,0 +1,100 @@
+import socket
+
+from dataclasses import dataclass
+from typing import Optional
+
+import psutil
+
+
+@dataclass
+class NetworkInterface:
+    name: str
+    ipv4: tuple[str, ...]
+    ipv6: tuple[str, ...]
+    mac: Optional[str]
+    is_up: bool
+
+
+@dataclass
+class DNSResult:
+    hostname: str
+    ipv4: tuple[str, ...]
+    ipv6: tuple[str, ...]
+
+
+def interfaces() -> list[NetworkInterface]:
+    """Return all available network interfaces."""
+
+    addresses = psutil.net_if_addrs()
+    stats = psutil.net_if_stats()
+
+    results = []
+
+    for name, entries in addresses.items():
+        ipv4 = []
+        ipv6 = []
+        mac = None
+
+        for entry in entries:
+            if entry.family == socket.AF_INET:
+                ipv4.append(entry.address)
+
+            elif entry.family == socket.AF_INET6:
+                address = entry.address.split("%")[0]
+                ipv6.append(address)
+
+            elif entry.family == getattr(psutil, "AF_LINK", object()):
+                mac = entry.address
+
+        interface_stats = stats.get(name)
+
+        results.append(
+            NetworkInterface(
+                name=name,
+                ipv4=tuple(dict.fromkeys(ipv4)),
+                ipv6=tuple(dict.fromkeys(ipv6)),
+                mac=mac,
+                is_up=interface_stats.isup if interface_stats else False
+            )
+        )
+
+    return results
+
+
+def resolve(host: str) -> DNSResult:
+    """Resolve a hostname into IPv4 and IPv6 addresses."""
+
+    if not isinstance(host, str) or not host.strip():
+        raise ValueError("Host must be a non-empty string")
+
+    addresses = socket.getaddrinfo(
+        host,
+        None,
+        socket.AF_UNSPEC,
+        socket.SOCK_STREAM
+    )
+
+    ipv4 = set()
+    ipv6 = set()
+
+    for result in addresses:
+        family = result[0]
+        address = result[4][0].split("%")[0]
+
+        if family == socket.AF_INET:
+            ipv4.add(address)
+
+        elif family == socket.AF_INET6:
+            ipv6.add(address)
+
+    return DNSResult(
+        hostname=host,
+        ipv4=tuple(sorted(ipv4)),
+        ipv6=tuple(sorted(ipv6))
+    )
+
+
+def hostname() -> str:
+    """Return the local machine hostname."""
+
+    return socket.gethostname()