jneqsim 3.2.0__tar.gz

jneqsim-3.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Equinor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

jneqsim-3.2.0/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: jneqsim
+Version: 3.2.0
+Summary: Python bindings for the Java library NeqSim (via JPype), with python stubs
+License: Apache-2.0
+License-File: LICENSE
+Keywords: neqsim
+Author: Jørgen
+Author-email: jenge@equinor.com
+Maintainer: Mathias
+Maintainer-email: maohe@equinor.com
+Requires-Python: >=3.9,<4.0
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: JPype1 (>=1.5.0,<2.0.0)
+Requires-Dist: PyYAML (>=6.0,<7.0)
+Project-URL: Homepage, https://github.com/equinor/jneqsim
+Project-URL: Repository, https://github.com/equinor/jneqsim
+Description-Content-Type: text/markdown
+
+# jNeqSim
+
+[![PyPI version](https://img.shields.io/pypi/v/jneqsim.svg)](https://pypi.org/project/jneqsim/)
+[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+
+Python interface for the [NeqSim java package](https://equinor.github.io/neqsimhome/), with stubs. Java interface is created with [jpype](https://jpype.readthedocs.io/en/latest/index.html#), and stubs are generated with [stubgenj](https://gitlab.cern.ch/scripting-tools/stubgenj)
+
+
+## PYPI
+
+[https://pypi.org/project/jneqsim/](https://pypi.org/project/jneqsim/)
+> [!NOTE]
+> JNeqSim mirrors NeqSims versions
+
+## Demo
+
+![demo.gif](docs/demo.gif)
+
+
+## Example
+
+```python
+from jneqsim import neqsim
+
+
+def pressurize_gas():
+    inlet_fluid = neqsim.thermo.system.SystemSrkEos()
+    neqsim.thermo.system.SystemSrkEos()
+    thermo_ops = neqsim.thermodynamicOperations.ThermodynamicOperations(inlet_fluid)
+    inlet_fluid.addComponent("methane", 100.0)
+
+    inlet_fluid.setTemperature(10, "C")
+    inlet_fluid.setPressure(20, "bara")
+    inlet_fluid.setMultiPhaseCheck(True)
+    inlet_fluid.setSolidPhaseCheck("methane")
+
+    thermo_ops.TPflash()
+    thermo_ops.bubblePointTemperatureFlash()
+
+    inlet_fluid.initProperties()
+    enthalpy = inlet_fluid.getEnthalpy()
+
+    inlet_fluid.setPressure(1.0, "bara")
+    thermo_ops.PHflash(enthalpy)
+```
+
+## Dependencies
+
+- [jpype](https://jpype.readthedocs.io/en/latest/index.html#)
+
+## Version Management
+
+jneqsim uses a controlled release process to ensure compatibility:
+
+- **Pinned Versions**: Each jneqsim release is pinned to a specific, tested NeqSim JAR version
+- **Automated Updates**: The nightly CI workflow automatically checks for new NeqSim releases and publishes updated jneqsim packages when available
+- **No Auto-Updates**: Applications using jneqsim will not automatically download newer NeqSim versions - they use the tested version that comes with their installed jneqsim package
+- **Cache Management**: Downloaded JARs are cached locally in `~/.jneqsim/cache` for faster subsequent usage
+
+## Development
+
+### Running Tests
+
+The project uses pytest with custom markers to categorize tests. Test dependencies are already included in the development dependencies.
+
+```bash
+# Install development dependencies (includes pytest and pytest-mock)
+poetry install
+
+# Run unit tests (fast, excludes tests marked as slow)
+pytest -v -m "not slow" tests/
+
+# Run all tests (may download JARs for integration tests)
+pytest -v tests/
+
+# Run with coverage (requires pytest-cov)
+poetry add --group dev pytest-cov
+poetry run pytest --cov=jneqsim --cov-report=html tests/
+```
+
+**Test markers:**
+- `slow`: Tests that may download files or take longer to run
+- `integration`: Integration tests that require external dependencies
+- `unit`: Fast unit tests (default)
+
+
+<a id="Contributing"></a>
+
+## :+1: Contributing
+
+Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
+
+Please make sure to update tests as appropriate.
+

jneqsim-3.2.0/README.md

@@ -0,0 +1,94 @@
+# jNeqSim
+
+[![PyPI version](https://img.shields.io/pypi/v/jneqsim.svg)](https://pypi.org/project/jneqsim/)
+[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+
+Python interface for the [NeqSim java package](https://equinor.github.io/neqsimhome/), with stubs. Java interface is created with [jpype](https://jpype.readthedocs.io/en/latest/index.html#), and stubs are generated with [stubgenj](https://gitlab.cern.ch/scripting-tools/stubgenj)
+
+
+## PYPI
+
+[https://pypi.org/project/jneqsim/](https://pypi.org/project/jneqsim/)
+> [!NOTE]
+> JNeqSim mirrors NeqSims versions
+
+## Demo
+
+![demo.gif](docs/demo.gif)
+
+
+## Example
+
+```python
+from jneqsim import neqsim
+
+
+def pressurize_gas():
+    inlet_fluid = neqsim.thermo.system.SystemSrkEos()
+    neqsim.thermo.system.SystemSrkEos()
+    thermo_ops = neqsim.thermodynamicOperations.ThermodynamicOperations(inlet_fluid)
+    inlet_fluid.addComponent("methane", 100.0)
+
+    inlet_fluid.setTemperature(10, "C")
+    inlet_fluid.setPressure(20, "bara")
+    inlet_fluid.setMultiPhaseCheck(True)
+    inlet_fluid.setSolidPhaseCheck("methane")
+
+    thermo_ops.TPflash()
+    thermo_ops.bubblePointTemperatureFlash()
+
+    inlet_fluid.initProperties()
+    enthalpy = inlet_fluid.getEnthalpy()
+
+    inlet_fluid.setPressure(1.0, "bara")
+    thermo_ops.PHflash(enthalpy)
+```
+
+## Dependencies
+
+- [jpype](https://jpype.readthedocs.io/en/latest/index.html#)
+
+## Version Management
+
+jneqsim uses a controlled release process to ensure compatibility:
+
+- **Pinned Versions**: Each jneqsim release is pinned to a specific, tested NeqSim JAR version
+- **Automated Updates**: The nightly CI workflow automatically checks for new NeqSim releases and publishes updated jneqsim packages when available
+- **No Auto-Updates**: Applications using jneqsim will not automatically download newer NeqSim versions - they use the tested version that comes with their installed jneqsim package
+- **Cache Management**: Downloaded JARs are cached locally in `~/.jneqsim/cache` for faster subsequent usage
+
+## Development
+
+### Running Tests
+
+The project uses pytest with custom markers to categorize tests. Test dependencies are already included in the development dependencies.
+
+```bash
+# Install development dependencies (includes pytest and pytest-mock)
+poetry install
+
+# Run unit tests (fast, excludes tests marked as slow)
+pytest -v -m "not slow" tests/
+
+# Run all tests (may download JARs for integration tests)
+pytest -v tests/
+
+# Run with coverage (requires pytest-cov)
+poetry add --group dev pytest-cov
+poetry run pytest --cov=jneqsim --cov-report=html tests/
+```
+
+**Test markers:**
+- `slow`: Tests that may download files or take longer to run
+- `integration`: Integration tests that require external dependencies
+- `unit`: Fast unit tests (default)
+
+
+<a id="Contributing"></a>
+
+## :+1: Contributing
+
+Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
+
+Please make sure to update tests as appropriate.

jneqsim-3.2.0/jneqsim/__init__.py

@@ -0,0 +1,3 @@
+from jneqsim.jvm_service import neqsim
+
+__all__ = ["neqsim"]

jneqsim-3.2.0/jneqsim/__init__.pyi

@@ -0,0 +1 @@
+from jneqsim.neqsim import *  # noqa: F403

jneqsim-3.2.0/jneqsim/common/config.yaml

@@ -0,0 +1,36 @@
+# NeqSim Dependency Configuration
+# This file defines how to resolve NeqSim Java dependencies
+
+neqsim:
+  # Version to use (specific version that has been tested with this jneqsim release)
+  # This version is automatically updated by the CI/CD pipeline when a new NeqSim release is published
+  version: "3.2.0"
+
+  # Fallback version when GitHub API is unavailable (rate limited, network issues)
+  # This should be the previous tested version, providing a safety fallback mechanism
+  # The CI/CD pipeline automatically sets this to the previous version when updating
+  fallback_version: "3.0.43"
+
+  # GitHub Releases source
+  sources:
+    github:
+      enabled: true
+      repository: "equinor/neqsim"
+      base_url: "https://github.com/equinor/neqsim/releases/download"
+      # JAR file patterns for different Java versions
+      # Note: The code will try multiple naming patterns per Java version
+      # (e.g., Java21-Java21, Java21) to handle variations
+      assets:
+        java8: "neqsim-{version}-Java8.jar"
+        java11: "neqsim-{version}.jar" # Java 11+ version
+        java21: "neqsim-{version}-Java21.jar"
+
+# Logging configuration
+logging:
+  level: "WARNING" # DEBUG, INFO, WARNING, ERROR
+  show_progress: true
+
+# Cache stores one JAR file per version/Java version combination
+cache:
+  enabled: true
+  verify_integrity: true

jneqsim-3.2.0/jneqsim/common/load_config.py

@@ -0,0 +1,9 @@
+from pathlib import Path
+
+import yaml
+
+
+def load_config(config_path: Path) -> dict:
+    """Load configuration from YAML file"""
+    with open(config_path) as f:
+        return yaml.safe_load(f)

jneqsim-3.2.0/jneqsim/common/setup_logging.py

@@ -0,0 +1,16 @@
+import logging
+
+
+def setup_logging(config: dict) -> logging.Logger:
+    """Setup logging based on configuration"""
+    logger = logging.getLogger(__name__)
+    level = getattr(logging, config["logging"]["level"])
+    logger.setLevel(level)
+
+    if not logger.handlers:
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+
+    return logger

jneqsim-3.2.0/jneqsim/dependency_manager.py

@@ -0,0 +1,184 @@
+import logging
+import tempfile
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Optional
+
+from .jar_cache import JARCacheManager
+
+
+class NeqSimDependencyManager:
+    """Manages NeqSim JAR dependencies from GitHub releases"""
+
+    def __init__(
+        self, logger: logging.Logger | None = None, config: dict | None = None, cache_dir: Optional[Path] = None
+    ):
+        """Initialize Neqsim Dependency Manager
+
+        Args:
+            logger (logging.Logger | None): Logger instance for logging or None
+            config (dict | None): Configuration dictionary (from yaml) or None
+            cache_dir (Optional[Path], optional): Directory for caching JAR versions, defaults to ~/.jneqsim/cache
+        """
+        if cache_dir is None:
+            cache_dir = Path.home() / ".jneqsim" / "cache"
+
+        self.cache_dir = cache_dir
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+        if config is None:
+            from jneqsim.common.load_config import load_config
+
+            config_path = Path(__file__).parent / "common" / "config.yaml"
+            config = load_config(config_path)
+        self.config = config
+        if logger is None:
+            from jneqsim.common.setup_logging import setup_logging
+
+            logger = setup_logging(self.config)
+        self.logger = logger
+
+        # Initialize cache manager
+        self.cache_manager = JARCacheManager(self.cache_dir, self.config, self.logger)
+
+    def _get_jar_patterns(self, java_version: int) -> list[str]:
+        """Get list of JAR filename patterns to try for a given Java version.
+
+        Returns patterns in order of preference, with newer patterns first.
+        Some releases use varying naming patterns (e.g., Java21-Java21 vs Java21).
+        """
+        github_config = self.config["neqsim"]["sources"]["github"]
+
+        if java_version == 8:
+            return [
+                "neqsim-{version}-Java8-Java8.jar",  # Newer pattern
+                github_config["assets"]["java8"],  # Standard pattern
+            ]
+        elif 11 <= java_version < 21:
+            return [
+                "neqsim-{version}.jar",  # Standard pattern
+            ]
+        elif java_version >= 21:
+            return [
+                "neqsim-{version}-Java21-Java21.jar",  # Newer pattern
+                github_config["assets"]["java21"],  # Standard pattern
+            ]
+        else:
+            raise ValueError(f"Unsupported Java version: {java_version}")
+
+    def _get_jar_from_github(self, version: str, java_version: int) -> Path:
+        """Download JAR from GitHub releases with fallback support and caching"""
+        github_config = self.config["neqsim"]["sources"]["github"]
+
+        # Check cache first
+        cached_jar = self.cache_manager.get_cached_jar(version, java_version)
+        if cached_jar:
+            return cached_jar
+
+        patterns_to_try = self._get_jar_patterns(java_version)
+
+        # Try each pattern until one succeeds
+        final_error = None
+        for i, asset_pattern in enumerate(patterns_to_try):
+            jar_filename = asset_pattern.format(version=version)
+            url = f"{github_config['base_url']}/v{version}/{jar_filename}"
+
+            # Create temporary directory for download
+            with tempfile.TemporaryDirectory(prefix="jneqsim_") as temp_dir_str:
+                temp_dir = Path(temp_dir_str)
+                downloaded_jar = temp_dir / jar_filename
+
+                try:
+                    is_fallback = i > 0
+                    if self.config["logging"]["show_progress"]:
+                        if is_fallback:
+                            self.logger.info(f"Trying fallback: {jar_filename} for Java {java_version}...")
+                        else:
+                            self.logger.info(f"Downloading {jar_filename} for Java {java_version}...")
+
+                    with urllib.request.urlopen(url) as response:  # noqa: S310
+                        content = response.read()
+
+                    downloaded_jar.write_bytes(content)
+
+                    if is_fallback:
+                        self.logger.warning(
+                            f"Using fallback JAR '{jar_filename}' for Java {java_version}. "
+                            f"Java {java_version}-specific version not available."
+                        )
+                    else:
+                        self.logger.info(f"Downloaded from GitHub: {downloaded_jar.name}")
+
+                    # Cache the downloaded JAR
+                    try:
+                        cached_jar = self.cache_manager.cache_jar(downloaded_jar, version, java_version)
+                    except Exception as cache_exc:
+                        final_error = cache_exc
+                        self.logger.error(f"Failed to cache downloaded JAR: {cache_exc}")
+                        # Try fallback if available
+                        continue
+                    return cached_jar
+
+                except urllib.error.HTTPError as e:
+                    if e.code == 404:
+                        final_error = e
+                        self.logger.debug(f"JAR not found: {jar_filename} (trying fallback...)")
+                        continue  # Try next pattern
+                    else:
+                        # For other HTTP errors, fail immediately
+                        self.logger.error(f"HTTP error downloading from GitHub: {e}")
+                        raise RuntimeError(f"Could not download NeqSim from GitHub: {e}") from e
+                except Exception as e:
+                    final_error = e
+                    self.logger.error(f"Failed to download from GitHub: {e}")
+                    # For non-HTTP errors, try fallback
+                    continue
+
+        error_msg = (
+            f"Could not download NeqSim from GitHub for Java {java_version}: {final_error} \n"
+            f"Tried patterns: {patterns_to_try}"
+        )
+        self.logger.error(error_msg)
+        raise RuntimeError(error_msg) from final_error
+
+    def resolve_dependency(self, java_version: int | None = None) -> Path:
+        """
+        Resolve NeqSim dependency
+
+        Args:
+            java_version: Java version, auto-detected if None
+
+        Returns:
+            Path to resolved JAR file
+        """
+        neqsim_version = self.config["neqsim"]["version"]
+        if neqsim_version is None:
+            raise ValueError("NeqSim version must be specified in config.yaml")
+
+        java_version = self._resolve_java_version(java_version)
+
+        # Download dependency
+        jar_path = self._get_jar_from_github(neqsim_version, java_version)
+
+        return jar_path
+
+    def _resolve_java_version(self, java_version: int | None) -> int:
+        """Resolve the Java version to use"""
+        if java_version is not None:
+            return java_version
+
+        try:
+            import jpype
+
+            if jpype.isJVMStarted():
+                return jpype.getJVMVersion()[0]
+            else:
+                raise RuntimeError("JVM is not started; cannot auto-detect Java version")
+        except ImportError:
+            raise RuntimeError("JPype is not available; cannot auto-detect Java version") from None
+
+    @property
+    def jar_cache_dir(self) -> Path:
+        """Access to JAR cache directory for backward compatibility"""
+        return self.cache_manager.jar_cache_dir

jneqsim-3.2.0/jneqsim/jar_cache.py

@@ -0,0 +1,115 @@
+import logging
+import os
+import shutil
+import tempfile
+import zipfile
+from pathlib import Path
+from typing import Optional
+
+
+class JARCacheManager:
+    """Simplified JAR cache manager that caches one JAR per version/java_version combination"""
+
+    def __init__(self, cache_dir: Path, config: dict, logger: logging.Logger):
+        """
+        Initialize cache manager
+
+        Args:
+            cache_dir: Base cache directory
+            config: Configuration dictionary
+            logger: Logger instance
+        """
+        self.cache_dir = cache_dir
+        self.jar_cache_dir = cache_dir / "jars"
+        self.jar_cache_dir.mkdir(parents=True, exist_ok=True)
+        self.config = config
+        self.logger = logger
+
+    def _get_cache_filename(self, version: str, java_version: int) -> str:
+        """Generate simple cache filename for version and Java version combination"""
+        return f"neqsim-{version}-java{java_version}.jar"
+
+    def get_cached_jar(self, version: str, java_version: int) -> Optional[Path]:
+        """Check if JAR exists in cache for the specified version and Java version"""
+        if not self.config.get("cache", {}).get("enabled", True):
+            return None
+
+        cache_filename = self._get_cache_filename(version, java_version)
+        cached_jar = self.jar_cache_dir / cache_filename
+
+        if not cached_jar.exists():
+            self.logger.debug(f"No cached JAR found for version {version}, Java {java_version}")
+            return None
+
+        # Verify integrity if enabled
+        if self.config.get("cache", {}).get("verify_integrity", True):
+            if not self._verify_jar_integrity(cached_jar):
+                self.logger.warning(f"Cached JAR failed integrity check, removing: {cached_jar.name}")
+                cached_jar.unlink()  # Remove corrupted cache
+                return None
+
+        self.logger.info(f"Using cached JAR: {cached_jar.name}")
+        return cached_jar
+
+    def cache_jar(self, source_jar: Path, version: str, java_version: int) -> Path:
+        """Cache downloaded JAR file, replacing any existing cached version"""
+        if not self.config.get("cache", {}).get("enabled", True):
+            return source_jar
+
+        cache_filename = self._get_cache_filename(version, java_version)
+        cached_jar = self.jar_cache_dir / cache_filename
+
+        tmp_path = None
+        try:
+            # Create a temp file in the same directory to ensure atomic rename
+            file_descriptor, tmp_file_name = tempfile.mkstemp(prefix=cache_filename + ".", dir=str(self.jar_cache_dir))
+            os.close(file_descriptor)
+            tmp_path = Path(tmp_file_name)
+
+            shutil.copy2(source_jar, tmp_path)
+
+            # Verify the temporary JAR file before replacing
+            if not self._verify_jar_integrity(tmp_path):
+                self.logger.error(f"Downloaded JAR failed integrity check: {tmp_path}")
+                try:
+                    tmp_path.unlink()
+                except Exception as e:
+                    self.logger.error(f"Failed to unlink temporary file: {e}")
+                raise RuntimeError("Downloaded JAR failed integrity check")
+
+            # Replace the cached JAR atomically
+            try:
+                tmp_path.replace(cached_jar)
+                self.logger.debug(f"Replaced cached JAR: {cache_filename}")
+            except Exception as e:
+                self.logger.error(f"Failed to replace cached JAR: {e}")
+                try:
+                    tmp_path.unlink()
+                except Exception as e:
+                    self.logger.error(f"Failed to unlink temporary file: {e}")
+                raise
+
+            self.logger.info(f"Cached JAR: {cached_jar.name}")
+            return cached_jar
+        finally:
+            try:
+                if tmp_path is not None and tmp_path.exists():
+                    tmp_path.unlink()
+            except Exception as e:
+                self.logger.error(f"Failed to unlink temporary file during cleanup: {e}")
+
+    def _verify_jar_integrity(self, jar_path: Path) -> bool:
+        """Verify JAR file is not corrupted"""
+        try:
+            # Basic checks: file exists, has content, ends with proper extension
+            if not jar_path.exists() or jar_path.stat().st_size == 0:
+                return False
+
+            # Check if it's a valid ZIP file (JARs are ZIP files)
+            with zipfile.ZipFile(jar_path, "r") as zf:
+                # Try to read the file list - this will fail if corrupted
+                zf.namelist()
+                return True
+        except Exception as e:
+            self.logger.debug(f"JAR integrity check failed for {jar_path}: {e}")
+            return False

jneqsim-3.2.0/jneqsim/jvm_service.py

@@ -0,0 +1,68 @@
+try:
+    import jpype
+
+    JPYPE_AVAILABLE = True
+except ImportError:
+    JPYPE_AVAILABLE = False
+    jpype = None
+
+import logging
+from pathlib import Path
+
+from jneqsim.common.load_config import load_config
+from jneqsim.common.setup_logging import setup_logging
+
+from .dependency_manager import NeqSimDependencyManager
+
+
+def get_neqsim_jar_path(java_version: tuple[int, ...], logger: logging.Logger, config: dict) -> str:
+    """
+    Get NeqSim JAR path using enhanced dependency resolution
+
+    Args:
+        java_version: JVM version tuple (major, minor, patch)
+
+    Returns:
+        Path to NeqSim JAR file
+
+    Raises:
+        RuntimeError: If dependency resolution fails
+    """
+    try:
+        manager = NeqSimDependencyManager(logger, config)
+        jar_path = manager.resolve_dependency(java_version=java_version[0])
+        return str(jar_path)
+    except Exception as e:
+        raise RuntimeError(
+            f"Failed to resolve NeqSim dependency for Java {'.'.join(map(str, java_version))}: {e}"
+        ) from e
+
+
+# Load configuration and setup logging
+config_path = Path(__file__).parent / "common" / "config.yaml"
+config = load_config(config_path)
+logger = setup_logging(config)
+
+# Initialize JVM and NeqSim package
+neqsim = None  # Default to None, cannot use NeqSim if JVM fails to start
+
+if JPYPE_AVAILABLE and jpype and not jpype.isJVMStarted():
+    # We need to start the JVM before importing the neqsim package
+    try:
+        jpype.startJVM()
+        jar_path = get_neqsim_jar_path(jpype.getJVMVersion(), logger, config)
+        jpype.addClassPath(jar_path)
+
+        import jpype.imports
+
+        # This is the java package, added to the python scope by "jpype.imports"
+        neqsim = jpype.JPackage("neqsim")
+    except Exception as e:
+        # JVM Start failed, handle gracefully
+
+        logger.error(f"Failed to initialize JVM: {e}. NeqSim functionality will not be available.", stacklevel=2)
+elif JPYPE_AVAILABLE and jpype and jpype.isJVMStarted():
+    # JVM already started, just get the package
+    import jpype.imports
+
+    neqsim = jpype.JPackage("neqsim")