Addressed Krastanov's feedback

Author: AJ0070

CondaPkg.toml

@@ -0,0 +1,2 @@
+[deps]
+networkx = ""

Project.toml

@@ -4,10 +4,12 @@ version = "0.1.0"
 authors = ["Jash <jashambaliya1@gmail.com>"]
 
 [deps]
+CondaPkg = "992eb4ea-22a4-4c89-a5bb-47a3300528ab"
 Graphs = "86223c79-3864-5bf0-83f7-82e725a168b6"
 PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d"
 
 [compat]
+CondaPkg = "0.2"
 Graphs = "1"
 PythonCall = "0.9"
 julia = "1.10"

README.md

@@ -3,10 +3,13 @@
 `NetworkX.jl` is a Julia wrapper around Python's `networkx` built on `PythonCall.jl`.
 The current milestone is intentionally narrow: constructors plus the basic `Graphs.jl` API needed to pass `GraphsInterfaceChecker`.
 
+`networkx` is declared as a package dependency and is automatically installed via `CondaPkg.jl` — no manual Python setup required.
+
 ## Features
 
-- Wrap `networkx.Graph`/`networkx.DiGraph` as `Graphs.AbstractGraph`
-- Convert between `Graphs.jl` graph types and Python `networkx` objects
+- Wrap `networkx.Graph`/`networkx.DiGraph` as `Graphs.AbstractGraph` using the `NetworkXGraph` / `NetworkXDiGraph` constructors
+- Convert between `Graphs.jl` graph types and Python `networkx` objects via `networkx_graph`
+- Access the raw Python `networkx` module through `NetworkX.PythonNetworkX`
 - Validate interface conformance with `GraphsInterfaceChecker.jl`
 - Stress-test multi-threaded use of independent graphs to catch Python/GIL integration regressions
 
@@ -16,18 +19,25 @@ The current milestone is intentionally narrow: constructors plus the basic `Grap
 using Graphs
 using NetworkX
 
-g = path_graph(5)
+# Access the raw Python networkx module
+nx = NetworkX.PythonNetworkX.networkx
 
-# Convert Graphs.jl -> Python networkx
-pyg = networkx_graph(g)
+# Create a Python networkx graph and wrap it as a Graphs.jl-compatible graph
+pyg = nx.path_graph(5)
+gw = NetworkXGraph(pyg)         # undirected
+nv(gw) == 5                     # true
 
-# Wrap networkx -> Graphs.jl compatible graph
-gw = wrap_networkx(pyg)
+pydg = nx.DiGraph()
+pydg.add_edges_from([(1, 2), (2, 3)])
+dgw = NetworkXDiGraph(pydg)     # directed
 
-nv(gw) == nv(g)
+# Convert a Graphs.jl graph to a Python networkx object
+g = path_graph(5)
+pyg2 = networkx_graph(g)
+gw2 = NetworkXGraph(pyg2)
+nv(gw2) == nv(g)                # true
 ```
 
 ## Notes
 
-- Python package `networkx` must be available in the Python environment used by `PythonCall.jl`.
 - No graph algorithms are implemented in this package at this stage.

src/NetworkX.jl

@@ -1,15 +1,39 @@
 module NetworkX
 
 using Graphs
-using PythonCall: Py, pybuiltins, pyconvert, pyimport
+using PythonCall: Py, pynew, pycopy!, pybuiltins, pyconvert, pyimport
 
 export AbstractNetworkXGraph,
 	NetworkXGraph,
 	NetworkXDiGraph,
 	networkx_graph,
-	wrap_networkx,
 	refresh_index!
 
+"""
+	NetworkX.PythonNetworkX
+
+Sub-module providing direct access to the Python `networkx` package.
+Use this namespace when you need raw Python networkx objects or algorithms
+that are not yet wrapped by the Julia API.
+
+# Example
+```julia
+using NetworkX
+nx = NetworkX.PythonNetworkX.networkx
+pyg = nx.complete_graph(5)
+```
+"""
+module PythonNetworkX
+using PythonCall: pynew, pycopy!, pyimport
+
+"""The raw Python `networkx` module."""
+const networkx = pynew()
+
+function __init__()
+    pycopy!(networkx, pyimport("networkx"))
+end
+end # module PythonNetworkX
+
 """
 	AbstractNetworkXGraph{T} <: Graphs.AbstractGraph{T}
 
@@ -19,8 +43,17 @@ abstract type AbstractNetworkXGraph{T<:Integer} <: Graphs.AbstractGraph{T} end
 
 """
 	NetworkXGraph{T}(pygraph)
+	NetworkXGraph(pygraph)
 
-Wrapper for an undirected NetworkX graph.
+Wrap an undirected Python `networkx.Graph` as a `Graphs.AbstractGraph`.
+
+# Example
+```julia
+using NetworkX
+nx = NetworkX.PythonNetworkX.networkx
+pyg = nx.path_graph(5)
+gw = NetworkXGraph(pyg)
+```
 """
 mutable struct NetworkXGraph{T<:Integer} <: AbstractNetworkXGraph{T}
 	pygraph::Py
@@ -30,23 +63,25 @@ end
 
 """
 	NetworkXDiGraph{T}(pygraph)
-
-Wrapper for a directed NetworkX graph.
+	NetworkXDiGraph(pygraph)
+
+Wrap a directed Python `networkx.DiGraph` as a `Graphs.AbstractGraph`.
+
+# Example
+```julia
+using NetworkX
+nx = NetworkX.PythonNetworkX.networkx
+pyg = nx.DiGraph()
+pyg.add_edges_from([(1, 2), (2, 3)])
+gw = NetworkXDiGraph(pyg)
+```
 """
 mutable struct NetworkXDiGraph{T<:Integer} <: AbstractNetworkXGraph{T}
 	pygraph::Py
 	nodes::Vector{Any}
 	node_to_index::Dict{Any,T}
 end
 
-const _NX = Ref{Py}()
-
-_nx() = isassigned(_NX) ? _NX[] : (_NX[] = pyimport("networkx"))
-_pylist(x) = pybuiltins.list(x)
-_nodes(pygraph::Py) = pyconvert(Vector{Any}, _pylist(pygraph.nodes()))
-_edges(pygraph::Py) = pyconvert(Vector{Tuple{Any,Any}}, _pylist(pygraph.edges()))
-_neighbors(pyiter) = pyconvert(Vector{Any}, _pylist(pyiter))
-
 function _node_to_index(nodes::Vector{Any}, ::Type{T}) where {T<:Integer}
 	mapping = Dict{Any,T}()
 	for (i, node) in enumerate(nodes)
@@ -56,9 +91,8 @@ function _node_to_index(nodes::Vector{Any}, ::Type{T}) where {T<:Integer}
 end
 
 function refresh_index!(g::AbstractNetworkXGraph{T}) where {T<:Integer}
-	nodes = _nodes(g.pygraph)
-	g.nodes = nodes
-	g.node_to_index = _node_to_index(nodes, T)
+	g.nodes = pyconvert(Vector{Any}, pybuiltins.list(g.pygraph.nodes()))
+	g.node_to_index = _node_to_index(g.nodes, T)
 	return g
 end
 
@@ -85,34 +119,23 @@ end
 
 NetworkXDiGraph(pygraph::Py) = NetworkXDiGraph{Int}(pygraph)
 
-"""
-	wrap_networkx(pygraph; T=Int)
-
-Wrap a NetworkX Python graph object as a `Graphs.AbstractGraph` implementation.
-"""
-function wrap_networkx(pygraph::Py; T::Type{<:Integer}=Int)
-	return pyconvert(Bool, pygraph.is_directed()) ? NetworkXDiGraph{T}(pygraph) :
-		   NetworkXGraph{T}(pygraph)
-end
-
 """
 	networkx_graph(g)
 
 Convert a `Graphs.AbstractGraph` to a Python NetworkX graph object.
+Returns the underlying Python object for `AbstractNetworkXGraph` wrappers,
+or creates a new Python networkx graph for any other `Graphs.AbstractGraph`.
 """
 networkx_graph(g::AbstractNetworkXGraph) = g.pygraph
 
 function networkx_graph(g::Graphs.AbstractGraph)
-	nx = _nx()
+	nx = PythonNetworkX.networkx
 	pyg = Graphs.is_directed(g) ? nx.DiGraph() : nx.Graph()
 	pyg.add_nodes_from(collect(Graphs.vertices(g)))
 	pyg.add_edges_from([(Graphs.src(e), Graphs.dst(e)) for e in Graphs.edges(g)])
 	return pyg
 end
 
-wrap_networkx(g::Graphs.AbstractGraph{T}) where {T<:Integer} =
-	wrap_networkx(networkx_graph(g); T=T)
-
 Graphs.is_directed(::Type{<:NetworkXGraph}) = false
 Graphs.is_directed(::NetworkXGraph) = false
 Graphs.is_directed(::Type{<:NetworkXDiGraph}) = true
@@ -127,9 +150,6 @@ Graphs.eltype(::Type{G}) where {T<:Integer,G<:AbstractNetworkXGraph{T}} = T
 Graphs.eltype(::AbstractNetworkXGraph{T}) where {T<:Integer} = T
 
 _node(g::AbstractNetworkXGraph, v::Integer) = g.nodes[Int(v)]
-_label_to_vertex(g::AbstractNetworkXGraph{T}, label) where {T<:Integer} =
-	g.node_to_index[label]::T
-_label_to_vertex(g::Graphs.AbstractGraph, label) = label
 
 function Graphs.has_edge(g::AbstractNetworkXGraph, s, d)
 	Graphs.has_vertex(g, s) || return false
@@ -138,7 +158,7 @@ function Graphs.has_edge(g::AbstractNetworkXGraph, s, d)
 end
 
 function _mapped_neighbors(g::AbstractNetworkXGraph{T}, pyiter) where {T<:Integer}
-	py_ns = _neighbors(pyiter)
+	py_ns = pyconvert(Vector{Any}, pybuiltins.list(pyiter))
 	return T[g.node_to_index[n] for n in py_ns]
 end
 
@@ -160,12 +180,14 @@ function Graphs.inneighbors(g::NetworkXDiGraph{T}, v) where {T<:Integer}
 end
 
 function Graphs.edges(g::AbstractNetworkXGraph{T}) where {T<:Integer}
+	py_edges = pyconvert(Vector{Tuple{Any,Any}}, pybuiltins.list(g.pygraph.edges()))
 	return Graphs.Edge{T}[
-		Graphs.Edge{T}(g.node_to_index[u], g.node_to_index[v]) for (u, v) in _edges(g.pygraph)
+		Graphs.Edge{T}(g.node_to_index[u], g.node_to_index[v]) for (u, v) in py_edges
 	]
 end
 
-Graphs.has_self_loops(g::AbstractNetworkXGraph) = pyconvert(Int, _nx().number_of_selfloops(g.pygraph)) > 0
+Graphs.has_self_loops(g::AbstractNetworkXGraph) =
+	pyconvert(Int, PythonNetworkX.networkx.number_of_selfloops(g.pygraph)) > 0
 
 function Graphs.add_vertex!(g::AbstractNetworkXGraph{T}) where {T<:Integer}
 	new_index = T(Graphs.nv(g) + 1)
@@ -234,25 +256,19 @@ function Graphs.rem_vertices!(g::AbstractNetworkXGraph{T}, vs; keep_order::Bool=
 end
 
 function Graphs.squash(g::AbstractNetworkXGraph{T}) where {T<:Integer}
-	copyg = wrap_networkx(g.pygraph.copy(); T=Int)
+	copyg = typeof(g)(g.pygraph.copy())
 	copyg.nodes = copy(g.nodes)
 	_refresh_index_from_nodes!(copyg)
 	return copyg, collect(Graphs.vertices(g))
 end
 
-Graphs.zero(::Type{<:NetworkXGraph{T}}) where {T<:Integer} = wrap_networkx(_nx().Graph(); T=T)
+Graphs.zero(::Type{<:NetworkXGraph{T}}) where {T<:Integer} =
+	NetworkXGraph{T}(PythonNetworkX.networkx.Graph())
 Graphs.zero(::Type{<:NetworkXDiGraph{T}}) where {T<:Integer} =
-	wrap_networkx(_nx().DiGraph(); T=T)
-
-function Base.copy(g::NetworkXGraph{T}) where {T<:Integer}
-	copyg = NetworkXGraph{T}(g.pygraph.copy())
-	copyg.nodes = copy(g.nodes)
-	copyg.node_to_index = copy(g.node_to_index)
-	return copyg
-end
+	NetworkXDiGraph{T}(PythonNetworkX.networkx.DiGraph())
 
-function Base.copy(g::NetworkXDiGraph{T}) where {T<:Integer}
-	copyg = NetworkXDiGraph{T}(g.pygraph.copy())
+function Base.copy(g::AbstractNetworkXGraph{T}) where {T<:Integer}
+	copyg = typeof(g)(g.pygraph.copy())
 	copyg.nodes = copy(g.nodes)
 	copyg.node_to_index = copy(g.node_to_index)
 	return copyg

test/Project.toml

@@ -1,5 +1,4 @@
 [deps]
-CondaPkg = "992eb4ea-22a4-4c89-a5bb-47a3300528ab"
 Graphs = "86223c79-3864-5bf0-83f7-82e725a168b6"
 GraphsInterfaceChecker = "3bef136c-15ff-4091-acbb-1a4aafe67608"
 Interfaces = "85a1e053-f937-4924-92a5-1367d23b7b87"

test/runtests.jl

@@ -1,23 +1,19 @@
 using Test
-using CondaPkg
 using Base.Threads: nthreads
 
-CondaPkg.add("networkx")
-CondaPkg.resolve()
-
 using Graphs
 using GraphsInterfaceChecker
 using Interfaces
 using NetworkX
 using PythonCall
 
 @testset "NetworkX.jl" begin
-    nx = pyimport("networkx")
+    nx = NetworkX.PythonNetworkX.networkx
 
     @testset "Constructors and basic API" begin
         pyg = nx.Graph()
         pyg.add_edges_from([(10, 20), (20, 30), (30, 40)])
-        gw = wrap_networkx(pyg)
+        gw = NetworkXGraph(pyg)
         @test gw isa NetworkXGraph
         @test !is_directed(gw)
         @test nv(gw) == 4
@@ -31,7 +27,7 @@ using PythonCall
 
         pydg = nx.DiGraph()
         pydg.add_edges_from([(1, 2), (2, 3), (4, 2)])
-        dgw = wrap_networkx(pydg)
+        dgw = NetworkXDiGraph(pydg)
         @test dgw isa NetworkXDiGraph
         @test is_directed(dgw)
         @test nv(dgw) == 4
@@ -41,7 +37,8 @@ using PythonCall
 
         # Graphs.jl -> networkx -> wrapper roundtrip on basic structure.
         g = path_graph(5)
-        gw2 = wrap_networkx(networkx_graph(g))
+        pyg2 = networkx_graph(g)
+        gw2 = NetworkXGraph(pyg2)
         @test nv(gw2) == 5
         @test ne(gw2) == 4
         @test has_edge(gw2, 2, 3)
@@ -54,7 +51,7 @@ using PythonCall
             PythonCall.GIL.@unlock Threads.@threads for i in eachindex(results)
                 pyg = PythonCall.GIL.@lock nx.Graph()
                 PythonCall.GIL.@lock pyg.add_edges_from([(1, 2), (2, 3), (3, 4), (4, 5), (5, 5 + i)])
-                gw = PythonCall.GIL.@lock wrap_networkx(pyg)
+                gw = PythonCall.GIL.@lock NetworkXGraph(pyg)
                 ok = gw isa NetworkXGraph
                 ok &= PythonCall.GIL.@lock nv(gw) == 6
                 ok &= PythonCall.GIL.@lock ne(gw) == 5
@@ -63,7 +60,7 @@ using PythonCall
 
                 pydg = PythonCall.GIL.@lock nx.DiGraph()
                 PythonCall.GIL.@lock pydg.add_edges_from([(1, 2), (2, 3), (3, 1)])
-                dgw = PythonCall.GIL.@lock wrap_networkx(pydg)
+                dgw = PythonCall.GIL.@lock NetworkXDiGraph(pydg)
                 ok &= dgw isa NetworkXDiGraph
                 ok &= PythonCall.GIL.@lock is_directed(dgw)
                 ok &= PythonCall.GIL.@lock outneighbors(dgw, 2) == [3]
@@ -82,16 +79,16 @@ using PythonCall
         dg1 = nx.DiGraph()
         dg1.add_edges_from([(1, 2), (2, 3), (3, 4)])
         dg2 = nx.complete_graph(4, create_using=nx.DiGraph())
-        test_ugraphs = [wrap_networkx(ug1), wrap_networkx(ug2)]
-        test_dgraphs = [wrap_networkx(dg1), wrap_networkx(dg2)]
+        test_ugraphs = [NetworkXGraph(ug1), NetworkXGraph(ug2)]
+        test_dgraphs = [NetworkXDiGraph(dg1), NetworkXDiGraph(dg2)]
 
         @test Interfaces.test(AbstractGraphInterface, NetworkXGraph, test_ugraphs)
         @test Interfaces.test(AbstractGraphInterface, NetworkXDiGraph, test_dgraphs)
     end
 
     @testset "Deletion preserves wrapper order" begin
         pyg = nx.path_graph(4)
-        gw = wrap_networkx(pyg)
+        gw = NetworkXGraph(pyg)
         @test rem_vertex!(gw, 2)
         @test gw.nodes == Any[0, 3, 2]
         @test gw.node_to_index == Dict{Any,Int}(0 => 1, 3 => 2, 2 => 3)
@@ -105,19 +102,19 @@ using PythonCall
         @test gw_squash.node_to_index == gw.node_to_index
         @test vmap == [1, 2, 3]
 
-        gw_batch = wrap_networkx(nx.path_graph(4))
+        gw_batch = NetworkXGraph(nx.path_graph(4))
         @test rem_vertex!(gw_batch, 2)
         @test rem_vertices!(gw_batch, [3]) == [1, 2, 0]
         @test gw_batch.nodes == Any[0, 3]
         @test gw_batch.node_to_index == Dict{Any,Int}(0 => 1, 3 => 2)
 
-        dg = wrap_networkx(nx.DiGraph([(1, 2), (2, 3), (3, 4)]))
+        dg = NetworkXDiGraph(nx.DiGraph([(1, 2), (2, 3), (3, 4)]))
         @test rem_vertex!(dg, 2)
         @test reverse(dg).nodes == dg.nodes
     end
 
     @testset "Duplicate edges are rejected" begin
-        gw = wrap_networkx(nx.path_graph(3))
+        gw = NetworkXGraph(nx.path_graph(3))
         @test !add_edge!(gw, 1, 2)
         @test ne(gw) == 2
     end