gstaichi 0.1.25.dev0__cp313-cp313-win_amd64.whl

gstaichi/_lib/utils.py

@@ -0,0 +1,249 @@
+# type: ignore
+
+import os
+import platform
+import re
+import sys
+import warnings
+
+from colorama import Fore, Style
+
+if sys.version_info[0] < 3 or sys.version_info[1] <= 5:
+    raise RuntimeError(
+        "\nPlease restart with Python 3.6+\n" + "Current Python version:",
+        sys.version_info,
+    )
+
+
+def in_docker():
+    if os.environ.get("TI_IN_DOCKER", "") == "":
+        return False
+    return True
+
+
+def get_os_name():
+    name = platform.platform()
+    # in python 3.8, platform.platform() uses mac_ver() on macOS
+    # it will return 'macOS-XXXX' instead of 'Darwin-XXXX'
+    if name.lower().startswith("darwin") or name.lower().startswith("macos"):
+        return "osx"
+    if name.lower().startswith("windows"):
+        return "win"
+    if name.lower().startswith("linux"):
+        return "linux"
+    if "bsd" in name.lower():
+        return "unix"
+    assert False, f"Unknown platform name {name}"
+
+
+def import_ti_python_core():
+    if get_os_name() != "win":
+        # pylint: disable=E1101
+        old_flags = sys.getdlopenflags()
+        sys.setdlopenflags(2 | 8)  # RTLD_NOW | RTLD_DEEPBIND
+    else:
+        pyddir = os.path.dirname(os.path.realpath(__file__))
+        os.environ["PATH"] += os.pathsep + pyddir
+    try:
+        from gstaichi._lib.core import gstaichi_python as core  # pylint: disable=C0415
+    except Exception as e:
+        if isinstance(e, ImportError):
+            print(
+                Fore.YELLOW + "Share object gstaichi_python import failed, "
+                "check this page for possible solutions:\n"
+                "https://docs.taichi-lang.org/docs/install" + Fore.RESET
+            )
+            if get_os_name() == "win":
+                # pylint: disable=E1101
+                e.msg += "\nConsider installing Microsoft Visual C++ Redistributable: https://aka.ms/vs/16/release/vc_redist.x64.exe"
+        raise e from None
+
+    if get_os_name() != "win":
+        sys.setdlopenflags(old_flags)  # pylint: disable=E1101
+    lib_dir = os.path.join(package_root, "_lib", "runtime")
+    core.set_lib_dir(locale_encode(lib_dir))
+    return core
+
+
+def locale_encode(path):
+    try:
+        import locale  # pylint: disable=C0415
+
+        return path.encode(locale.getdefaultlocale()[1])
+    except (UnicodeEncodeError, TypeError):
+        try:
+            return path.encode(sys.getfilesystemencoding())
+        except UnicodeEncodeError:
+            try:
+                return path.encode()
+            except UnicodeEncodeError:
+                return path
+
+
+def is_ci():
+    return os.environ.get("TI_CI", "") == "1"
+
+
+package_root = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
+
+
+def get_core_shared_object():
+    directory = os.path.join(package_root, "_lib")
+    return os.path.join(directory, "libgstaichi_python.so")
+
+
+def print_red_bold(*args, **kwargs):
+    print(Fore.RED + Style.BRIGHT, end="")
+    print(*args, **kwargs)
+    print(Style.RESET_ALL, end="")
+
+
+def print_yellow_bold(*args, **kwargs):
+    print(Fore.YELLOW + Style.BRIGHT, end="")
+    print(*args, **kwargs)
+    print(Style.RESET_ALL, end="")
+
+
+def check_exists(src):
+    if not os.path.exists(src):
+        raise FileNotFoundError(f'File "{src}" not exist. Installation corrupted or build incomplete?')
+
+
+ti_python_core = import_ti_python_core()
+
+ti_python_core.set_python_package_dir(package_root)
+
+log_level = os.environ.get("TI_LOG_LEVEL", "")
+if log_level:
+    ti_python_core.set_logging_level(log_level)
+
+
+def get_dll_name(name):
+    if get_os_name() == "linux":
+        return f"libgstaichi_{name}.so"
+    if get_os_name() == "osx":
+        return f"libgstaichi_{name}.dylib"
+    if get_os_name() == "win":
+        return f"gstaichi_{name}.dll"
+    raise Exception(f"Unknown OS: {get_os_name()}")
+
+
+def at_startup():
+    ti_python_core.set_core_state_python_imported(True)
+
+
+at_startup()
+
+
+def compare_version(latest, current):
+    latest_num = map(int, latest.split("."))
+    current_num = map(int, current.split("."))
+    return tuple(latest_num) > tuple(current_num)
+
+
+def _print_gstaichi_header():
+    header = "[GsTaichi] "
+    header += f"version {ti_python_core.get_version_string()}, "
+
+    try:
+        timestamp_path = os.path.join(ti_python_core.get_repo_dir(), "timestamp")
+        if os.path.exists(timestamp_path):
+            latest_version = ""
+            with open(timestamp_path, "r") as f:
+                latest_version = f.readlines()[1].rstrip()
+            if compare_version(latest_version, ti_python_core.get_version_string()):
+                header += f"latest version {latest_version}, "
+    except:
+        pass
+
+    llvm_target_support = ti_python_core.get_llvm_target_support()
+    header += f"llvm {llvm_target_support}, "
+
+    commit_hash = ti_python_core.get_commit_hash()
+    commit_hash = commit_hash[:8]
+    header += f"commit {commit_hash}, "
+
+    header += f"{get_os_name()}, "
+
+    py_ver = ".".join(str(x) for x in sys.version_info[:3])
+    header += f"python {py_ver}"
+
+    print(header)
+
+
+if os.getenv("ENABLE_GSTAICHI_HEADER_PRINT", "True").lower() not in ("false", "0", "f"):
+    _print_gstaichi_header()
+
+
+def try_get_wheel_tag(module):
+    try:
+        from email.parser import Parser  # pylint: disable=import-outside-toplevel
+
+        wheel_path = f'{module.__path__[0]}-{".".join(map(str, module.__version__))}.dist-info/WHEEL'
+        with open(wheel_path, "r") as f:
+            meta = Parser().parse(f)
+        return meta.get("Tag")
+    except Exception:
+        return None
+
+
+def try_get_loaded_libc_version():
+    assert platform.system() == "Linux"
+    with open("/proc/self/maps") as f:
+        content = f.read()
+
+    try:
+        libc_path = next(v for v in content.split() if "libc-" in v)
+        ver = re.findall(r"\d+\.\d+", libc_path)
+        if not ver:
+            return None
+        return tuple([int(v) for v in ver[0].split(".")])
+    except StopIteration:
+        return None
+
+
+def try_get_pip_version():
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            import pip  # pylint: disable=import-outside-toplevel
+        return tuple([int(v) for v in pip.__version__.split(".")])
+    except ImportError:
+        return None
+
+
+def warn_restricted_version():
+    if os.environ.get("TI_MANYLINUX2014_OK", ""):
+        return
+
+    if get_os_name() == "linux":
+        try:
+            import gstaichi as ti  # pylint: disable=import-outside-toplevel
+
+            wheel_tag = try_get_wheel_tag(ti)
+            if wheel_tag and "manylinux2014" in wheel_tag:
+                print_yellow_bold(
+                    "You have installed a restricted version of gstaichi, certain features (e.g. Vulkan & GGUI) will not work."
+                )
+                libc_ver = try_get_loaded_libc_version()
+                if libc_ver and libc_ver < (2, 27):
+                    print_yellow_bold(
+                        "!! GsTaichi requires glibc >= 2.27 to run, please try upgrading your OS to a recent one (e.g. Ubuntu 18.04 or later) if possible."
+                    )
+
+                pip_ver = try_get_pip_version()
+                if pip_ver and pip_ver < (20, 3, 0):
+                    print_yellow_bold(
+                        f"!! Your pip (version {'.'.join(map(str, pip_ver))}) is outdated (20.3.0 or later required), "
+                        "try upgrading pip and install gstaichi again."
+                    )
+                    print()
+                    print_yellow_bold("    $ python3 -m pip install --upgrade pip")
+                    print_yellow_bold("    $ python3 -m pip install --force-reinstall gstaichi")
+                    print()
+
+                print_yellow_bold(
+                    "You can suppress this warning by setting the environment variable TI_MANYLINUX2014_OK=1."
+                )
+        except Exception:
+            pass

gstaichi/_logging.py

@@ -0,0 +1,131 @@
+# type: ignore
+
+import inspect
+import os
+
+from gstaichi._lib import core as ti_python_core
+
+
+def _get_logging(name):
+    """Generates a decorator to decorate a specific logger function.
+
+    Args:
+        name (str): The string represents logging level.
+            Effective levels include: 'trace', 'debug', 'info', 'warn', 'error', 'critical'.
+
+    Returns:
+        Callabe: The decorated function.
+    """
+
+    def logger(msg, *args, **kwargs):
+        # Python inspection takes time (~0.1ms) so avoid it as much as possible
+        if ti_python_core.logging_effective(name):
+            msg_formatted = msg.format(*args, **kwargs)
+            func = getattr(ti_python_core, name)
+            frame = inspect.currentframe().f_back
+            file_name, lineno, func_name, _, _ = inspect.getframeinfo(frame)
+            file_name = os.path.basename(file_name)
+            msg = f"[{file_name}:{func_name}@{lineno}] {msg_formatted}"
+            func(msg)
+
+    return logger
+
+
+def set_logging_level(level):
+    """Setting the logging level to a specified value.
+    Available levels are: 'trace', 'debug', 'info', 'warn', 'error', 'critical'.
+
+    Note that after calling this function, logging levels below the specified one will
+    also be effective. For example if `level` is set to 'warn', then the levels below
+    it, which are 'error' and 'critical' in this case, will also be effective.
+
+    See also https://docs.taichi-lang.org/docs/developer_utilities#logging.
+
+    Args:
+        level (str): Logging level.
+
+    Example::
+
+        >>> set_logging_level('debug')
+    """
+    ti_python_core.set_logging_level(level)
+
+
+def is_logging_effective(level):
+    """Check if the specified logging level is effective.
+    All levels below current level will be effective.
+    The default level is 'info'.
+
+    See also https://docs.taichi-lang.org/docs/developer_utilities#logging.
+
+    Args:
+        level (str): The string represents logging level. \
+            Effective levels include: 'trace', 'debug', 'info', 'warn', 'error', 'critical'.
+
+    Returns:
+        Bool: Indicate whether the logging level is effective.
+
+    Example::
+
+        >>> # assume current level is 'info'
+        >>> print(ti.is_logging_effective("trace"))     # False
+        >>> print(ti.is_logging_effective("debug"))     # False
+        >>> print(ti.is_logging_effective("info"))      # True
+        >>> print(ti.is_logging_effective("warn"))      # True
+        >>> print(ti.is_logging_effective("error"))     # True
+        >>> print(ti.is_logging_effective("critical"))  # True
+    """
+    return ti_python_core.logging_effective(level)
+
+
+# ------------------------
+
+DEBUG = "debug"
+"""The `str` 'debug', used for the `debug` logging level.
+"""
+# ------------------------
+
+TRACE = "trace"
+"""The `str` 'trace', used for the `debug` logging level.
+"""
+# ------------------------
+
+INFO = "info"
+"""The `str` 'info', used for the `info` logging level.
+"""
+# ------------------------
+
+WARN = "warn"
+"""The `str` 'warn', used for the `warn` logging level.
+"""
+# ------------------------
+
+ERROR = "error"
+"""The `str` 'error', used for the `error` logging level.
+"""
+# ------------------------
+
+CRITICAL = "critical"
+"""The `str` 'critical', used for the `critical` logging level.
+"""
+# ------------------------
+
+supported_log_levels = [DEBUG, TRACE, INFO, WARN, ERROR, CRITICAL]
+
+debug = _get_logging(DEBUG)
+trace = _get_logging(TRACE)
+info = _get_logging(INFO)
+warn = _get_logging(WARN)
+error = _get_logging(ERROR)
+critical = _get_logging(CRITICAL)
+
+__all__ = [
+    "DEBUG",
+    "TRACE",
+    "INFO",
+    "WARN",
+    "ERROR",
+    "CRITICAL",
+    "set_logging_level",
+    "is_logging_effective",
+]