arx-net 0.1.0__tar.gz

arx_net-0.1.0/LICENSE

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

arx_net-0.1.0/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: arx-net
+Version: 0.1.0
+Summary: Graph parsing for arx net (https://dwarakesh-v.github.io/arx-net/) and graph representation conversion library.
+License: MIT
+Keywords: arx-net,graph,network,adjacency,graph-parser
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Arx-Net
+
+A lightweight Python library for parsing graph edge strings and converting
+between common graph representations.
+
+## Installation
+
+```bash
+pip install arx-net
+```
+
+## Features
+
+- Parse edge strings
+- Directed and undirected graphs
+- Weighted and unweighted graphs
+- Convert between
+
+  - adjacency lists
+  - edge lists
+  - adjacency matrices
+
+## Example
+
+```python
+import arx_net
+
+graph = arx_net.parse_edges(
+    "(A,B,4),(B,C,2),(C,D)"
+)
+
+print(graph)
+```
+
+Output
+
+```python
+{
+    "A": [("B",4)],
+    "B": [("C",2)],
+    "C": [("D",1)],
+    "D": []
+}
+```
+
+Convert formats
+
+```python
+edges = arx_net.convert_type(graph, "edge")
+matrix, order = arx_net.convert_type(graph, "matrix")
+```
+
+## Supported formats
+
+### Adjacency List
+
+```python
+{
+    "A": ["B", "C"]
+}
+```
+
+### Edge List
+
+```python
+[
+    ("A","B"),
+    ("A","C")
+]
+```
+
+### Matrix
+
+```python
+[
+ [0,1,1],
+ [0,0,1],
+ [0,0,0]
+]
+```
+
+## License
+
+MIT

arx_net-0.1.0/README.md

@@ -0,0 +1,84 @@
+# Arx-Net
+
+A lightweight Python library for parsing graph edge strings and converting
+between common graph representations.
+
+## Installation
+
+```bash
+pip install arx-net
+```
+
+## Features
+
+- Parse edge strings
+- Directed and undirected graphs
+- Weighted and unweighted graphs
+- Convert between
+
+  - adjacency lists
+  - edge lists
+  - adjacency matrices
+
+## Example
+
+```python
+import arx_net
+
+graph = arx_net.parse_edges(
+    "(A,B,4),(B,C,2),(C,D)"
+)
+
+print(graph)
+```
+
+Output
+
+```python
+{
+    "A": [("B",4)],
+    "B": [("C",2)],
+    "C": [("D",1)],
+    "D": []
+}
+```
+
+Convert formats
+
+```python
+edges = arx_net.convert_type(graph, "edge")
+matrix, order = arx_net.convert_type(graph, "matrix")
+```
+
+## Supported formats
+
+### Adjacency List
+
+```python
+{
+    "A": ["B", "C"]
+}
+```
+
+### Edge List
+
+```python
+[
+    ("A","B"),
+    ("A","C")
+]
+```
+
+### Matrix
+
+```python
+[
+ [0,1,1],
+ [0,0,1],
+ [0,0,0]
+]
+```
+
+## License
+
+MIT

arx_net-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=69"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "arx-net"
+version = "0.1.0"
+description = "Graph parsing for arx net (https://dwarakesh-v.github.io/arx-net/) and graph representation conversion library."
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+
+keywords = [
+    "arx-net",
+    "graph",
+    "network",
+    "adjacency",
+    "graph-parser"
+]
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]

arx_net-0.1.0/setup.cfg

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

arx_net-0.1.0/src/arx_net/__init__.py

@@ -0,0 +1,9 @@
+from .parser import parse_edges
+from .convert import convert_type
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "parse_edges",
+    "convert_type",
+]

arx_net-0.1.0/src/arx_net/convert.py

@@ -0,0 +1,197 @@
+from warnings import warn
+
+# Type conversion
+# Parse to canonical edges
+def _parse_adj(adj):
+    nodes = set(adj.keys())
+    edges = []
+    for src, neighbors in adj.items():
+        for nb in neighbors:
+            if isinstance(nb, (tuple, list)) and len(nb) == 2:
+                tgt, w = nb
+            else:
+                tgt, w = nb, None
+            nodes.add(tgt)
+            edges.append((src, tgt, w))
+    return edges, nodes
+
+def _parse_edge_list(edge_list):
+    nodes = set()
+    edges = []
+    for e in edge_list:
+        if isinstance(e, dict):
+            src = e.get('source', e.get('src'))
+            tgt = e.get('target', e.get('tgt'))
+            w   = e.get('weight', e.get('w'))
+        elif len(e) == 3:
+            src, tgt, w = e
+        elif len(e) == 2:
+            src, tgt, w = *e, None
+        else:
+            warn(f"Skipping malformed edge: {e}")
+            continue
+        if src is None or tgt is None:
+            warn(f"Skipping edge with missing src/tgt: {e}")
+            continue
+        nodes.update([src, tgt])
+        edges.append((src, tgt, w))
+    return edges, nodes
+
+def _parse_matrix(matrix):
+    edges = []
+    if isinstance(matrix, dict):
+        nodes = set(matrix.keys())
+        for src, row in matrix.items():
+            for tgt, val in row.items():
+                nodes.add(tgt)
+                if val != 0:
+                    edges.append((src, tgt, val))
+    else:
+        n = len(matrix)
+        nodes = set(range(n))
+        for i, row in enumerate(matrix):
+            for j, val in enumerate(row):
+                if val != 0:
+                    edges.append((i, j, val))
+    return edges, nodes
+
+def convert_type(input_graph, to, directed=None, weighted=None, from_type=None):
+    """
+    Convert between graph representations seamlessly.
+
+    Args:
+        input_graph : Input graph in any supported format -
+            Adjacency list  : { node: [neighbor, ...] } or { node: [(neighbor, weight), ...] }
+            Edge list       : [(src, tgt), ...] or [(src, tgt, weight), ...]
+                              or list of dicts with 'source'/'target'/'weight' keys (parse_edges output)
+            Matrix          : 2D list  (nodes = row/col indices)
+                              or dict-of-dicts { src: { tgt: weight } }
+        to          : Target format - 'adj', 'edge', or 'matrix'
+        directed    : bool. Auto-detected from input symmetry if None.
+        weighted    : bool. Auto-detected from input structure if None.
+        from_type   : Input format - 'adj', 'edge', or 'matrix'. Auto-detected if None.
+                      ('from' is a Python keyword, so from_type is used instead.)
+
+    Returns:
+        'adj'
+            {node: [neighbor, ...]} or
+            {node: [(neighbor, weight), ...]}
+
+        'edge'
+            [(src, tgt), ...] or
+            [(src, tgt, weight), ...]
+
+        'matrix'
+            (2D list, node_order)
+            node_order[i] gives the label for row/column i.
+
+    Notes:
+        - For binary (0/1) matrices, weighted is inferred as False since 1 = "edge exists".
+          If your graph genuinely has weight=1 on all edges, pass weighted=True explicitly.
+        - Directed detection is a heuristic: if every edge (u,v) has a reverse (v,u), 
+          the graph is assumed undirected. Pass directed=True/False to override.
+    """
+
+    FORMAT_ALIASES = {
+        'adj': 'adj', 'adjacency_list': 'adj', 'adjacency': 'adj',
+        'edge': 'edge', 'edge_list': 'edge', 'edges': 'edge',
+        'matrix': 'matrix', 'adjacency_matrix': 'matrix', 'mat': 'matrix',
+    }
+
+    to = FORMAT_ALIASES.get(to, to)
+    if to not in ('adj', 'edge', 'matrix'):
+        raise ValueError(f"Unknown target format '{to}'. Use 'adj', 'edge', or 'matrix'.")
+
+    if from_type is not None:
+        from_type = FORMAT_ALIASES.get(from_type, from_type)
+
+    # Auto-detect input format
+    def detect_format(g):
+        if isinstance(g, dict):
+            if not g:
+                return 'adj'
+            first_val = next(iter(g.values()))
+            return 'matrix' if isinstance(first_val, dict) else 'adj'
+        if isinstance(g, list):
+            if not g:
+                return 'edge'
+            return 'matrix' if isinstance(g[0], list) else 'edge'
+        raise ValueError("Cannot auto-detect format. Specify `from_type` explicitly.")
+
+    fmt = from_type if from_type is not None else detect_format(input_graph)
+    if fmt not in ('adj', 'edge', 'matrix'):
+        raise ValueError(f"Unknown input format '{fmt}'.")
+
+    parsers = {'adj': _parse_adj, 'edge': _parse_edge_list, 'matrix': _parse_matrix}
+    edges, nodes = parsers[fmt](input_graph)
+
+    # Auto-detect weighted
+    if weighted is None:
+        if fmt == 'matrix':
+            # Binary 0/1 matrix → unweighted; any other value → weighted
+            weighted = any(w not in (0, 1) for _, _, w in edges)
+        else:
+            weighted = any(w is not None for _, _, w in edges)
+
+    # Auto-detect directed
+    if directed is None:
+        if fmt == 'matrix' and isinstance(input_graph, list):
+            n = len(input_graph)
+            directed = any(
+                input_graph[i][j] != input_graph[j][i]
+                for i in range(n) for j in range(i, n)
+            )
+        else:
+            edge_set = {(s, t) for s, t, _ in edges}
+            directed = not all(
+                (t, s) in edge_set
+                for s, t, _ in edges if s != t
+            )
+
+    # Normalize
+    if weighted:
+        edges = [(s, t, w if w is not None else 1) for s, t, w in edges]
+    else:
+        edges = [(s, t, None) for s, t, _ in edges]
+
+    if not directed:
+        seen = set()
+        deduped = []
+        for s, t, w in edges:
+            key = frozenset([s, t])
+            if key not in seen:
+                seen.add(key)
+                deduped.append((s, t, w))
+        edges = deduped
+
+    # Build target format
+
+    def build_adj(edges, nodes, directed, weighted):
+        adj = {n: [] for n in nodes}
+        for s, t, w in edges:
+            adj.setdefault(s, []).append((t, w) if weighted else t)
+            if not directed:
+                adj.setdefault(t, []).append((s, w) if weighted else s)
+        return adj
+
+    def build_edge_list(edges, weighted):
+        return [(s, t, w) if weighted else (s, t) for s, t, w in edges]
+
+    def build_matrix(edges, nodes, directed, weighted):
+        node_order = sorted(nodes, key=str)
+        idx = {n: i for i, n in enumerate(node_order)}
+        size = len(node_order)
+        matrix = [[0] * size for _ in range(size)]
+        for s, t, w in edges:
+            val = w if weighted else 1
+            matrix[idx[s]][idx[t]] = val
+            if not directed:
+                matrix[idx[t]][idx[s]] = val
+        return matrix, node_order
+
+    builders = {
+        'adj':    lambda: build_adj(edges, nodes, directed, weighted),
+        'edge':   lambda: build_edge_list(edges, weighted),
+        'matrix': lambda: build_matrix(edges, nodes, directed, weighted),
+    }
+    return builders[to]()

arx_net-0.1.0/src/arx_net/parser.py

@@ -0,0 +1,100 @@
+import re
+
+# Parse Arx-Net style edges
+def _split_top_level(input_str):
+    result = []
+    depth = 0
+    current = ''
+    for char in input_str:
+        if char == '(':
+            depth += 1
+        if char == ')':
+            depth -= 1
+        if char == ',' and depth == 0:
+            result.append(current)
+            current = ''
+        else:
+            current += char
+    result.append(current)
+    return [s for s in result if s.strip() != '']
+
+def parse_edges(edges_input, directed=True, strict=False):
+    """
+    Parse the arx net application format into a python compatible adjacency list format.
+
+    Args:
+        edges_input : Arx-Tet type input edge format
+        directed : Directed or Undirected
+        strict : Continue or terminate for invalid cases
+
+    Returns:
+        Python compatible adjacency list of type dict.
+    """
+    simple_format = re.compile(r'^([a-zA-Z0-9]{2})(-?\d*\.?\d*)$')
+    paren_format = re.compile(r'^\(\s*([a-zA-Z0-9]+)\s*,\s*([a-zA-Z0-9]+)\s*(?:,\s*(-?\d*\.?\d*)\s*)?\)$')
+
+    edges_raw = []
+    for edge in _split_top_level(edges_input):
+        edge = edge.strip()
+
+        source = target = weight = None
+
+        if m := simple_format.match(edge):
+            source = m.group(1)[0]
+            target = m.group(1)[1]
+            w = m.group(2)
+            weight = float(w) if w else None
+        elif m := paren_format.match(edge):
+            source = m.group(1)
+            target = m.group(2)
+            w = m.group(3)
+            weight = float(w) if w else None
+        elif len(edge) == 1:
+            source = edge
+            target = None
+            weight = None
+        else:
+            if strict:
+                raise ValueError(f"Invalid edge format: {edge}")
+            continue
+
+        if weight is None or (isinstance(weight, float) and weight != weight):  # NaN check
+            weight = None  # keep as None rather than defaulting to 1, so we know if weights are absent
+
+        edges_raw.append({'source': source, 'target': target, 'weight': weight})
+
+    # Remove duplicates, keeping last occurrence
+    edge_map = {}
+    for edge in edges_raw:
+        if edge['source'] and edge['target']:
+            key = f"{edge['source']}_{edge['target']}"
+            edge_map[key] = edge
+            if not directed:
+                reverse_key = f"{edge['target']}_{edge['source']}"
+                if reverse_key in edge_map:
+                    del edge_map[reverse_key]
+
+    edges_raw = list(edge_map.values())
+
+    has_weights = any(e['weight'] is not None for e in edges_raw)
+
+    adj = {}
+    for edge in edges_raw:
+        src, tgt, w = edge['source'], edge['target'], edge['weight']
+        if src is None:
+            continue
+
+        for node in ([src, tgt] if tgt else [src]):
+            if node not in adj:
+                adj[node] = []
+
+        if tgt is not None:
+            neighbor = (tgt, w if w is not None else 1) if has_weights else tgt
+            adj[src].append(neighbor)
+
+            if not directed:
+                neighbor_rev = (src, w if w is not None else 1) if has_weights else src
+                adj[tgt].append(neighbor_rev)
+
+    return adj
+

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

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: arx-net
+Version: 0.1.0
+Summary: Graph parsing for arx net (https://dwarakesh-v.github.io/arx-net/) and graph representation conversion library.
+License: MIT
+Keywords: arx-net,graph,network,adjacency,graph-parser
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Arx-Net
+
+A lightweight Python library for parsing graph edge strings and converting
+between common graph representations.
+
+## Installation
+
+```bash
+pip install arx-net
+```
+
+## Features
+
+- Parse edge strings
+- Directed and undirected graphs
+- Weighted and unweighted graphs
+- Convert between
+
+  - adjacency lists
+  - edge lists
+  - adjacency matrices
+
+## Example
+
+```python
+import arx_net
+
+graph = arx_net.parse_edges(
+    "(A,B,4),(B,C,2),(C,D)"
+)
+
+print(graph)
+```
+
+Output
+
+```python
+{
+    "A": [("B",4)],
+    "B": [("C",2)],
+    "C": [("D",1)],
+    "D": []
+}
+```
+
+Convert formats
+
+```python
+edges = arx_net.convert_type(graph, "edge")
+matrix, order = arx_net.convert_type(graph, "matrix")
+```
+
+## Supported formats
+
+### Adjacency List
+
+```python
+{
+    "A": ["B", "C"]
+}
+```
+
+### Edge List
+
+```python
+[
+    ("A","B"),
+    ("A","C")
+]
+```
+
+### Matrix
+
+```python
+[
+ [0,1,1],
+ [0,0,1],
+ [0,0,0]
+]
+```
+
+## License
+
+MIT

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

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+src/arx_net/__init__.py
+src/arx_net/convert.py
+src/arx_net/parser.py
+src/arx_net.egg-info/PKG-INFO
+src/arx_net.egg-info/SOURCES.txt
+src/arx_net.egg-info/dependency_links.txt
+src/arx_net.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1 @@
+arx_net