netstate 0.1.0__tar.gz

netstate-0.1.0/License.md

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

netstate-0.1.0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: netstate
+Version: 0.1.0
+Summary: Windows network and system snapshot collector
+Author: Imon Mallik
+License: MIT
+Keywords: network,system-info,windows,ip,network-monitoring
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: License.md
+Requires-Dist: requests>=2.0
+Dynamic: license-file
+
+# NetState
+
+NetState is a Python package for collecting structured system and
+network information on Windows machines.
+
+It provides a clean API to retrieve:
+
+-   Operating system details
+-   Active private network adapter information
+-   Public IP and ISP information
+-   JSON-serializable network snapshots
+
+This package is intended to be used as a **library**, not a standalone
+application.
+
+------------------------------------------------------------------------
+
+## Installation
+
+After publishing to PyPI:
+
+``` bash
+pip install netstate
+```
+
+For local development:
+
+``` bash
+pip install -e .
+```
+
+------------------------------------------------------------------------
+
+## Basic Usage
+
+``` python
+from netstate.network_info import get_network_info
+
+snapshot = get_network_info()
+
+print(snapshot.system)
+print(snapshot.private_network)
+print(snapshot.public_network)
+```
+
+------------------------------------------------------------------------
+
+## JSON Output
+
+``` python
+from netstate.network_info import get_network_info_json
+
+json_output = get_network_info_json()
+print(json_output)
+```
+
+------------------------------------------------------------------------
+
+## Returned Data Structure
+
+`get_network_info()` returns a `NetStateSnapshot` dataclass containing:
+
+-   platform (str)
+-   system (SystemData)
+-   private_network (List\[NetworkData\] \| None)
+-   public_network (PublicNetworkData \| None)
+-   record_time (datetime)
+
+All models are defined using Python dataclasses.
+
+------------------------------------------------------------------------
+
+## Requirements
+
+-   Python 3.9+
+-   Windows OS
+-   requests
+
+------------------------------------------------------------------------
+
+## Design Goals
+
+-   Clean modular architecture
+-   Structured dataclass models
+-   Graceful failure handling
+-   Easy JSON serialization
+-   Extensible collector design
+
+------------------------------------------------------------------------
+
+## License
+
+MIT License
+
+------------------------------------------------------------------------
+
+## Author
+
+Imon Mallik

netstate-0.1.0/README.md

@@ -0,0 +1,99 @@
+# NetState
+
+NetState is a Python package for collecting structured system and
+network information on Windows machines.
+
+It provides a clean API to retrieve:
+
+-   Operating system details
+-   Active private network adapter information
+-   Public IP and ISP information
+-   JSON-serializable network snapshots
+
+This package is intended to be used as a **library**, not a standalone
+application.
+
+------------------------------------------------------------------------
+
+## Installation
+
+After publishing to PyPI:
+
+``` bash
+pip install netstate
+```
+
+For local development:
+
+``` bash
+pip install -e .
+```
+
+------------------------------------------------------------------------
+
+## Basic Usage
+
+``` python
+from netstate.network_info import get_network_info
+
+snapshot = get_network_info()
+
+print(snapshot.system)
+print(snapshot.private_network)
+print(snapshot.public_network)
+```
+
+------------------------------------------------------------------------
+
+## JSON Output
+
+``` python
+from netstate.network_info import get_network_info_json
+
+json_output = get_network_info_json()
+print(json_output)
+```
+
+------------------------------------------------------------------------
+
+## Returned Data Structure
+
+`get_network_info()` returns a `NetStateSnapshot` dataclass containing:
+
+-   platform (str)
+-   system (SystemData)
+-   private_network (List\[NetworkData\] \| None)
+-   public_network (PublicNetworkData \| None)
+-   record_time (datetime)
+
+All models are defined using Python dataclasses.
+
+------------------------------------------------------------------------
+
+## Requirements
+
+-   Python 3.9+
+-   Windows OS
+-   requests
+
+------------------------------------------------------------------------
+
+## Design Goals
+
+-   Clean modular architecture
+-   Structured dataclass models
+-   Graceful failure handling
+-   Easy JSON serialization
+-   Extensible collector design
+
+------------------------------------------------------------------------
+
+## License
+
+MIT License
+
+------------------------------------------------------------------------
+
+## Author
+
+Imon Mallik

netstate-0.1.0/netstate/__init__.py

@@ -0,0 +1,3 @@
+from .network_info import get_network_info, get_network_info_json
+
+__all__ = ["get_network_info","get_network_info_json"]

netstate-0.1.0/netstate/collectors/networkData.py

@@ -0,0 +1,140 @@
+import subprocess
+import re
+from datetime import datetime
+from dataclasses import dataclass
+from typing import Optional
+from netstate.exception import PrivateNetworkUnavailableError
+
+@dataclass(frozen=True)
+class NetworkData:
+    adapter_name: str
+    adapter_type: str
+
+    ipv4: Optional[str]
+    subnet_mask: Optional[str]
+    mac_address: Optional[str]
+
+    dhcp_enabled: Optional[bool]
+    dhcp_server: Optional[str]
+    dns_servers: Optional[str]
+    default_gateway: Optional[str]
+
+    lease_obtained: Optional[datetime]
+    lease_expires: Optional[datetime]
+
+    description: Optional[str]
+    record_time: datetime
+
+_FIELD_MAP = {
+    "type": "type",
+    "IPv4 Address": "IPv4",
+    "DHCP Enabled": "DHCP_Enable",
+    "DHCP Server": "DHCP_Server",
+    "DNS Servers": "DNS_Servers",
+    "Default Gateway": "Default_Gateway",
+    "Physical Address": "MAC_Address",
+    "Subnet Mask": "Subnet_Mask",
+    "Lease Expires": "Lease_Expires",
+    "Lease Obtained": "Lease_Obtained",
+    "Description": "Description",
+}
+
+def _clean_ipv4(ip: str) -> str:
+    if not ip:
+        return ""
+    return ip.replace("(Preferred)", "").strip()
+
+def _parse_windows_datetime(dt_str: str):
+    if not dt_str:
+        return None
+
+    return datetime.strptime(dt_str,"%A, %B %d, %Y %I:%M:%S %p")
+
+def to_isoformat(dt_str: str):
+    dt = _parse_windows_datetime(dt_str)
+    return dt.isoformat() if dt else None
+
+def _parse_ipconfig(output: str) -> dict:
+    adapters = {}
+    current_adapter = None
+
+    adapter_header = re.compile(r"^(Ethernet|Wireless LAN|Unknown) adapter (.+):$")
+    key_value = re.compile(r"^\s+(.+?)\s*:\s*(.*)$")
+
+    for line in output.splitlines():
+        line = line.rstrip()
+
+        header_match = adapter_header.match(line)
+        if header_match:
+            adapter_type, adapter_name = header_match.groups()
+
+            current_adapter = adapter_name.strip()
+
+            adapters[current_adapter] = {
+                "type": adapter_type,
+                'Media State': True,
+            }
+            continue
+
+        if current_adapter:
+            kv_match = key_value.match(line)
+
+            if kv_match:
+                key, value = kv_match.groups()
+                key = key[0:key.index('.')].strip()
+                
+                value = value.strip()
+
+                if value.lower() in ("yes", "no"):
+                    value = value.lower() == "yes"
+
+                if(key == "Media State" and value =='Media disconnected' ):
+                    value=False
+
+                adapters[current_adapter][key] = value
+
+    return adapters
+
+def _filter_active_networks(data : dict) -> dict:
+    filtered_networks={}
+
+    for key,value in data.items():
+        if value["Media State"]==True and len(value['Default Gateway'])!=0:
+            filtered_networks[key]=value
+    
+    return filtered_networks
+
+def get_network_data() -> list[NetworkData]:
+    try:
+        output = subprocess.check_output(["ipconfig", "/all"], text=True)
+
+        parsed = _parse_ipconfig(output)
+        filtered = _filter_active_networks(parsed)
+
+        if not filtered:
+            raise RuntimeError("No active network adapter found")
+
+        results = []
+
+        for adapter_name, filtered_data in filtered.items():
+            results.append(
+                NetworkData(
+                    adapter_name=adapter_name,
+                    adapter_type=filtered_data.get("type"),
+                    ipv4=_clean_ipv4(filtered_data.get("IPv4 Address")),
+                    subnet_mask=filtered_data.get("Subnet Mask"),
+                    mac_address=filtered_data.get("Physical Address"),
+                    dhcp_enabled=filtered_data.get("DHCP Enabled"),
+                    dhcp_server=filtered_data.get("DHCP Server"),
+                    dns_servers=filtered_data.get("DNS Servers"),
+                    default_gateway=filtered_data.get("Default Gateway"),
+                    lease_obtained=_parse_windows_datetime(filtered_data.get("Lease Obtained")),
+                    lease_expires=_parse_windows_datetime(filtered_data.get("Lease Expires")),
+                    description=filtered_data.get("Description"),
+                    record_time=datetime.now().astimezone()
+                )
+            )
+        return results
+
+    except Exception:
+        raise PrivateNetworkUnavailableError("Private network not available")

netstate-0.1.0/netstate/collectors/publicIpData.py

@@ -0,0 +1,58 @@
+from dataclasses import dataclass
+from typing import Optional
+from datetime import datetime
+import requests
+from datetime import datetime
+from netstate.exception import NetStateError, PublicNetworkUnavailableError
+@dataclass(frozen=True)
+class PublicNetworkData:
+    public_ip: str
+    isp: Optional[str]
+
+    country: Optional[str]
+    region: Optional[str]
+    city: Optional[str]
+    pincode: Optional[str]
+
+    latitude: Optional[float]
+    longitude: Optional[float]
+
+    record_time: datetime
+
+
+IFCONFIG_URL = "https://ifconfig.me/all.json"
+IP_API_URL = "http://ip-api.com/json/"
+
+def get_public_network_data() -> PublicNetworkData:
+    try:
+        r1 = requests.get(IFCONFIG_URL, timeout=5)
+        r1.raise_for_status()
+        ip_data = r1.json()
+        public_ip = ip_data.get("ip_addr")
+    except Exception as e:
+        print("unable to fetch public network ip")
+        raise PublicNetworkUnavailableError("public network not available")
+
+    try:
+        r2 = requests.get(IP_API_URL + public_ip, timeout=5)
+        r2.raise_for_status()
+        geo = r2.json()
+    except Exception as e:
+        print("Unable to fetch public network ip data")
+        raise PublicNetworkUnavailableError("Unable to fetch public network ip data")
+
+    return PublicNetworkData(
+        public_ip=public_ip,
+        isp=geo.get("isp"),
+
+        country=geo.get("country"),
+        region=geo.get("regionName"),
+        city=geo.get("city"),
+        pincode=geo.get("zip"),
+
+        latitude=geo.get("lat"),
+        longitude=geo.get("lon"),
+
+        record_time=datetime.now().astimezone()
+    )
+

netstate-0.1.0/netstate/collectors/systemData.py

@@ -0,0 +1,31 @@
+import platform
+import socket
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from netstate.exception import SystemDetailsUnavailableError
+
+@dataclass(frozen=True)
+class SystemData:
+    os_name: str
+    os_release_name: str
+    os_version_no: str
+    os_full_detail: str
+    host_name: str
+    record_time: datetime
+
+
+def get_system_data() -> SystemData:
+    """
+    Collect system-level metadata and return it as an immutable snapshot.
+    """
+    try:
+        return SystemData(
+            os_name=platform.system(),
+            os_release_name=platform.release(),
+            os_version_no=platform.version(),
+            os_full_detail=platform.platform(),
+            host_name=socket.gethostname(),
+            record_time=datetime.now().astimezone()
+        )
+    except Exception:
+        raise SystemDetailsUnavailableError("System details cannot be fetched")

netstate-0.1.0/netstate/exception.py

@@ -0,0 +1,40 @@
+class NetStateError(Exception):
+    """
+    Base exception for netstate package.
+    """
+    def __init__(self, message):
+        super().__init__(message)
+        self.message = message
+    
+    def __str__(self):
+        return f"NetStateError : {self.message}"
+
+class SystemDetailsUnavailableError(NetStateError):
+    """
+    Raised when System information cannot be retrieved.
+    """
+    def __init__(self, message):
+        super().__init__(message)
+    
+    def __str__(self):
+        return f"SystemDetailsUnavailableError : {self.message}"
+    
+class PrivateNetworkUnavailableError(NetStateError):
+    """
+    Raised when private network information cannot be retrieved.
+    """
+    def __init__(self, message):
+        super().__init__(message)
+    
+    def __str__(self):
+        return f"PrivateNetworkUnavailableError : {self.message}"
+    
+class PublicNetworkUnavailableError(NetStateError):
+    """
+    Raised when public network information cannot be retrieved.
+    """
+    def __init__(self, message):
+        super().__init__(message)
+    
+    def __str__(self):
+        return f"PublicNetworkUnavailableError : {self.message}"

netstate-0.1.0/netstate/models.py

@@ -0,0 +1,19 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+
+from netstate.collectors.systemData import SystemData
+from netstate.collectors.networkData import NetworkData
+from netstate.collectors.publicIpData import PublicNetworkData
+
+
+@dataclass(frozen=True)
+class NetStateSnapshot:
+    """
+    Final aggregated snapshot returned to the user.
+    """
+    platform: str
+    system: SystemData
+    private_network: NetworkData
+    public_network: Optional[PublicNetworkData]
+    record_time: datetime

netstate-0.1.0/netstate/network_info.py

@@ -0,0 +1,48 @@
+import platform
+from datetime import datetime
+import json
+from dataclasses import asdict
+
+from netstate.models import NetStateSnapshot
+from netstate.collectors.systemData import get_system_data
+from netstate.collectors.networkData import get_network_data
+from netstate.collectors.publicIpData import get_public_network_data
+from netstate.exception import PublicNetworkUnavailableError, NetStateError, PrivateNetworkUnavailableError
+
+
+def get_network_info() -> NetStateSnapshot:
+    """
+    Return current system and network information (Windows only).
+    """
+    if platform.system().lower() != "windows":
+        raise NotImplementedError("netstate currently supports Windows only")
+    
+    system_data = get_system_data()
+    try:
+        private_network_data = get_network_data()
+    except PrivateNetworkUnavailableError as e:
+        private_network_data=None
+    except RuntimeError:
+        private_network_data=None
+    try:
+        public_network_data = get_public_network_data()
+    except PublicNetworkUnavailableError as e:
+        public_network_data=None
+    record_time_data = datetime.now().astimezone()
+    return NetStateSnapshot(
+        platform="windows",
+        system=system_data,
+        private_network=private_network_data,
+        public_network=public_network_data,
+        record_time=record_time_data
+    )
+
+if __name__ == "__main__":
+    try:
+        print(get_network_info())
+    except:
+        print("some error occured")
+
+def get_network_info_json():
+    snapshot = get_network_info()
+    return json.dumps(asdict(snapshot), indent=4, default=str)

netstate-0.1.0/netstate.egg-info/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: netstate
+Version: 0.1.0
+Summary: Windows network and system snapshot collector
+Author: Imon Mallik
+License: MIT
+Keywords: network,system-info,windows,ip,network-monitoring
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: License.md
+Requires-Dist: requests>=2.0
+Dynamic: license-file
+
+# NetState
+
+NetState is a Python package for collecting structured system and
+network information on Windows machines.
+
+It provides a clean API to retrieve:
+
+-   Operating system details
+-   Active private network adapter information
+-   Public IP and ISP information
+-   JSON-serializable network snapshots
+
+This package is intended to be used as a **library**, not a standalone
+application.
+
+------------------------------------------------------------------------
+
+## Installation
+
+After publishing to PyPI:
+
+``` bash
+pip install netstate
+```
+
+For local development:
+
+``` bash
+pip install -e .
+```
+
+------------------------------------------------------------------------
+
+## Basic Usage
+
+``` python
+from netstate.network_info import get_network_info
+
+snapshot = get_network_info()
+
+print(snapshot.system)
+print(snapshot.private_network)
+print(snapshot.public_network)
+```
+
+------------------------------------------------------------------------
+
+## JSON Output
+
+``` python
+from netstate.network_info import get_network_info_json
+
+json_output = get_network_info_json()
+print(json_output)
+```
+
+------------------------------------------------------------------------
+
+## Returned Data Structure
+
+`get_network_info()` returns a `NetStateSnapshot` dataclass containing:
+
+-   platform (str)
+-   system (SystemData)
+-   private_network (List\[NetworkData\] \| None)
+-   public_network (PublicNetworkData \| None)
+-   record_time (datetime)
+
+All models are defined using Python dataclasses.
+
+------------------------------------------------------------------------
+
+## Requirements
+
+-   Python 3.9+
+-   Windows OS
+-   requests
+
+------------------------------------------------------------------------
+
+## Design Goals
+
+-   Clean modular architecture
+-   Structured dataclass models
+-   Graceful failure handling
+-   Easy JSON serialization
+-   Extensible collector design
+
+------------------------------------------------------------------------
+
+## License
+
+MIT License
+
+------------------------------------------------------------------------
+
+## Author
+
+Imon Mallik

netstate-0.1.0/netstate.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+License.md
+README.md
+pyproject.toml
+netstate/__init__.py
+netstate/exception.py
+netstate/models.py
+netstate/network_info.py
+netstate.egg-info/PKG-INFO
+netstate.egg-info/SOURCES.txt
+netstate.egg-info/dependency_links.txt
+netstate.egg-info/requires.txt
+netstate.egg-info/top_level.txt
+netstate/collectors/networkData.py
+netstate/collectors/publicIpData.py
+netstate/collectors/systemData.py
+tests/test_netstate.py

netstate-0.1.0/netstate.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

netstate-0.1.0/netstate.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.0

netstate-0.1.0/netstate.egg-info/top_level.txt

@@ -0,0 +1 @@
+netstate

netstate-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "netstate"
+version = "0.1.0"
+description = "Windows network and system snapshot collector"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+
+authors = [
+    { name = "Imon Mallik" }
+]
+
+dependencies = [
+    "requests>=2.0"
+]
+
+keywords = [
+    "network",
+    "system-info",
+    "windows",
+    "ip",
+    "network-monitoring"
+]
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Operating System :: Microsoft :: Windows",
+    "License :: OSI Approved :: MIT License",
+    "Intended Audience :: Developers",
+    "Topic :: System :: Networking",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["netstate*"]
+exclude = ["tests*"]

netstate-0.1.0/setup.cfg

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

netstate-0.1.0/tests/test_netstate.py

@@ -0,0 +1,24 @@
+from netstate import get_network_info 
+from netstate import get_network_info_json 
+from pprint import pprint
+
+def main():
+    snapshot = get_network_info()
+
+    print("===== SYSTEM =====")
+    pprint(snapshot.system)
+
+    print("\n===== PRIVATE NETWORK =====")
+    pprint(snapshot.private_network)
+
+    print("\n===== PUBLIC NETWORK =====")
+    pprint(snapshot.public_network)
+
+    print("\n===== RECORD TIME =====")
+    pprint(snapshot.record_time)
+
+    json_output = get_network_info_json()
+    print(json_output)
+
+if __name__ == "__main__":
+    main()