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

fargopy/base.py

@@ -0,0 +1,377 @@
+###############################################################
+# Package documentation
+###############################################################
+"""
+FARGOpy Base Module
+===================
+
+This module contains the base classes, configuration, and initialization logic for FARGOpy.
+It is separated from __init__.py to avoid circular import issues with other modules like sys.py.
+"""
+
+import warnings
+import os
+import json
+import sys
+import numpy as np
+
+# Version
+__version__ = '1.0.1'
+
+__all__ = [
+    "__version__",
+    "Debug",
+    "Dictobj",
+    "Fargobj",
+    "Conf",
+    "initialize",
+    "DEG",
+    "RAD",
+    "IN_COLAB",
+    "_welcome",
+]
+
+###############################################################
+# Constants
+###############################################################
+DEG = np.pi / 180
+RAD = 1 / DEG
+
+# Check if we are in colab
+IN_COLAB = "google.colab" in sys.modules
+
+
+###############################################################
+# Base classes
+###############################################################
+class Debug(object):
+    """The Debug class controls the debugging messages of the package.
+
+    Attributes
+    ----------
+    VERBOSE : bool
+        If True all the trace messages are shown. Default is False.
+
+    Methods
+    -------
+    trace(msg)
+        Show a debugging message if VERBOSE=True.
+    """
+
+    VERBOSE = False
+
+    @staticmethod
+    def trace(msg):
+        if Debug.VERBOSE:
+            print("::" + msg)
+
+
+class Dictobj(object):
+    """Convert a dictionary to an object
+
+    Initialization attributes:
+        dict: dictionary:
+            Dictionary containing the attributes.
+
+    Attributes:
+        All the keys in the initialization dictionary.
+
+    Methods:
+        keys():
+            It works like the keys() method of a dictionary.
+        item(key):
+            Recover the value of an attribute as it was a dictionary.
+        print_keys():
+            Print a list of keys
+    """
+
+    def __init__(self, **kwargs):
+        if "dict" in kwargs.keys():
+            kwargs.update(kwargs["dict"])
+        for key, value in kwargs.items():
+            if key == "dict":
+                continue
+            setattr(self, key, value)
+
+    def __getitem__(self, key):
+        return self.item(str(key))
+
+    def keys(self):
+        """Show the list of attributes of Dictobj"""
+        props = []
+        for i, prop in enumerate(self.__dict__.keys()):
+            if "__" in prop:
+                continue
+            props += [prop]
+        return props
+
+    def item(self, key):
+        """Get the value of an item of a Dictobj."""
+        if key not in self.keys():
+            raise ValueError(f"Key 'key' not in Dictobj")
+        return self.__dict__[key]
+
+    def __getitem__(self, key):
+        return self.item(str(key))
+
+    def print_keys(self):
+        """Print all the keys of a Dictobj."""
+        prop_list = ""
+        for i, prop in enumerate(self.keys()):
+            prop_list += f"{prop}, "
+            if ((i + 1) % 10) == 0:
+                prop_list += "\n"
+        print(prop_list.strip(", "))
+
+    def __str__(self):
+        return str(self.__dict__)
+
+    def __repr__(self):
+        return self.__str__()
+
+
+class Fargobj(object):
+    def __init__(self, **kwargs):
+        self.fobject = True
+        self.kwargs = kwargs
+
+    def save_object(self, filename=None, verbose=False):
+        """Save Fargobj into a filename in JSON format"""
+        if filename is None:
+            object_hash = str(abs(hash(str(self.__dict__))))
+            filename = f"/tmp/fargobj_{object_hash}.json"
+        if verbose:
+            print(f"Saving object to {filename}...")
+        with open(filename, "w") as file_object:
+            file_object.write(
+                json.dumps(self.__dict__, default=lambda obj: "<not serializable>")
+            )
+            file_object.close()
+
+    def set_property(self, property, default, method=lambda prop: prop):
+        """Set a property of object using a given method"""
+        if property in self.kwargs.keys():
+            method(self.kwargs[property])
+            self.__dict__[property] = self.kwargs[property]
+            return True
+        else:
+            method(default)
+            self.__dict__[property] = default
+            return False
+
+    def has(self, key):
+        """Check if a key is an attribute of Fargobj object"""
+        if key in self.__dict__.keys():
+            return True
+        else:
+            return False
+
+
+###############################################################
+# Package configuration
+###############################################################
+# Basic (unmodifiable) variables
+Conf = Dictobj()
+
+# Cross-platform home directory detection
+if os.name == "nt":  # Windows
+    Conf.FP_HOME = os.environ.get("USERPROFILE", os.path.expanduser("~"))
+else:  # Unix-like systems (Linux, macOS)
+    Conf.FP_HOME = os.environ.get("HOME", os.path.expanduser("~"))
+
+Conf.FP_DOTDIR = os.path.join(Conf.FP_HOME, ".fargopy")
+Conf.FP_RCFILE = os.path.join(Conf.FP_DOTDIR, "fargopyrc")
+
+# Default configuration file content
+Conf.FP_CONFIGURATION = f"""# This is the configuration variables for FARGOpy
+# Package
+FP_VERSION = '{__version__}'
+# System
+FP_HOME = '{Conf.FP_HOME}/'
+# Directories
+FP_DOTDIR = '{Conf.FP_DOTDIR}'
+FP_RCFILE = '{Conf.FP_RCFILE}'
+# Behavior
+FP_VERBOSE = False
+# FARGO3D variables
+FP_FARGO3D_CLONECMD = 'GIT_TERMINAL_PROMPT=0 git clone https://bitbucket.org/fargo3d/public.git'
+FP_FARGO3D_BASEDIR = '{Conf.FP_HOME}'
+FP_FARGO3D_PACKDIR = 'fargo3d/'
+FP_FARGO3D_BINARY = 'fargo3d'
+FP_FARGO3D_HEADER = 'src/fargo3d.h'
+"""
+
+# Default initialization script
+Conf.FP_INITIAL_SCRIPT = """
+import sys
+import fargopy as fp
+get_ipython().run_line_magic('load_ext','autoreload')
+get_ipython().run_line_magic('autoreload','2')
+fp.initialize(' '.join(sys.argv))
+"""
+
+
+def initialize(options="", force=False, **kwargs):
+    """Initialization routine
+
+    Args:
+        options: string, default = '':
+            Action(s) to be performed. Valid actions include:
+                'configure': configure the package.
+                'download': download FARGO3D directory.
+                'check': attempt to compile FARGO3D in the machine.
+                'all': all actions.
+
+        force: bool, default = False:
+            If True, force any action that depends on a previous condition.
+            For instance if options = 'configure' and force = True it will
+            override FARGOpy directory.
+    """
+
+    # Import fargopy inside the function to avoid circular imports
+    # when accessing fargopy.Sys or other components that might rely on base.py
+    import fargopy
+
+    if ("configure" in options) or ("all" in options):
+        # Create configuration directory
+        if not os.path.isdir(Conf.FP_DOTDIR) or force:
+            Debug.trace(f"Configuring FARGOpy at {Conf.FP_DOTDIR}...")
+            # Create directory
+            os.system(f"mkdir -p {Conf.FP_DOTDIR}")
+            # Create configuration variables
+            f = open(f"{Conf.FP_DOTDIR}/fargopyrc", "w")
+            f.write(Conf.FP_CONFIGURATION)
+            f.close()
+            # Create initialization script
+            f = open(f"{Conf.FP_DOTDIR}/ifargopy.py", "w")
+            f.write(Conf.FP_INITIAL_SCRIPT)
+            f.close()
+        else:
+            Debug.trace(f"Configuration already in place.")
+
+    if ("download" in options) or ("all" in options):
+        fargo_dir = f"{Conf.FP_FARGO3D_BASEDIR}/{Conf.FP_FARGO3D_PACKDIR}".replace(
+            "//", "/"
+        )
+
+        print("Downloading FARGOpy...")
+        if not os.path.isdir(fargo_dir) or force:
+            if os.path.isdir(fargo_dir):
+                print(f"Directory '{fargo_dir}' already exists. Removing it...")
+                os.system(f"rm -rf {fargo_dir}")
+            # Ensure GIT_TERMINAL_PROMPT=0 is set to avoid stalling if authentication is requested
+            clone_cmd = Conf.FP_FARGO3D_CLONECMD
+            if "GIT_TERMINAL_PROMPT" not in clone_cmd:
+                clone_cmd = "GIT_TERMINAL_PROMPT=0 " + clone_cmd
+
+            fargopy.Sys.simple(
+                f"cd {Conf.FP_FARGO3D_BASEDIR} && {clone_cmd} {Conf.FP_FARGO3D_PACKDIR}"
+            )
+            print(f"\tFARGO3D downloaded to {fargo_dir}")
+        else:
+            print(f"\tFARGO3D directory already present in '{fargo_dir}'")
+
+        fargo_header = f"{fargo_dir}/{Conf.FP_FARGO3D_HEADER}"
+        if not os.path.isfile(fargo_header):
+            print(f"No header file for fargo found in '{fargo_header}'")
+        else:
+            print(f"Header file for FARGO3D found in the fargo directory {fargo_dir}")
+
+    if ("check" in options) or ("all" in options):
+        fargo_dir = f"{Conf.FP_FARGO3D_BASEDIR}/{Conf.FP_FARGO3D_PACKDIR}".replace(
+            "//", "/"
+        )
+
+        print("Test compilation of FARGO3D")
+        if not os.path.isdir(fargo_dir):
+            print(
+                f"Directory '{fargo_dir}' does not exist. Please download it with fargopy.initialize('download')"
+            )
+
+        cmd_fun = lambda options, mode: (
+            f"make -C {fargo_dir} clean mrproper all {options} 2>&1 |tee /tmp/fargo_{mode}.log"
+        )
+
+        for option, mode in zip(
+            ["PARALLEL=0 GPU=0", "PARALLEL=0 GPU=1", "PARALLEL=1 GPU=0"],
+            ["regular", "gpu", "parallel"],
+        ):
+            # Verify if you want to check this mode
+            if (mode in kwargs.keys()) and (kwargs[mode] == 0):
+                print(f"\tSkipping {mode} compilation")
+                exec(f"Conf.FP_FARGO3D_{mode.upper()} = 0")
+                continue
+
+            cmd = cmd_fun(option, mode)
+            print(f"\tChecking normal compilation.\n\tRunning '{cmd}':")
+            # fargopy.Sys is used here
+            error, output = fargopy.Sys.run(cmd)
+            if not os.path.isfile(f"{fargo_dir}/{Conf.FP_FARGO3D_BINARY}"):
+                print(
+                    f"\t\tCompilation failed for '{mode}'. Check log file '/tmp/fargo_{mode}.log'"
+                )
+                exec(f"Conf.FP_FARGO3D_{mode.upper()} = 0")
+            else:
+                print(f"\t\tCompilation in mode {mode} successful.")
+                exec(f"Conf.FP_FARGO3D_{mode.upper()} = 1")
+
+        print(f"Summary of compilation modes:")
+        print(f"\tRegular: {Conf.FP_FARGO3D_REGULAR}")
+        print(f"\tGPU: {Conf.FP_FARGO3D_GPU}")
+        print(f"\tParallel: {Conf.FP_FARGO3D_PARALLEL}")
+
+
+# Showing version
+def _welcome():
+    """Welcome message"""
+    print(f"Running FARGOpy version {__version__}")
+
+
+###############################################################
+# Initialization logic (moved from __init__.py)
+###############################################################
+# Avoid warnings
+warnings.filterwarnings("ignore")
+
+# Read FARGOpy configuration variables
+if not os.path.isdir(Conf.FP_DOTDIR):
+    print(f"Configuring FARGOpy for the first time")
+    initialize("configure")
+Debug.trace(f"::Reading configuration variables")
+
+# Load configuration variables into Conf
+conf_dict = dict()
+if os.path.isfile(Conf.FP_RCFILE):
+    exec(open(f"{Conf.FP_RCFILE}").read(), dict(), conf_dict)
+Conf.__dict__.update(conf_dict)
+
+# Derivative configuration variables
+Debug.VERBOSE = Conf.FP_VERBOSE
+Conf.FP_FARGO3D_DIR = (Conf.FP_FARGO3D_BASEDIR + "/" + Conf.FP_FARGO3D_PACKDIR).replace(
+    "//", "/"
+)
+Conf.FP_FARGO3D_LOCKFILE = f"{Conf.FP_DOTDIR}/fargopy.lock"
+
+# Check if version in RCFILE is different from installed FARGOpy version
+if Conf.FP_VERSION != __version__:
+    print(
+        f"Your configuration file version '{Conf.FP_VERSION}' it is different than the installed version of FARGOpy '{__version__}'"
+    )
+    # Interactive check only if stream is a TTY? Or just skip if not?
+    # Original code asks for input. This might be blocking in some envs.
+    # We'll keep it as is, but rely on it not triggering often in CI/tests if version matches.
+    # However, since I'm creating a new file, I'll assume users might encounter this.
+    try:
+        # Check if sys.stdin has interactive capabilities
+        if sys.stdin.isatty():
+            ans = input(
+                f"Do you want to update configuration file '{Conf.FP_RCFILE}'? [Y/n]: "
+            )
+            if ans and ("Y" not in ans.upper()):
+                if "N" in ans.upper():
+                    print("We will keeping asking you this until you update it, sorry!")
+            else:
+                os.system(f"cp -rf {Conf.FP_RCFILE} {Conf.FP_RCFILE}.save")
+                initialize("configure", force=True)
+    except Exception:
+        pass

fargopy/bin/ifargopy

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+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()