fargopy 0.4.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

fargopy/sys.py

@@ -17,52 +17,67 @@ from select import select
 # Classes
 ###############################################################
 
-#/////////////////////////////////////
+
+# /////////////////////////////////////
 # UTIL CLASS
-#/////////////////////////////////////
+# /////////////////////////////////////
 class Sys(object):
+    """System utilities for command execution, directory locking, and resource monitoring.
+
+    The ``Sys`` class provides a collection of static methods to interact with
+    the operating system. It handles shell command execution with output capturing,
+    directory locking mechanisms for concurrent safety, and system pause functionalities.
+    """
 
     QERROR = True
-    STDERR = ''
-    STDOUT = ''
-    OUT = ''
+    STDERR = ""
+    STDOUT = ""
+    OUT = ""
 
     @staticmethod
-    def run(cmd,quiet=True):
-        """Run a system command
-        
-        Parameters:
-            cmd: string:
-                Command to run
-            quiet: boolean, default = True:
-                When False the output of the command is shown.
-            
-        Output:
-            error: integer:
-                Error code (0,-1,>0)
-
-            output: list:
-                List with output. 
-                If error == 0, output[:-1] will contain 
-                the output line by line.
+    def run(cmd, quiet=True):
+        """Run a system shell command.
+
+        Executes a command string in the shell and captures its stdout and stderr.
+        Useful for running FARGO3D executables or other system tools.
+
+        Parameters
+        ----------
+        cmd : str
+            The command string to execute.
+        quiet : bool, optional
+            If True, suppress printing output to stdout (default: True).
+
+        Returns
+        -------
+        tuple
+            (error_code, output_list)
+            - error_code (int): 0 for success, non-zero for error.
+            - output_list (list): List of output lines (strings).
+
+        Examples
+        --------
+        Run a simple shell command:
+
+        >>> err, out = fp.Sys.run("ls -l")
         """
         fargopy.Debug.trace(f"sysrun::cmd = {cmd}")
 
-        out=[]
+        out = []
         for path in Sys._run(cmd):
             try:
                 if not quiet:
-                    print(path.decode('utf-8'))
-                out += [path.decode('utf-8')]
+                    print(path.decode("utf-8"))
+                out += [path.decode("utf-8")]
             except:
-                out += [(path[0],path[1].decode('utf-8'))]
-        
-        Sys.STDOUT = ''
-        if len(out)>1:
-            Sys.STDOUT = '\n'.join(out[:-1])
-        
+                out += [(path[0], path[1].decode("utf-8"))]
+
+        Sys.STDOUT = ""
+        if len(out) > 1:
+            Sys.STDOUT = "\n".join(out[:-1])
+
         Sys.STDERR = out[-1][1]
-        if len(Sys.STDERR)>0:
+        if len(Sys.STDERR) > 0:
             Sys.QERROR = out[-1][0]
             if Sys.QERROR == 0:
                 Sys.QERROR = -1
@@ -74,30 +89,36 @@ class Sys(object):
 
         if fargopy.Debug.VERBOSE:
             error = out[-1][0]
-            if Sys.QERROR>0:
+            if Sys.QERROR > 0:
                 fargopy.Debug.trace(f"sysrun::Error check Sys.STDERR.")
-            elif Sys.QERROR<0:
-                fargopy.Debug.trace(f"sysrun::Done. Still some issues must be check. Check Sys.STDOUT and Sys.STDERR for details.")
-            elif Sys.QERROR==0:
-                fargopy.Debug.trace(f"sysrun::Done. You're great. Check Sys.STDOUT for details.")
-        
+            elif Sys.QERROR < 0:
+                fargopy.Debug.trace(
+                    f"sysrun::Done. Still some issues must be check. Check Sys.STDOUT and Sys.STDERR for details."
+                )
+            elif Sys.QERROR == 0:
+                fargopy.Debug.trace(
+                    f"sysrun::Done. You're great. Check Sys.STDOUT for details."
+                )
+
         Sys.OUT = out
-        return Sys.QERROR,out
+        return Sys.QERROR, out
 
     @staticmethod
     def _run(cmd):
-        p=subprocess.Popen(cmd,stdout=subprocess.PIPE,stderr=subprocess.PIPE,shell=True)
+        p = subprocess.Popen(
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True
+        )
         while True:
             line = p.stdout.readline().rstrip()
             if not line:
                 break
             yield line
-        (output,error)=p.communicate()
-        yield p.returncode,error
+        (output, error) = p.communicate()
+        yield p.returncode, error
 
     @staticmethod
     def simple(cmd):
-        return os.system(cmd)
+        return subprocess.call(cmd, shell=True)
 
     @staticmethod
     def get_memory():
@@ -105,21 +126,38 @@ class Sys(object):
         return svmem
 
     @staticmethod
-    def lock(dir,content=dict()):
-        """Lock a directory using content information
+    def lock(dir, content=dict()):
+        """Create a lock file in a directory.
+
+        Creates a ``fargopy.lock`` file containing the provided content to
+        signal that the directory is in use or processing.
+
+        Parameters
+        ----------
+        dir : str
+            Path to the directory to lock.
+        content : dict, optional
+            Dictionary of metadata to store in the lock file.
         """
         if not os.path.isdir(dir):
             print(f"Locking directory '{dir}' not found.")
             return
-        
+
         filename = f"{dir}/fargopy.lock"
-        with open(filename,'w') as file_object:
-            file_object.write(json.dumps(content,default=lambda obj:'<not serializable>'))
+        with open(filename, "w") as file_object:
+            file_object.write(
+                json.dumps(content, default=lambda obj: "<not serializable>")
+            )
             file_object.close()
 
     @staticmethod
     def unlock(dir):
-        """UnLock a directory
+        """Remove the lock file from a directory.
+
+        Parameters
+        ----------
+        dir : str
+            Path to the directory to unlock.
         """
         if not os.path.isdir(dir):
             print(f"Locking directory '{dir}' not found.")
@@ -127,9 +165,9 @@ class Sys(object):
         filename = f"{dir}/fargopy.lock"
         if os.path.isfile(filename):
             fargopy.Sys.simple(f"rm -rf {filename}")
-    
+
     @staticmethod
-    def is_locked(dir,verbose=False):
+    def is_locked(dir, verbose=False):
         if not os.path.isdir(dir):
             if verbose:
                 print(f"Locking directory '{dir}' not found.")
@@ -141,21 +179,34 @@ class Sys(object):
             with open(filename) as file_handler:
                 info = json.load(file_handler)
                 return info
-            
-    @staticmethod
-    def sleep_timeout(timeout=5,msg=None):
-        """This routine sleeps for a 'time'. In the meanwhile checks if there is a keyboard interrupt 
-        (Enter or Ctrl+C) and interrupt sleeping
 
-        Examples:
-            >>> Sys.sleep_timeout()
-            >>> Sys.sleep_timeout(10) 
-
-            >>> for i in range(10):
-                   print(f"i = {i}")
-                   if Sys.sleep_timeout():break
+    @staticmethod
+    def sleep_timeout(timeout=5, msg=None):
+        """Sleep for a specified duration, interruptible by user input.
+
+        Sleeps for ``timeout`` seconds. Checks for keyboard interrupt (Enter or Ctrl+C)
+        during the sleep period.
+
+        Parameters
+        ----------
+        timeout : int, optional
+            Sleep duration in seconds (default: 5).
+        msg : str, optional
+            Message to display before sleeping.
+
+        Returns
+        -------
+        bool
+            True if interrupted, False if timeout completed.
+
+        Examples
+        --------
+        Sleep for 10 seconds or until user interrupt:
+
+        >>> if fp.Sys.sleep_timeout(10, "Press Enter to skip"):
+        ...     print("Skipped")
         """
-        try: 
+        try:
             if msg:
                 print(msg)
             rlist, wlist, xlist = select([sys.stdin], [], [], timeout)
@@ -165,4 +216,4 @@ class Sys(object):
                 return False
         except KeyboardInterrupt:
             print("Interrupting")
-            return True
+            return True

fargopy/tests/test_base.py

@@ -0,0 +1,8 @@
+# fargopy/tests/test___interp.py
+import os
+import numpy as np
+import pytest
+import fargopy as fp
+
+FILE = __file__
+ROOTDIR = os.path.abspath(os.path.dirname(FILE))

fargopy/tests/test_flux.py

@@ -0,0 +1,76 @@
+import os
+import numpy as np
+import pytest
+import fargopy as fp
+
+FILE = __file__
+ROOTDIR = os.path.abspath(os.path.dirname(FILE))
+
+
+@pytest.fixture(scope="session")
+def sim():
+    # Load the local test simulation only once per test session
+    fp.Simulation.download_precomputed("p3disoj")
+    return fp.Simulation(output_dir=f"/tmp/p3disoj")
+
+
+def test_sphere_tessellation_properties():
+    # basic sanity checks on sphere tessellation
+    s = fp.flux.Surface(type="sphere", radius=1.0, subdivisions=1)
+    # number of triangles for 1 subdivision: 20*(4**1) = 80
+    assert s.num_triangles == 20 * (4**1)
+    assert s.centers.shape == (s.num_triangles, 3)
+    assert s.normals.shape == (s.num_triangles, 3)
+    assert s.areas.shape == (s.num_triangles,)
+    # areas positive
+    assert np.all(s.areas > 0)
+    # normals are unit length
+    norms = np.linalg.norm(s.normals, axis=1)
+    assert np.allclose(norms, 1.0, atol=1e-6)
+    # total area approximates sphere area 4*pi*r^2
+    total_area = np.sum(s.areas)
+    assert np.isfinite(total_area)
+    assert np.isclose(total_area, 4 * np.pi * s.radius**2, rtol=0.12)
+
+
+def test_plane_tessellation_and_areas():
+    # plane tessellation with subdivisions should yield correct area sum
+    s = fp.flux.Surface(type="plane", radius=1.0, subdivisions=4, width=2.0, length=3.0)
+    assert s.centers.shape[0] == s.subdivisions**2
+    assert np.all(s.areas > 0)
+    total_area = np.sum(s.areas)
+    assert np.isclose(total_area, 2.0 * 3.0, rtol=1e-8)
+
+
+def test_cylinder_tessellation_basic():
+    # cylinder tessellation exposes top/bottom/lateral arrays
+    s = fp.flux.Surface(type="cylinder", radius=0.5, height=1.0, subdivisions=8)
+    # ensure expected attributes exist and have consistent sizes
+    assert hasattr(s, "top_centers")
+    assert hasattr(s, "bottom_centers")
+    assert hasattr(s, "lateral_centers")
+    assert s.top_centers.shape[0] == s.bottom_centers.shape[0]
+    assert s.lateral_centers.shape[0] > 0
+
+
+# FAILED
+def test_total_mass_grid_integration(sim):
+    # Use the test simulation to run total_mass on a small sphere
+    s = fp.flux.Surface(
+        type="sphere", radius=0.1, subdivisions=0, center=(0.0, 0.0, 0.0)
+    )
+    # compute mass for a single snapshot (should be finite and non-negative)
+    mass = s.total_mass(sim, field="gasdens", snapshot=1, follow_planet=False)
+    assert np.isfinite(mass)
+    assert mass >= 0.0
+
+
+def test_total_mass_multiple_snapshots_returns_array(sim):
+    s = fp.flux.Surface(
+        type="sphere", radius=0.1, subdivisions=0, center=(0.0, 0.0, 0.0)
+    )
+    masses = s.total_mass(sim, field="gasdens", snapshot=[1, 2], follow_planet=False)
+    assert isinstance(masses, np.ndarray)
+    assert masses.shape[0] == 2
+    assert np.all(np.isfinite(masses))
+    assert np.all(masses >= 0.0)

fargopy/tests/test_interp.py

@@ -0,0 +1,132 @@
+# fargopy/tests/test___interp.py
+import os
+import numpy as np
+import pytest
+import fargopy as fp
+
+
+@pytest.fixture(scope="session")
+def sim():
+    # Load the local test simulation only once per test session
+    fp.Simulation.download_precomputed("p3disoj")
+    return fp.Simulation(output_dir=f"/tmp/p3disoj")
+
+
+def test_interpolacion_1d_point(sim):
+    data = sim.load_field(
+        fields="gasdens",
+        slice="phi=0,theta=1.56",
+        snapshot=(1, 2),
+        interpolate=True,
+    )
+    x = 1.2
+    valor = data.evaluate(1.2, var1=x)
+    # If it returns a 0-d array or a scalar, both are acceptable; it must be finite
+    assert np.isfinite(valor).all(), "1D interpolation must return a finite value"
+
+
+def test_interpolacion_1d_array(sim):
+    data = sim.load_field(
+        fields="gasdens",
+        slice="phi=0,theta=1.56",
+        snapshot=(1, 2),
+        interpolate=True,
+    )
+    x = np.array([1.2, 1.3, 1.4])
+    valor = data.evaluate(1.2, var1=x)
+    assert np.asarray(valor).shape == x.shape, (
+        "1D interpolation must preserve the input shape"
+    )
+    assert np.isfinite(valor).any(), (
+        "At least some points should be finite if they lie inside the domain"
+    )
+
+
+def test_interpolacion_2d_point(sim):
+    data = sim.load_field(
+        fields="gasdens",
+        slice="theta=1.56",
+        snapshot=(1, 2),
+        interpolate=True,
+    )
+    # Conservative point (typically inside the domain)
+    x = 1.2
+    y = 0.14
+    valor = data.evaluate(
+        1.2, var1=x, var2=y, interpolator="griddata", method="nearest"
+    )
+    assert np.isscalar(valor) or np.asarray(valor).shape == (), (
+        "2D point interpolation must return a scalar/0-d value"
+    )
+    assert np.isfinite(valor), (
+        "2D point interpolation must return a finite value (nearest)"
+    )
+
+
+def test_interpolacion_2d_array(sim):
+    data = sim.load_field(
+        fields="gasdens",
+        slice="theta=1.56",
+        snapshot=(1, 2),
+        interpolate=True,
+    )
+
+    # Your y=[1.3,1.4,1.5] values are very likely outside the domain -> NaNs (linear) or spurious values.
+    # Here we use "safe" points and, additionally, nearest-neighbor interpolation to avoid NaNs
+    # due to the convex hull limitation.
+    x = np.array([0.9, 1.0, 1.1])
+    y = np.array([0.05, 0.10, 0.15])
+
+    valor = data.evaluate(
+        1.2, var1=x, var2=y, interpolator="griddata", method="nearest"
+    )
+    valor = np.asarray(valor)
+
+    assert valor.shape == x.shape, (
+        "2D interpolation must return an array with the same shape as the input"
+    )
+    assert np.isfinite(valor).all(), (
+        "With nearest and in-domain points, NaNs should not appear"
+    )
+
+
+# FAILING
+def test_interpolacion_3d_point(sim):
+    data = sim.load_field(
+        fields="gasdens",
+        snapshot=(1, 2),
+        interpolate=True,
+    )
+    x, y, z = 1.2, 1.3, 1.4
+    valor = data.evaluate(
+        1.2, var1=x, var2=y, var3=z, interpolator="griddata", method="nearest"
+    )
+    assert np.isscalar(valor) or np.asarray(valor).shape == (), (
+        "3D point interpolation must return a scalar/0-d value"
+    )
+    assert np.isfinite(valor), (
+        "3D point interpolation must return a finite value (nearest)"
+    )
+
+
+def test_interpolacion_3d_array(sim):
+    data = sim.load_field(
+        fields="gasdens",
+        snapshot=(1, 2),
+        interpolate=True,
+    )
+    x = np.array([1.2, 1.3, 1.4])
+    y = np.array([1.3, 1.4, 1.5])
+    z = np.array([0.024, 0.14, 0.2])
+
+    valor = data.evaluate(
+        1.2, var1=x, var2=y, var3=z, interpolator="griddata", method="nearest"
+    )
+    valor = np.asarray(valor)
+
+    assert valor.shape == x.shape, (
+        "3D interpolation must return an array with the same shape as the input"
+    )
+    assert np.isfinite(valor).all(), (
+        "With nearest, NaNs should not appear except for extremely out-of-domain points"
+    )

fargopy-1.0.0.data/scripts/ifargopy

@@ -0,0 +1,91 @@
+#!python
+import sys
+import os
+import subprocess
+import argparse
+
+
+def get_version():
+    try:
+        try:
+            from importlib.metadata import version
+            return version("fargopy")
+        except ImportError:
+            # Fallback for Python < 3.8
+            import pkg_resources
+            return pkg_resources.get_distribution("fargopy").version
+    except Exception:
+        # Fallback if package not installed or in development
+        try:
+            import fargopy.version
+            return fargopy.version.version
+        except ImportError:
+            return "unknown"
+
+def run_verify():
+    try:
+        import fargopy
+        v = get_version()
+        print(f"fargopy {v} is successfully installed.")
+        print(f"Location: {os.path.dirname(fargopy.__file__)}")
+    except ImportError:
+        print("Error: fargopy is not installed or cannot be imported.")
+        sys.exit(1)
+
+def run_tests():
+    try:
+        import fargopy
+        package_dir = os.path.dirname(fargopy.__file__)
+        test_dir = os.path.join(package_dir, 'tests')
+        if not os.path.exists(test_dir):
+             print(f"Error: tests directory not found at {test_dir}")
+             sys.exit(1)
+        
+        print(f"Running tests in {test_dir}...")
+        subprocess.check_call([sys.executable, "-m", "pytest", test_dir])
+    except ImportError:
+        print("Error: fargopy is not installed.")
+        sys.exit(1)
+    except subprocess.CalledProcessError as e:
+        sys.exit(e.returncode)
+
+def main():
+    parser = argparse.ArgumentParser(description="fargopy interactive shell and utilities")
+    parser.add_argument("--verify", action="store_true", help="Verify installation and show version")
+    parser.add_argument("--test", action="store_true", help="Run the distributed tests")
+    
+    # If no arguments are provided, or just unknown args (which arguably should be passed to ipython? 
+    # but for now let's stick to the requested logic: optional args for cmd, else launch ipython)
+    # The issue is that argparse will parse all args. If the user wants to pass args to ipython, this might conflict.
+    # However, standard pattern is usually wrapper handles its flags, pass others. 
+    # But ifargopy historically just wraps ipython.
+    
+    # Let's check if we have specific flags.
+    if "--verify" in sys.argv:
+        run_verify()
+        return
+    if "--test" in sys.argv:
+        run_tests()
+        return
+
+    # Original behavior: launch IPython
+    user_home = os.path.expanduser("~")
+    fp_dotdir = os.path.join(user_home, ".fargopy")
+    
+    if not os.path.isdir(fp_dotdir):
+        # First time initialization logic
+        init_script = "/tmp/ifargopy_initialize.py"
+        with open(init_script, "w") as f:
+            f.write("import fargopy as fp\n")
+            f.write("fp.initialize('configure')\n")
+            f.write("print('We have configured fargopy for the first time. Run it again.')\n")
+        
+        subprocess.call(["ipython", "-i", init_script])
+    else:
+        startup_script = os.path.join(fp_dotdir, "ifargopy.py")
+        # Pass all arguments to ipython except the script name itself
+        cmd = ["ipython", "-i", startup_script] + sys.argv[1:]
+        subprocess.call(cmd)
+
+if __name__ == "__main__":
+    main()