Package evaluation to test SpineInterface on Julia 1.14.0-DEV.2705 (2f35a920f0*) started at 2026-07-19T17:07:50.707 ################################################################################ # Set-up # Installing PkgEval dependencies (TestEnv)... Activating project at `~/.julia/environments/v1.14` Set-up completed after 14.41s ################################################################################ # Installation # Installing SpineInterface... Resolving package versions... Installed Conda ── v1.10.3 Installed PyCall ─ v1.96.4 Updating `~/.julia/environments/v1.14/Project.toml` [0cda1612] + SpineInterface v0.18.0 Updating `~/.julia/environments/v1.14/Manifest.toml` [8f4d0f93] + Conda v1.10.3 [864edb3b] + DataStructures v0.19.6 ⌅ [682c06a0] + JSON v0.21.4 [1914dd2f] + MacroTools v0.5.16 [bac558e1] + OrderedCollections v2.0.1 [69de0a69] + Parsers v2.8.6 [aea7be01] + PrecompileTools v1.3.4 [21216c6a] + Preferences v1.5.2 [438e738f] + PyCall v1.96.4 [ae029012] + Requires v1.3.1 [0cda1612] + SpineInterface v0.18.0 [10745b16] + Statistics v1.11.1 [5c2747f8] + URIs v1.6.1 [81def892] + VersionParsing v1.3.0 [0dad84c5] + ArgTools v1.2.0 [56f22d72] + Artifacts v1.11.0 [2a0f44e3] + Base64 v1.11.0 [ade2ca70] + Dates v1.11.0 [f43a241f] + Downloads v1.7.0 [7b1f6079] + FileWatching v1.11.0 [b77e0a4c] + InteractiveUtils v1.11.0 [ac6e5ff7] + JuliaSyntaxHighlighting v1.13.0 [b27032c2] + LibCURL v1.0.0 [8f399da3] + Libdl v1.11.0 [37e2e46d] + LinearAlgebra v1.14.0 [56ddb016] + Logging v1.11.0 [d6f4376e] + Markdown v1.11.0 [a63ad114] + Mmap v1.11.0 [ca575930] + NetworkOptions v1.3.0 [de0858da] + Printf v1.11.0 [9a3f8284] + Random v1.11.0 [ea8e919c] + SHA v1.13.0 [9e88b42a] + Serialization v1.11.0 [6462fe0b] + Sockets v1.11.0 [f489334b] + StyledStrings v1.13.0 [fa267f1f] + TOML v1.0.3 [8dfed614] + Test v1.11.0 [cf7118a7] + UUIDs v1.11.0 [4ec0a83e] + Unicode v1.11.0 [e66e0078] + CompilerSupportLibraries_jll v1.5.5+2 [deac9b47] + LibCURL_jll v8.21.0+0 [29816b5a] + LibSSH2_jll v1.11.103+0 [14a3606d] + MozillaCACerts_jll v2026.7.16 [4536629a] + OpenBLAS_jll v0.3.33+0 [458c3c95] + OpenSSL_jll v3.5.7+0 [83775a58] + Zlib_jll v1.3.2+0 [3161d3a3] + Zstd_jll v1.5.7+1 [8e850b90] + libblastrampoline_jll v5.15.0+0 [8e850ede] + nghttp2_jll v1.69.0+0 Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. To see why use `status --outdated -m` Building Conda ─→ `~/.julia/scratchspaces/44cfe95a-1eb2-52ea-b672-e2afdf69b78f/8f06b0cfa4c514c7b9546756dbae91fcfbc92dc9/build.log` Building PyCall → `~/.julia/scratchspaces/44cfe95a-1eb2-52ea-b672-e2afdf69b78f/9816a3826b0ebf49ab4926e2b18842ad8b5c8f04/build.log` Installation completed after 43.86s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... ┌ Warning: Could not use exact versions of packages in manifest, re-resolving └ @ TestEnv ~/.julia/packages/TestEnv/RUPmD/src/julia-1.13/activate_set.jl:78 Precompiling package dependencies... Precompiling project... 2.2 s ✓ OpenBLAS32_jll 1.2 s ✓ Bzip2_jll 1.1 s ✓ HiGHS_jll 4.5 s ✓ SpineInterface 1.5 s ✓ CodecBzip2 105.5 s ✓ MathOptInterface 66.7 s ✓ JuMP 8.2 s ✓ MathOptIIS 39.9 s ✓ HiGHS 9 dependencies successfully precompiled in 232 seconds. 57 already precompiled. Precompilation completed after 257.26s ################################################################################ # Testing # Testing SpineInterface Test Could not use exact versions of packages in manifest, re-resolving. Note: if you do not check your manifest file into source control, then you can probably ignore this message. However, if you do check your manifest file into source control, then you probably want to pass the `allow_reresolve = false` kwarg when calling the `Pkg.test` function. Updating `/tmp/jl_86EySQ/Project.toml` [87dc4568] + HiGHS v1.24.1 [4076af6c] + JuMP v1.30.1 Updating `/tmp/jl_86EySQ/Manifest.toml` [523fee87] + CodecBzip2 v0.8.5 [944b1d66] + CodecZlib v0.7.8 [bbf7d656] + CommonSubexpressions v0.3.1 [163ba53b] + DiffResults v1.1.0 [b552c78f] + DiffRules v1.16.0 [ffbed154] + DocStringExtensions v0.9.5 [f6369f11] + ForwardDiff v1.4.1 [87dc4568] + HiGHS v1.24.1 [92d709cd] + IrrationalConstants v0.2.6 [692b3bcd] + JLLWrappers v1.8.0 [4076af6c] + JuMP v1.30.1 [2ab3a3ac] + LogExpFunctions v1.0.1 [8c4f8055] + MathOptIIS v0.2.0 [b8f27783] + MathOptInterface v1.51.2 [d8a4904e] + MutableArithmetics v1.8.0 [77ba4419] + NaNMath v1.1.4 ⌅ [bac558e1] ↓ OrderedCollections v2.0.1 ⇒ v1.8.2 [276daf66] + SpecialFunctions v2.8.0 [1e83bf80] + StaticArraysCore v1.4.4 [3bb67fe8] + TranscodingStreams v0.11.3 [6e34b625] + Bzip2_jll v1.0.9+0 [8fd58aa0] + HiGHS_jll v1.15.1+0 [656ef2d0] + OpenBLAS32_jll v0.3.33+2 [efe28fd5] + OpenSpecFun_jll v0.5.6+0 [2f01184e] + SparseArrays v1.13.0 [05823500] + OpenLibm_jll v0.8.7+0 [bea87d4a] + SuiteSparse_jll v7.10.1+0 Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. To see why use `status --outdated -m` Test Successfully re-resolved Status `/tmp/jl_86EySQ/Project.toml` [87dc4568] HiGHS v1.24.1 ⌅ [682c06a0] JSON v0.21.4 [4076af6c] JuMP v1.30.1 [438e738f] PyCall v1.96.4 [0cda1612] SpineInterface v0.18.0 [ade2ca70] Dates v1.11.0 [8dfed614] Test v1.11.0 Status `/tmp/jl_86EySQ/Manifest.toml` [523fee87] CodecBzip2 v0.8.5 [944b1d66] CodecZlib v0.7.8 [bbf7d656] CommonSubexpressions v0.3.1 [8f4d0f93] Conda v1.10.3 [864edb3b] DataStructures v0.19.6 [163ba53b] DiffResults v1.1.0 [b552c78f] DiffRules v1.16.0 [ffbed154] DocStringExtensions v0.9.5 [f6369f11] ForwardDiff v1.4.1 [87dc4568] HiGHS v1.24.1 [92d709cd] IrrationalConstants v0.2.6 [692b3bcd] JLLWrappers v1.8.0 ⌅ [682c06a0] JSON v0.21.4 [4076af6c] JuMP v1.30.1 [2ab3a3ac] LogExpFunctions v1.0.1 [1914dd2f] MacroTools v0.5.16 [8c4f8055] MathOptIIS v0.2.0 [b8f27783] MathOptInterface v1.51.2 [d8a4904e] MutableArithmetics v1.8.0 [77ba4419] NaNMath v1.1.4 ⌅ [bac558e1] OrderedCollections v1.8.2 [69de0a69] Parsers v2.8.6 [aea7be01] PrecompileTools v1.3.4 [21216c6a] Preferences v1.5.2 [438e738f] PyCall v1.96.4 [ae029012] Requires v1.3.1 [276daf66] SpecialFunctions v2.8.0 [0cda1612] SpineInterface v0.18.0 [1e83bf80] StaticArraysCore v1.4.4 [10745b16] Statistics v1.11.1 [3bb67fe8] TranscodingStreams v0.11.3 [5c2747f8] URIs v1.6.1 [81def892] VersionParsing v1.3.0 [6e34b625] Bzip2_jll v1.0.9+0 [8fd58aa0] HiGHS_jll v1.15.1+0 [656ef2d0] OpenBLAS32_jll v0.3.33+2 [efe28fd5] OpenSpecFun_jll v0.5.6+0 [0dad84c5] ArgTools v1.2.0 [56f22d72] Artifacts v1.11.0 [2a0f44e3] Base64 v1.11.0 [ade2ca70] Dates v1.11.0 [f43a241f] Downloads v1.7.0 [7b1f6079] FileWatching v1.11.0 [b77e0a4c] InteractiveUtils v1.11.0 [ac6e5ff7] JuliaSyntaxHighlighting v1.13.0 [b27032c2] LibCURL v1.0.0 [8f399da3] Libdl v1.11.0 [37e2e46d] LinearAlgebra v1.14.0 [56ddb016] Logging v1.11.0 [d6f4376e] Markdown v1.11.0 [a63ad114] Mmap v1.11.0 [ca575930] NetworkOptions v1.3.0 [de0858da] Printf v1.11.0 [9a3f8284] Random v1.11.0 [ea8e919c] SHA v1.13.0 [9e88b42a] Serialization v1.11.0 [6462fe0b] Sockets v1.11.0 [2f01184e] SparseArrays v1.13.0 [f489334b] StyledStrings v1.13.0 [fa267f1f] TOML v1.0.3 [8dfed614] Test v1.11.0 [cf7118a7] UUIDs v1.11.0 [4ec0a83e] Unicode v1.11.0 [e66e0078] CompilerSupportLibraries_jll v1.5.5+2 [deac9b47] LibCURL_jll v8.21.0+0 [29816b5a] LibSSH2_jll v1.11.103+0 [14a3606d] MozillaCACerts_jll v2026.7.16 [4536629a] OpenBLAS_jll v0.3.33+0 [05823500] OpenLibm_jll v0.8.7+0 [458c3c95] OpenSSL_jll v3.5.7+0 [bea87d4a] SuiteSparse_jll v7.10.1+0 [83775a58] Zlib_jll v1.3.2+0 [3161d3a3] Zstd_jll v1.5.7+1 [8e850b90] libblastrampoline_jll v5.15.0+0 [8e850ede] nghttp2_jll v1.69.0+0 Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. Testing Running tests... object_class: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:23 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, objects::Vector{Vector{String}}, object_groups::Vector{Vector{String}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:28 [inlined] [8] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [9] _test_object_class() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:24 [10] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:533 [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:533 [inlined] [13] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ none:6 [19] eval(m::Module, e::Any) @ Core boot.jl:545 [20] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [21] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, objects::Vector{Vector{String}}, object_groups::Vector{Vector{String}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:28 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_object_class() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:24 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:533 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:533 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 relationship_class: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:49 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, relationship_classes::Vector{Vector{Any}}, objects::Vector{Vector{String}}, relationships::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:70 [inlined] [8] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [9] _test_relationship_class() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:50 [10] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:533 [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:534 [inlined] [13] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ none:6 [19] eval(m::Module, e::Any) @ Core boot.jl:545 [20] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [21] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, relationship_classes::Vector{Vector{Any}}, objects::Vector{Vector{String}}, relationships::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:70 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_relationship_class() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:50 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:533 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:534 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 parameter: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:104 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, relationship_classes::Vector{Vector{Any}}, objects::Vector{Vector{String}}, relationships::Vector{Vector{Any}}, object_parameters::Vector{Vector{String}}, relationship_parameters::Vector{Vector{Any}}, object_parameter_values::Vector{Vector{Any}}, relationship_parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:133 [inlined] [8] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [9] _test_parameter() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:105 [10] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:533 [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:535 [inlined] [13] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ none:6 [19] eval(m::Module, e::Any) @ Core boot.jl:545 [20] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [21] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, relationship_classes::Vector{Vector{Any}}, objects::Vector{Vector{String}}, relationships::Vector{Vector{Any}}, object_parameters::Vector{Vector{String}}, relationship_parameters::Vector{Vector{Any}}, object_parameter_values::Vector{Vector{Any}}, relationship_parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:133 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_parameter() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:105 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:533 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:535 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 using_spinedb - parameter value types: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:538 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, objects::Vector{Vector{String}}, object_parameters::Vector{Vector{String}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] _test_pv_type_setup() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:172 [8] _test_pv_type_true() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:176 [9] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:539 [10] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [11] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:539 [inlined] [12] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [13] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [inlined] [16] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [17] top-level scope @ none:6 [18] eval(m::Module, e::Any) @ Core boot.jl:545 [19] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [20] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, objects::Vector{Vector{String}}, object_parameters::Vector{Vector{String}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] _test_pv_type_setup() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:172 [9] _test_pv_type_true() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:176 [10] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:539 [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:539 [inlined] [13] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ none:6 [19] eval(m::Module, e::Any) @ Core boot.jl:545 [20] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [21] _start() @ Base client.jl:596 using_spinedb_in_a_loop: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:404 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{alternatives::Vector{String}, object_classes::Vector{String}, objects::Vector{Tuple{String, String}}, object_parameters::Vector{Tuple{String, String}}, object_parameter_values::Vector{NTuple{5, String}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:409 [inlined] [8] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [9] _test_using_spinedb_in_a_loop() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:405 [10] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:552 [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:552 [inlined] [13] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ none:6 [19] eval(m::Module, e::Any) @ Core boot.jl:545 [20] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [21] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{alternatives::Vector{String}, object_classes::Vector{String}, objects::Vector{Tuple{String, String}}, object_parameters::Vector{Tuple{String, String}}, object_parameter_values::Vector{NTuple{5, String}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:409 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_using_spinedb_in_a_loop() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:405 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:552 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:552 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 using_spinedb_extend: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:426 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{Vector{String}}, object_parameters::Vector{Vector{String}}, relationship_classes::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:435 [inlined] [8] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [9] _test_using_spinedb_extend() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:427 [10] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:552 [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:553 [inlined] [13] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ none:6 [19] eval(m::Module, e::Any) @ Core boot.jl:545 [20] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [21] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{Vector{String}}, object_parameters::Vector{Vector{String}}, relationship_classes::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:435 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_using_spinedb_extend() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:427 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:552 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:553 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 using_spinedb_with_env: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:501 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{relationships::Vector{Vector{Any}}, object_classes::Vector{Vector{String}}, objects::Vector{Vector{String}}, relationship_classes::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:515 [inlined] [8] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [9] _test_using_spinedb_with_env() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:502 [10] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:552 [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:554 [inlined] [13] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ none:6 [19] eval(m::Module, e::Any) @ Core boot.jl:545 [20] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [21] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{relationships::Vector{Vector{Any}}, object_classes::Vector{Vector{String}}, objects::Vector{Vector{String}}, relationship_classes::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:515 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_using_spinedb_with_env() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:502 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:552 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:554 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 using_spinedb_with_module: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:445 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{relationships::Vector{Vector{Any}}, object_classes::Vector{Vector{String}}, object_parameters::Vector{Vector{String}}, objects::Vector{Vector{String}}, relationship_classes::Vector{Vector{Any}}, object_parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:457 [inlined] [8] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [9] _test_using_spinedb_with_module() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:446 [10] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:552 [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:555 [inlined] [13] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ none:6 [19] eval(m::Module, e::Any) @ Core boot.jl:545 [20] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [21] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{relationships::Vector{Vector{Any}}, object_classes::Vector{Vector{String}}, object_parameters::Vector{Vector{String}}, objects::Vector{Vector{String}}, relationship_classes::Vector{Vector{Any}}, object_parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:457 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_using_spinedb_with_module() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:446 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:552 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:555 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 add_binding_type_mismatch: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:487 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{Vector{String}}, objects::Vector{Vector{String}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:489 [inlined] [8] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [9] _test_add_binding_type_mismatch() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:488 [10] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:552 [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:556 [inlined] [13] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ none:6 [19] eval(m::Module, e::Any) @ Core boot.jl:545 [20] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [21] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{Vector{String}}, objects::Vector{Vector{String}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:489 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_add_binding_type_mismatch() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:488 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:552 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/using_spinedb.jl:556 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 indices: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/api.jl:24 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, relationship_classes::Vector{Vector{Any}}, objects::Vector{Vector{String}}, relationships::Vector{Vector{Any}}, object_parameters::Vector{Vector{Any}}, relationship_parameters::Vector{Vector{String}}, object_parameter_values::Vector{Vector{Any}}, relationship_parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:38 [inlined] [8] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [9] _test_indices() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:25 [10] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [inlined] [13] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ none:6 [19] eval(m::Module, e::Any) @ Core boot.jl:545 [20] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [21] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, relationship_classes::Vector{Vector{Any}}, objects::Vector{Vector{String}}, relationships::Vector{Vector{Any}}, object_parameters::Vector{Vector{Any}}, relationship_parameters::Vector{Vector{String}}, object_parameter_values::Vector{Vector{Any}}, relationship_parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:38 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_indices() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:25 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 indices as tuples: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/api.jl:65 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, objects::Vector{Vector{String}}, object_parameters::Vector{Vector{String}}, object_parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:72 [inlined] [8] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [9] _test_indices_as_tuples() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:66 [10] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1388 [inlined] [13] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ none:6 [19] eval(m::Module, e::Any) @ Core boot.jl:545 [20] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [21] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, objects::Vector{Vector{String}}, object_parameters::Vector{Vector{String}}, object_parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:72 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_indices_as_tuples() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:66 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1388 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 object_class, relationship_class, parameter: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/api.jl:87 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, relationship_classes::Vector{Vector{Any}}, object_parameters::Vector{Vector{String}}, relationship_parameters::Vector{Vector{String}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:93 [inlined] [8] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [9] _test_object_class_relationship_class_parameter() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:88 [10] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1389 [inlined] [13] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ none:6 [19] eval(m::Module, e::Any) @ Core boot.jl:545 [20] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [21] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, relationship_classes::Vector{Vector{Any}}, object_parameters::Vector{Vector{String}}, relationship_parameters::Vector{Vector{String}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:93 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_object_class_relationship_class_parameter() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:88 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1389 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 add_objects: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/api.jl:164 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, objects::Vector{Vector{String}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:168 [inlined] [8] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [9] _test_add_objects() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:165 [10] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1392 [inlined] [13] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ none:6 [19] eval(m::Module, e::Any) @ Core boot.jl:545 [20] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [21] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, objects::Vector{Vector{String}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:168 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_add_objects() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:165 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1392 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 add_relationships: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/api.jl:182 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, relationship_classes::Vector{Vector{Any}}, objects::Vector{Vector{String}}, relationships::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:192 [inlined] [8] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [9] _test_add_relationships() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:183 [10] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1393 [inlined] [13] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ none:6 [19] eval(m::Module, e::Any) @ Core boot.jl:545 [20] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [21] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, relationship_classes::Vector{Vector{Any}}, objects::Vector{Vector{String}}, relationships::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:192 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_add_relationships() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:183 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1393 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 add_object_parameter_values: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/api.jl:284 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, objects::Vector{Vector{String}}, object_parameters::Vector{Vector{String}}, object_parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:291 [inlined] [8] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [9] _test_add_object_parameter_values() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:285 [10] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1395 [inlined] [13] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ none:6 [19] eval(m::Module, e::Any) @ Core boot.jl:545 [20] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [21] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, objects::Vector{Vector{String}}, object_parameters::Vector{Vector{String}}, object_parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:291 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_add_object_parameter_values() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:285 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1395 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 add_relationship_parameter_values: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/api.jl:319 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, relationship_classes::Vector{Vector{Any}}, relationship_parameters::Vector{Vector{String}}, objects::Vector{Vector{String}}, relationships::Vector{Vector{Any}}, relationship_parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:334 [inlined] [8] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [9] _test_add_relationship_parameter_values() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:320 [10] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1396 [inlined] [13] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ none:6 [19] eval(m::Module, e::Any) @ Core boot.jl:545 [20] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [21] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, relationship_classes::Vector{Vector{Any}}, relationship_parameters::Vector{Vector{String}}, objects::Vector{Vector{String}}, relationships::Vector{Vector{Any}}, relationship_parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:334 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_add_relationship_parameter_values() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:320 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1396 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 int & string: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/api.jl:385 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] _db(f::SpineInterface.var"#196#197"{Dict{Symbol, Any}, String}, url::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:929 [6] import_data(url::String, data::Dict{Symbol, Any}, comment::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:854 [inlined] [7] write_parameters(parameters::Dict{Symbol, Dict{NamedTuple, Any}}, url::String; upgrade::Bool, for_object::Bool, report::String, alternative::String, on_conflict::String, comment::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:716 [8] write_parameters(parameters::Dict{Symbol, Dict{NamedTuple, Any}}, url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:693 [9] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:388 [inlined] [10] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [11] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:386 [inlined] [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] _test_write_parameters() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:383 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1397 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [19] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [20] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [21] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [22] top-level scope @ none:6 [23] eval(m::Module, e::Any) @ Core boot.jl:545 [24] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [25] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] _db(f::SpineInterface.var"#196#197"{Dict{Symbol, Any}, String}, url::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:929 [7] import_data(url::String, data::Dict{Symbol, Any}, comment::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:854 [inlined] [8] write_parameters(parameters::Dict{Symbol, Dict{NamedTuple, Any}}, url::String; upgrade::Bool, for_object::Bool, report::String, alternative::String, on_conflict::String, comment::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:716 [9] write_parameters(parameters::Dict{Symbol, Dict{NamedTuple, Any}}, url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:693 [10] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:388 [inlined] [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:386 [inlined] [13] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [14] _test_write_parameters() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:383 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1397 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [20] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [21] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [22] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [23] top-level scope @ none:6 [24] eval(m::Module, e::Any) @ Core boot.jl:545 [25] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [26] _start() @ Base client.jl:596 date_time & duration: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/api.jl:394 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] _db(f::SpineInterface.var"#196#197"{Dict{Symbol, Any}, String}, url::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:929 [6] import_data(url::String, data::Dict{Symbol, Any}, comment::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:854 [inlined] [7] write_parameters(parameters::Dict{Symbol, Dict{NamedTuple, Dates.AbstractTime}}, url::String; upgrade::Bool, for_object::Bool, report::String, alternative::String, on_conflict::String, comment::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:716 [8] write_parameters(parameters::Dict{Symbol, Dict{NamedTuple, Dates.AbstractTime}}, url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:693 [9] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:398 [inlined] [10] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [11] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:395 [inlined] [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] _test_write_parameters() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:383 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1397 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [19] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [20] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [21] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [22] top-level scope @ none:6 [23] eval(m::Module, e::Any) @ Core boot.jl:545 [24] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [25] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] _db(f::SpineInterface.var"#196#197"{Dict{Symbol, Any}, String}, url::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:929 [7] import_data(url::String, data::Dict{Symbol, Any}, comment::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:854 [inlined] [8] write_parameters(parameters::Dict{Symbol, Dict{NamedTuple, Dates.AbstractTime}}, url::String; upgrade::Bool, for_object::Bool, report::String, alternative::String, on_conflict::String, comment::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:716 [9] write_parameters(parameters::Dict{Symbol, Dict{NamedTuple, Dates.AbstractTime}}, url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:693 [10] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:398 [inlined] [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:395 [inlined] [13] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [14] _test_write_parameters() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:383 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1397 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [20] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [21] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [22] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [23] top-level scope @ none:6 [24] eval(m::Module, e::Any) @ Core boot.jl:545 [25] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [26] _start() @ Base client.jl:596 array: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/api.jl:404 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] _db(f::SpineInterface.var"#196#197"{Dict{Symbol, Any}, String}, url::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:929 [6] import_data(url::String, data::Dict{Symbol, Any}, comment::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:854 [inlined] [7] write_parameters(parameters::Dict{Symbol, Dict{@NamedTuple{country::Symbol}, Vector{Float64}}}, url::String; upgrade::Bool, for_object::Bool, report::String, alternative::String, on_conflict::String, comment::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:716 [8] write_parameters(parameters::Dict{Symbol, Dict{@NamedTuple{country::Symbol}, Vector{Float64}}}, url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:693 [inlined] [9] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:407 [inlined] [10] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [11] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:405 [inlined] [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] _test_write_parameters() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:383 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1397 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [19] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [20] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [21] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [22] top-level scope @ none:6 [23] eval(m::Module, e::Any) @ Core boot.jl:545 [24] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [25] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] _db(f::SpineInterface.var"#196#197"{Dict{Symbol, Any}, String}, url::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:929 [7] import_data(url::String, data::Dict{Symbol, Any}, comment::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:854 [inlined] [8] write_parameters(parameters::Dict{Symbol, Dict{@NamedTuple{country::Symbol}, Vector{Float64}}}, url::String; upgrade::Bool, for_object::Bool, report::String, alternative::String, on_conflict::String, comment::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:716 [9] write_parameters(parameters::Dict{Symbol, Dict{@NamedTuple{country::Symbol}, Vector{Float64}}}, url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:693 [inlined] [10] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:407 [inlined] [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:405 [inlined] [13] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [14] _test_write_parameters() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:383 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1397 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [20] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [21] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [22] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [23] top-level scope @ none:6 [24] eval(m::Module, e::Any) @ Core boot.jl:545 [25] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [26] _start() @ Base client.jl:596 time_pattern: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/api.jl:412 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] _db(f::SpineInterface.var"#196#197"{Dict{Symbol, Any}, String}, url::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:929 [6] import_data(url::String, data::Dict{Symbol, Any}, comment::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:854 [inlined] [7] write_parameters(parameters::Dict{Symbol, Dict{@NamedTuple{country::Symbol}, Dict{Vector{Vector{SpineInterface.TimeInterval}}, Float64}}}, url::String; upgrade::Bool, for_object::Bool, report::String, alternative::String, on_conflict::String, comment::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:716 [8] write_parameters(parameters::Dict{Symbol, Dict{@NamedTuple{country::Symbol}, Dict{Vector{Vector{SpineInterface.TimeInterval}}, Float64}}}, url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:693 [9] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:418 [inlined] [10] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [11] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:413 [inlined] [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] _test_write_parameters() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:383 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1397 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [19] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [20] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [21] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [22] top-level scope @ none:6 [23] eval(m::Module, e::Any) @ Core boot.jl:545 [24] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [25] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] _db(f::SpineInterface.var"#196#197"{Dict{Symbol, Any}, String}, url::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:929 [7] import_data(url::String, data::Dict{Symbol, Any}, comment::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:854 [inlined] [8] write_parameters(parameters::Dict{Symbol, Dict{@NamedTuple{country::Symbol}, Dict{Vector{Vector{SpineInterface.TimeInterval}}, Float64}}}, url::String; upgrade::Bool, for_object::Bool, report::String, alternative::String, on_conflict::String, comment::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:716 [9] write_parameters(parameters::Dict{Symbol, Dict{@NamedTuple{country::Symbol}, Dict{Vector{Vector{SpineInterface.TimeInterval}}, Float64}}}, url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:693 [10] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:418 [inlined] [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:413 [inlined] [13] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [14] _test_write_parameters() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:383 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1397 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [20] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [21] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [22] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [23] top-level scope @ none:6 [24] eval(m::Module, e::Any) @ Core boot.jl:545 [25] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [26] _start() @ Base client.jl:596 time_series: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/api.jl:436 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] _db(f::SpineInterface.var"#196#197"{Dict{Symbol, Any}, String}, url::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:929 [6] import_data(url::String, data::Dict{Symbol, Any}, comment::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:854 [inlined] [7] write_parameters(parameters::Dict{Symbol, Dict{@NamedTuple{country::Symbol}, TimeSeries{Int64}}}, url::String; upgrade::Bool, for_object::Bool, report::String, alternative::String, on_conflict::String, comment::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:716 [8] write_parameters(parameters::Dict{Symbol, Dict{@NamedTuple{country::Symbol}, TimeSeries{Int64}}}, url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:693 [inlined] [9] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:440 [inlined] [10] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [11] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:437 [inlined] [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] _test_write_parameters() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:383 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1397 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [19] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [20] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [21] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [22] top-level scope @ none:6 [23] eval(m::Module, e::Any) @ Core boot.jl:545 [24] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [25] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] _db(f::SpineInterface.var"#196#197"{Dict{Symbol, Any}, String}, url::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:929 [7] import_data(url::String, data::Dict{Symbol, Any}, comment::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:854 [inlined] [8] write_parameters(parameters::Dict{Symbol, Dict{@NamedTuple{country::Symbol}, TimeSeries{Int64}}}, url::String; upgrade::Bool, for_object::Bool, report::String, alternative::String, on_conflict::String, comment::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:716 [9] write_parameters(parameters::Dict{Symbol, Dict{@NamedTuple{country::Symbol}, TimeSeries{Int64}}}, url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:693 [inlined] [10] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:440 [inlined] [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:437 [inlined] [13] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [14] _test_write_parameters() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:383 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1397 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [20] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [21] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [22] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [23] top-level scope @ none:6 [24] eval(m::Module, e::Any) @ Core boot.jl:545 [25] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [26] _start() @ Base client.jl:596 repeating time_series: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/api.jl:458 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] _db(f::SpineInterface.var"#196#197"{Dict{Symbol, Any}, String}, url::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:929 [6] import_data(url::String, data::Dict{Symbol, Any}, comment::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:854 [inlined] [7] write_parameters(parameters::Dict{Symbol, Dict{@NamedTuple{country::Symbol}, TimeSeries{Int64}}}, url::String; upgrade::Bool, for_object::Bool, report::String, alternative::String, on_conflict::String, comment::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:716 [8] write_parameters(parameters::Dict{Symbol, Dict{@NamedTuple{country::Symbol}, TimeSeries{Int64}}}, url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:693 [inlined] [9] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:469 [inlined] [10] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [11] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:459 [inlined] [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] _test_write_parameters() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:383 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1397 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [19] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [20] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [21] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [22] top-level scope @ none:6 [23] eval(m::Module, e::Any) @ Core boot.jl:545 [24] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [25] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] _db(f::SpineInterface.var"#196#197"{Dict{Symbol, Any}, String}, url::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:929 [7] import_data(url::String, data::Dict{Symbol, Any}, comment::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:854 [inlined] [8] write_parameters(parameters::Dict{Symbol, Dict{@NamedTuple{country::Symbol}, TimeSeries{Int64}}}, url::String; upgrade::Bool, for_object::Bool, report::String, alternative::String, on_conflict::String, comment::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:716 [9] write_parameters(parameters::Dict{Symbol, Dict{@NamedTuple{country::Symbol}, TimeSeries{Int64}}}, url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:693 [inlined] [10] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:469 [inlined] [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:459 [inlined] [13] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [14] _test_write_parameters() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:383 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1397 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [20] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [21] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [22] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [23] top-level scope @ none:6 [24] eval(m::Module, e::Any) @ Core boot.jl:545 [25] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [26] _start() @ Base client.jl:596 with report: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/api.jl:489 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] _db(f::SpineInterface.var"#196#197"{Dict{Symbol, Any}, String}, url::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:929 [6] import_data(url::String, data::Dict{Symbol, Any}, comment::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:854 [inlined] [7] write_parameters(parameters::Dict{Symbol, Dict{@NamedTuple{country::Symbol}, String}}, url::String; upgrade::Bool, for_object::Bool, report::String, alternative::String, on_conflict::String, comment::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:716 [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:492 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:490 [inlined] [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] _test_write_parameters() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:383 [13] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1397 [inlined] [16] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [17] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [19] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [20] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [21] top-level scope @ none:6 [22] eval(m::Module, e::Any) @ Core boot.jl:545 [23] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [24] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] _db(f::SpineInterface.var"#196#197"{Dict{Symbol, Any}, String}, url::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:929 [7] import_data(url::String, data::Dict{Symbol, Any}, comment::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:854 [inlined] [8] write_parameters(parameters::Dict{Symbol, Dict{@NamedTuple{country::Symbol}, String}}, url::String; upgrade::Bool, for_object::Bool, report::String, alternative::String, on_conflict::String, comment::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:716 [9] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:492 [inlined] [10] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [11] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:490 [inlined] [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] _test_write_parameters() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:383 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1397 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [19] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [20] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [21] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [22] top-level scope @ none:6 [23] eval(m::Module, e::Any) @ Core boot.jl:545 [24] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [25] _start() @ Base client.jl:596 maximum_parameter_value: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/api.jl:519 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, relationship_classes::Vector{Vector{Any}}, objects::Vector{Vector{String}}, relationships::Vector{Vector{Any}}, relationship_parameters::Vector{Vector{String}}, relationship_parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:574 [inlined] [8] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [9] _test_maximum_parameter_value() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:520 [10] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1399 [inlined] [13] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ none:6 [19] eval(m::Module, e::Any) @ Core boot.jl:545 [20] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [21] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, relationship_classes::Vector{Vector{Any}}, objects::Vector{Vector{String}}, relationships::Vector{Vector{Any}}, relationship_parameters::Vector{Vector{String}}, relationship_parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:574 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_maximum_parameter_value() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:520 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1399 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 import_data: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/api.jl:590 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{Any}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:592 [inlined] [8] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [9] _test_import_data() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:592 [10] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1400 [inlined] [13] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ none:6 [19] eval(m::Module, e::Any) @ Core boot.jl:545 [20] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [21] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{Any}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:592 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_import_data() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:592 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1400 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 difference: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/api.jl:634 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, relationship_classes::Vector{Vector{Any}}, object_parameters::Vector{Vector{String}}, relationship_parameters::Vector{Vector{String}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:635 [inlined] [8] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [9] _test_difference() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:635 [10] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1401 [inlined] [13] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ none:6 [19] eval(m::Module, e::Any) @ Core boot.jl:545 [20] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [21] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, relationship_classes::Vector{Vector{Any}}, object_parameters::Vector{Vector{String}}, relationship_parameters::Vector{Vector{String}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:635 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_difference() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:635 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1401 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 indexed_values: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/api.jl:663 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, objects::Vector{Vector{String}}, object_parameters::Vector{Vector{String}}, object_parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:708 [inlined] [8] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [9] _test_indexed_values() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:664 [10] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1402 [inlined] [13] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ none:6 [19] eval(m::Module, e::Any) @ Core boot.jl:545 [20] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [21] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, objects::Vector{Vector{String}}, object_parameters::Vector{Vector{String}}, object_parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:708 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_indexed_values() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:664 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1402 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 superclasses: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/api.jl:942 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{entity_classes::Vector{Vector{Any}}, superclass_subclasses::Vector{Vector{String}}, entities::Vector{Vector{Any}}, parameter_definitions::Vector{Vector{Any}}, parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] _import_superclass_test_data(db_url::String) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:931 [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:944 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_superclasses() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:944 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1405 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{entity_classes::Vector{Vector{Any}}, superclass_subclasses::Vector{Vector{String}}, entities::Vector{Vector{Any}}, parameter_definitions::Vector{Vector{Any}}, parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] _import_superclass_test_data(db_url::String) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:931 [9] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:944 [inlined] [10] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [11] _test_superclasses() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:944 [12] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [13] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [14] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1405 [inlined] [15] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [16] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [17] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [18] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [19] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [20] top-level scope @ none:6 [21] eval(m::Module, e::Any) @ Core boot.jl:545 [22] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [23] _start() @ Base client.jl:596 writing_superclasses: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/api.jl:1068 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{entity_classes::Vector{Vector{Any}}, superclass_subclasses::Vector{Vector{String}}, entities::Vector{Vector{Any}}, parameter_definitions::Vector{Vector{Any}}, parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] _import_superclass_test_data(db_url::String) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:931 [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1071 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_writing_superclasses() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1071 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1406 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{entity_classes::Vector{Vector{Any}}, superclass_subclasses::Vector{Vector{String}}, entities::Vector{Vector{Any}}, parameter_definitions::Vector{Vector{Any}}, parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] _import_superclass_test_data(db_url::String) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:931 [9] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1071 [inlined] [10] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [11] _test_writing_superclasses() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1071 [12] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [13] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [14] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1406 [inlined] [15] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [16] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [17] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [18] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [19] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [20] top-level scope @ none:6 [21] eval(m::Module, e::Any) @ Core boot.jl:545 [22] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [23] _start() @ Base client.jl:596 manipulating_superclasses: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/api.jl:1102 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{entity_classes::Vector{Vector{Any}}, superclass_subclasses::Vector{Vector{String}}, entities::Vector{Vector{Any}}, parameter_definitions::Vector{Vector{Any}}, parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] _import_superclass_test_data(db_url::String) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:931 [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1105 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_manipulating_superclasses() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1105 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1407 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{entity_classes::Vector{Vector{Any}}, superclass_subclasses::Vector{Vector{String}}, entities::Vector{Vector{Any}}, parameter_definitions::Vector{Vector{Any}}, parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] _import_superclass_test_data(db_url::String) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:931 [9] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1105 [inlined] [10] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [11] _test_manipulating_superclasses() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1105 [12] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [13] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [14] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1407 [inlined] [15] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [16] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [17] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [18] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [19] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [20] top-level scope @ none:6 [21] eval(m::Module, e::Any) @ Core boot.jl:545 [22] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [23] _start() @ Base client.jl:596 reorder_dimensions: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/api.jl:1139 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, relationship_classes::Vector{Vector{Any}}, objects::Vector{Vector{String}}, relationships::Vector{Vector{Any}}, relationship_parameters::Vector{Vector{String}}, relationship_parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1160 [inlined] [8] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [9] _test_reorder_dimensions() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1140 [10] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1408 [inlined] [13] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ none:6 [19] eval(m::Module, e::Any) @ Core boot.jl:545 [20] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [21] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, relationship_classes::Vector{Vector{Any}}, objects::Vector{Vector{String}}, relationships::Vector{Vector{Any}}, relationship_parameters::Vector{Vector{String}}, relationship_parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1160 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_reorder_dimensions() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1140 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1408 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 add_dimension!: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/api.jl:1241 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, relationship_classes::Vector{Vector{Any}}, objects::Vector{Vector{String}}, relationships::Vector{Vector{Any}}, relationship_parameters::Vector{Vector{String}}, relationship_parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1258 [inlined] [8] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [9] _test_add_dimension() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1242 [10] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1409 [inlined] [13] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ none:6 [19] eval(m::Module, e::Any) @ Core boot.jl:545 [20] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [21] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{object_classes::Vector{String}, relationship_classes::Vector{Vector{Any}}, objects::Vector{Vector{String}}, relationships::Vector{Vector{Any}}, relationship_parameters::Vector{Vector{String}}, relationship_parameter_values::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1258 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_add_dimension() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1242 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1409 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 parse_db!: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/api.jl:1358 Got exception outside of a @test UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [6] import_test_data(db_url::String; kwargs::@Kwargs{parameter_values::Vector{Vector{Any}}, entity_classes::Vector{Vector{Any}}, entities::Vector{Vector{Union{Nothing, String}}}, parameter_definitions::Vector{Vector{Union{Nothing, String}}}, alternatives::Vector{Vector{String}}, parameter_value_lists::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [7] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1377 [inlined] [8] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [9] _test_parse_db_dict() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1359 [10] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1410 [inlined] [13] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [14] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [17] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [18] top-level scope @ none:6 [19] eval(m::Module, e::Any) @ Core boot.jl:545 [20] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [21] _start() @ Base client.jl:596 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] open_connection(db_url::String) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:910 [7] import_test_data(db_url::String; kwargs::@Kwargs{parameter_values::Vector{Vector{Any}}, entity_classes::Vector{Vector{Any}}, entities::Vector{Vector{Union{Nothing, String}}}, parameter_definitions::Vector{Vector{Union{Nothing, String}}}, alternatives::Vector{Vector{String}}, parameter_value_lists::Vector{Vector{Any}}}) @ Main ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:39 [inlined] [8] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1377 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [10] _test_parse_db_dict() @ Main ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1359 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1387 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/api.jl:1410 [inlined] [14] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [15] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:51 [inlined] [18] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [19] top-level scope @ none:6 [20] eval(m::Module, e::Any) @ Core boot.jl:545 [21] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [22] _start() @ Base client.jl:596 ┌ Warning: can't find a value of uses_pants for argument(s) (studio = Disney, duck = Daffy) └ @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/util.jl:47 Running HiGHS 1.15.1 (git hash: 04024d701f): Copyright (c) 2026 under MIT licence terms Includes third-party software components, see THIRD_PARTY_NOTICES.md for full details Using BLAS: blastrampoline LP has 16 rows; 5 cols; 18 nonzeros Coefficient ranges: Matrix [1e+00, 2e+01] Cost [1e+00, 1e+01] Bound [0e+00, 0e+00] RHS [1e+01, 1e+02] Presolving model 0 rows, 0 cols, 0 nonzeros 0s 0 rows, 0 cols, 0 nonzeros 0s Presolve reductions: rows 0(-16); columns 0(-5); nonzeros 0(-18) - Reduced to empty Performed postsolve Solving the original LP from the solution after postsolve Model status : Optimal Objective value : 1.2000000000e+01 P-D objective error : 0.0000000000e+00 HiGHS run time : 0.02 LP has 16 rows; 5 cols; 18 nonzeros Coefficient ranges: Matrix [1e+00, 4e+00] Cost [1e+00, 1e+00] Bound [0e+00, 0e+00] RHS [1e+00, 1e+02] Solving LP with useful basis so presolve not used Model status : Optimal Objective value : 2.0000000000e+00 P-D objective error : 0.0000000000e+00 HiGHS run time : 0.00 Running HiGHS 1.15.1 (git hash: 04024d701f): Copyright (c) 2026 under MIT licence terms Includes third-party software components, see THIRD_PARTY_NOTICES.md for full details Using BLAS: blastrampoline LP has 1 row; 1 col; 1 nonzero Coefficient ranges: Matrix [1e+00, 1e+00] Cost [1e+00, 1e+00] Bound [0e+00, 0e+00] RHS [2e+01, 4e+01] Presolving model 0 rows, 0 cols, 0 nonzeros 0s 0 rows, 0 cols, 0 nonzeros 0s Presolve reductions: rows 0(-1); columns 0(-1); nonzeros 0(-1) - Reduced to empty Performed postsolve Solving the original LP from the solution after postsolve Model status : Optimal Objective value : 2.0000000000e+01 P-D objective error : 0.0000000000e+00 HiGHS run time : 0.00 LP has 1 row; 1 col; 1 nonzero Coefficient ranges: Matrix [1e+00, 1e+00] Cost [1e+00, 1e+00] Bound [0e+00, 0e+00] RHS [4e+00, 8e+00] Solving LP with useful basis so presolve not used Model status : Optimal Objective value : 4.0000000000e+00 P-D objective error : 0.0000000000e+00 HiGHS run time : 0.00 LP has 1 row; 1 col; 1 nonzero Coefficient ranges: Matrix [1e+00, 1e+00] Cost [1e+00, 1e+00] Bound [0e+00, 0e+00] RHS [4e+00, 8e+00] Solving LP with useful basis so presolve not used Using dual simplex solver Iteration Objective Infeasibilities num(sum) 0 0.0000000000e+00 Ph1: 0(0) 0.0s 0 -8.0000000000e+00 Pr: 0(0) 0.0s Model status : Optimal Objective value : -8.0000000000e+00 P-D objective error : 0.0000000000e+00 HiGHS run time : 0.00 examples: Error During Test at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:56 Got exception outside of a @test LoadError: UndefVarError: `python` not defined in `SpineInterface` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:956 [2] eval(m::Module, e::Any) @ Core boot.jl:545 [3] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [4] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [5] _db(f::SpineInterface.var"#196#197"{Dict{Symbol, Vector{String}}, String}, url::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:929 [6] import_data(url::String, data::Dict{Symbol, Vector{String}}, comment::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:854 [inlined] [7] import_data(url::String, comment::String; upgrade::Bool, kwargs::@Kwargs{object_classes::Vector{String}}) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:851 [inlined] [8] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/examples/tutorial_spine_database/tutorial_spine_database.jl:16 [9] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [10] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [11] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [12] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:57 [inlined] [13] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [14] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:57 [inlined] [15] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [16] top-level scope @ none:6 [17] eval(m::Module, e::Any) @ Core boot.jl:545 [18] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [19] _start() @ Base client.jl:596 in expression starting at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/examples/tutorial_spine_database/tutorial_spine_database.jl:16 caused by: PyError (PyImport_ImportModule The Python package spinedb_api could not be imported by pyimport. Usually this means that you did not install spinedb_api in the Python version being used by PyCall. PyCall is currently configured to use the Julia-specific Python distribution installed by the Conda.jl package. To install the spinedb_api module, you can use `pyimport_conda("spinedb_api", PKG)`, where PKG is the Anaconda package that contains the module spinedb_api, or alternatively you can use the Conda package directly (via `using Conda` followed by `Conda.add` etcetera). Alternatively, if you want to use a different Python distribution on your system, such as a system-wide Python (as opposed to the Julia-specific Python), you can re-configure PyCall with that Python. As explained in the PyCall documentation, set ENV["PYTHON"] to the path/name of the python executable you want to use, run Pkg.build("PyCall"), and re-launch Julia. ) ModuleNotFoundError("No module named 'spinedb_api'") Stacktrace: [1] pyimport(name::String) @ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558 [2] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:951 [3] eval(m::Module, e::Any) @ Core boot.jl:545 [4] _import_spinedb_api() @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:948 [5] _create_db_handler(db_url::String, upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:939 [inlined] [6] _db(f::SpineInterface.var"#196#197"{Dict{Symbol, Vector{String}}, String}, url::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:929 [7] import_data(url::String, data::Dict{Symbol, Vector{String}}, comment::String; upgrade::Bool) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:854 [inlined] [8] import_data(url::String, comment::String; upgrade::Bool, kwargs::@Kwargs{object_classes::Vector{String}}) @ SpineInterface ~/.julia/packages/SpineInterface/0BM0R/src/api/db.jl:851 [inlined] [9] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/examples/tutorial_spine_database/tutorial_spine_database.jl:16 [10] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [11] top-level scope @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:50 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:57 [inlined] [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:57 [inlined] [16] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:326 [17] top-level scope @ none:6 [18] eval(m::Module, e::Any) @ Core boot.jl:545 [19] exec_options(opts::Base.JLOptions) @ Base client.jl:321 [20] _start() @ Base client.jl:596 Test Summary: | Pass Error Total Time test set | 430 34 464 8m08.7s using_spinedb - basics | 3 3 33.2s object_class | 1 1 8.1s relationship_class | 1 1 0.1s parameter | 1 1 0.3s using_spinedb - parameter value types | 1 1 1.5s using_spinedb - advanced | 5 5 10.3s using_spinedb_in_a_loop | 1 1 0.1s using_spinedb_extend | 1 1 0.1s using_spinedb_with_env | 1 1 0.1s using_spinedb_with_module | 1 1 0.2s add_binding_type_mismatch | 1 1 0.1s api | 90 24 114 3m08.2s indices | 1 1 0.1s indices as tuples | 1 1 0.0s object_class, relationship_class, parameter | 1 1 0.0s time-slices | 17 17 2.2s add_objects | 1 1 0.0s add_relationships | 1 1 0.0s parse_db_value | 9 9 16.6s add_object_parameter_values | 1 1 0.0s add_relationship_parameter_values | 1 1 0.1s write_parameters | 1 7 8 8.8s int & string | 1 1 2.7s date_time & duration | 1 1 2.8s array | 1 1 0.2s time_pattern | 1 1 2 2.7s time_series | 1 1 0.1s repeating time_series | 1 1 0.3s with report | 1 1 0.0s Call | 5 5 3.0s maximum_parameter_value | 1 1 0.1s import_data | 1 1 0.0s difference | 1 1 0.0s indexed_values | 1 1 0.1s Bind | 12 12 0.1s write_interface | 40 40 2.4s superclasses | 1 1 0.1s writing_superclasses | 1 1 0.1s manipulating_superclasses | 1 1 0.1s reorder_dimensions | 1 1 0.1s add_dimension! | 1 1 0.1s parse_db! | 1 1 0.1s constructors | 16 16 10.6s base | 225 225 1m12.3s TimePattern-TimePattern arithmetic | 2 2 1.1s object_class_to_dict | 5 5 6.0s relationship_class_to_dict | 7 7 4.0s update_model | 85 85 2m21.9s examples | 1 1 1.2s RNG of the outermost testset: Random.Xoshiro(0xea894a13cbad05e9, 0xeaec712e8fc90840, 0x04372ad1a72f2c11, 0xa5c58b950004775b, 0x48c944cabf133e7b) ERROR: LoadError: Some tests did not pass: 430 passed, 0 failed, 34 errored, 0 broken. in expression starting at /home/pkgeval/.julia/packages/SpineInterface/0BM0R/test/runtests.jl:49 Testing failed after 534.37s ERROR: LoadError: Package SpineInterface errored during testing Stacktrace: [1] pkgerror(msg::String) @ Pkg.Types /opt/julia/share/julia/stdlib/v1.14/Pkg/src/Types.jl:68 [2] test(ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}; coverage::Bool, julia_args::Cmd, test_args::Cmd, test_fn::Nothing, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool) @ Pkg.Operations /opt/julia/share/julia/stdlib/v1.14/Pkg/src/Operations.jl:3247 [3] test(ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}; coverage::Bool, test_fn::Nothing, julia_args::Cmd, test_args::Cmd, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool, kwargs::@Kwargs{io::IOContext{IO}}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:587 [4] test(pkgs::Vector{PackageSpec}; io::IOContext{IO}, kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:172 [5] test(pkgs::Vector{String}; kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:160 [6] test(pkg::String; kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:159 [inlined] [7] top-level scope @ /PkgEval.jl/scripts/evaluate.jl:223 [8] include(mod::Module, _path::String) @ Base Base.jl:325 [9] exec_options(opts::Base.JLOptions) @ Base client.jl:355 [10] _start() @ Base client.jl:596 in expression starting at /PkgEval.jl/scripts/evaluate.jl:214 PkgEval failed after 942.98s: package tests unexpectedly errored