hcn 0.0.1__py3-none-any.whl

hcn/__init__.py

@@ -0,0 +1,51 @@
+import os, git, threading, warnings, socket
+from importlib.metadata import version, PackageNotFoundError
+
+__all__ = []
+
+
+try:
+    __version__ = version('hcn')
+except PackageNotFoundError:
+    __version__ = 'unknown'
+
+
+def _has_network(host='8.8.8.8', port=53):
+    try:
+        socket.socket(socket.AF_INET, socket.SOCK_STREAM).connect((host, port))
+        return True
+    except Exception:
+        return False
+
+
+def _check_update():
+    current_dir = os.path.dirname(__file__)
+    repo_path = os.path.abspath(os.path.join(current_dir, '..', '..'))
+
+    try:
+        repo = git.Repo(repo_path)
+        
+        if repo.is_dirty():
+            warnings.warn('Local changes detected.')
+
+        if not _has_network():
+            warnings.warn('No network connection. Remote update check skipped.')
+        
+        else:
+            try:
+                repo.remotes.origin.fetch(kill_after_timeout=5)
+                active_branch = repo.active_branch
+                remote_ref = repo.remotes.origin.refs[active_branch.name]
+                
+                behind = list(repo.iter_commits(f'{active_branch.name}..{remote_ref}'))
+                if behind:
+                    warnings.warn(f'Remote update detected. {len(behind)} commits behind.')
+            except Exception as git_err:
+                warnings.warn(f'Remote check failed: {git_err}')
+
+    except Exception as e:
+        warnings.warn(f'Git check failed: {e}')
+
+
+threading.Thread(target=_check_update, daemon=True).start()
+

hcn/assets/matlab_style.py

@@ -0,0 +1,128 @@
+import matplotlib.pyplot as plt
+
+from matplotlib_inline import backend_inline
+backend_inline.set_matplotlib_formats('retina')
+del backend_inline
+
+import os
+from matplotlib.font_manager import fontManager
+assets_dir = os.path.abspath(
+    os.path.join(os.path.dirname(__file__), '../assets/')
+)
+fontManager.addfont(os.path.join(assets_dir, 'fonts/SourceHanSans.otf'))
+del fontManager
+
+
+plt.rcParams['font.size'] = 7
+plt.rcParams['font.sans-serif'].append('Source Han Sans SC')
+
+plt.rcParams['axes.linewidth'] = 0.334
+plt.rcParams['xtick.major.width'] = 0.334
+plt.rcParams['ytick.major.width'] = 0.334
+plt.rcParams['figure.dpi'] = 150
+plt.rcParams['figure.figsize'] = (3.3, 2.5)
+plt.rcParams['lines.linewidth'] = 1
+plt.rcParams['lines.markersize'] = 4
+
+plt.rcParams['xtick.top'] = True
+plt.rcParams['ytick.right'] = True
+plt.rcParams['xtick.direction'] = 'in'
+plt.rcParams['ytick.direction'] = 'in'
+plt.rcParams['xtick.major.size'] = 2.3
+plt.rcParams['ytick.major.size'] = 2.3
+
+
+plt.rcParams['savefig.bbox'] = 'tight'
+plt.rcParams['axes.prop_cycle'] = \
+    plt.cycler('color', ['#0072bd', '#d95319', '#edb120', '#7e2f8e', '#77ac30', '#4dbeee', '#a2142f'])
+
+plt.rcParams['legend.fancybox'] = False
+plt.rcParams['legend.frameon'] = True
+plt.rcParams['legend.framealpha'] = 1
+plt.rcParams['legend.edgecolor'] = 'k'
+plt.rcParams['legend.handlelength'] = 2.5
+plt.rcParams['legend.borderpad'] = 0.3
+plt.rcParams['legend.handletextpad'] = 0.3
+plt.rcParams['patch.linewidth'] = 0.334
+
+plt.rcParams['axes.unicode_minus'] = False
+
+
+import matplotlib as mpl
+
+
+cm_data = [
+    [0.2081, 0.1663, 0.5292],
+    [0.2116238095, 0.1897809524, 0.5776761905],
+    [0.212252381, 0.2137714286, 0.6269714286],
+    [0.2081, 0.2386, 0.6770857143],
+    [0.1959047619, 0.2644571429, 0.7279],
+    [0.1707285714, 0.2919380952, 0.779247619],
+    [0.1252714286, 0.3242428571, 0.8302714286],
+    [0.0591333333, 0.3598333333, 0.8683333333],
+    [0.0116952381, 0.3875095238, 0.8819571429],
+    [0.0059571429, 0.4086142857, 0.8828428571],
+    [0.0165142857, 0.4266, 0.8786333333],
+    [0.032852381, 0.4430428571, 0.8719571429],
+    [0.0498142857, 0.4585714286, 0.8640571429],
+    [0.0629333333, 0.4736904762, 0.8554380952],
+    [0.0722666667, 0.4886666667, 0.8467],
+    [0.0779428571, 0.5039857143, 0.8383714286],
+    [0.079347619, 0.5200238095, 0.8311809524],
+    [0.0749428571, 0.5375428571, 0.8262714286],
+    [0.0640571429, 0.5569857143, 0.8239571429],
+    [0.0487714286, 0.5772238095, 0.8228285714],
+    [0.0343428571, 0.5965809524, 0.819852381],
+    [0.0265, 0.6137, 0.8135],
+    [0.0238904762, 0.6286619048, 0.8037619048],
+    [0.0230904762, 0.6417857143, 0.7912666667],
+    [0.0227714286, 0.6534857143, 0.7767571429],
+    [0.0266619048, 0.6641952381, 0.7607190476],
+    [0.0383714286, 0.6742714286, 0.743552381],
+    [0.0589714286, 0.6837571429, 0.7253857143],
+    [0.0843, 0.6928333333, 0.7061666667],
+    [0.1132952381, 0.7015, 0.6858571429],
+    [0.1452714286, 0.7097571429, 0.6646285714],
+    [0.1801333333, 0.7176571429, 0.6424333333],
+    [0.2178285714, 0.7250428571, 0.6192619048],
+    [0.2586428571, 0.7317142857, 0.5954285714],
+    [0.3021714286, 0.7376047619, 0.5711857143],
+    [0.3481666667, 0.7424333333, 0.5472666667],
+    [0.3952571429, 0.7459, 0.5244428571],
+    [0.4420095238, 0.7480809524, 0.5033142857],
+    [0.4871238095, 0.7490619048, 0.4839761905],
+    [0.5300285714, 0.7491142857, 0.4661142857],
+    [0.5708571429, 0.7485190476, 0.4493904762],
+    [0.609852381, 0.7473142857, 0.4336857143],
+    [0.6473, 0.7456, 0.4188],
+    [0.6834190476, 0.7434761905, 0.4044333333],
+    [0.7184095238, 0.7411333333, 0.3904761905],
+    [0.7524857143, 0.7384, 0.3768142857],
+    [0.7858428571, 0.7355666667, 0.3632714286],
+    [0.8185047619, 0.7327333333, 0.3497904762],
+    [0.8506571429, 0.7299, 0.3360285714],
+    [0.8824333333, 0.7274333333, 0.3217],
+    [0.9139333333, 0.7257857143, 0.3062761905],
+    [0.9449571429, 0.7261142857, 0.2886428571],
+    [0.9738952381, 0.7313952381, 0.266647619],
+    [0.9937714286, 0.7454571429, 0.240347619],
+    [0.9990428571, 0.7653142857, 0.2164142857],
+    [0.9955333333, 0.7860571429, 0.196652381],
+    [0.988, 0.8066, 0.1793666667],
+    [0.9788571429, 0.8271428571, 0.1633142857],
+    [0.9697, 0.8481380952, 0.147452381],
+    [0.9625857143, 0.8705142857, 0.1309],
+    [0.9588714286, 0.8949, 0.1132428571],
+    [0.9598238095, 0.9218333333, 0.0948380952],
+    [0.9661, 0.9514428571, 0.0755333333],
+    [0.9763, 0.9831, 0.0538],
+]
+
+
+parula = mpl.colors.LinearSegmentedColormap.from_list('parula', cm_data)
+mpl.colormaps.register(parula)
+plt.rcParams['image.cmap'] = 'parula'
+del mpl, parula, cm_data
+
+
+__all__ = []

hcn/io/__init__.py

@@ -0,0 +1 @@
+from .core import *

hcn/io/core.py

@@ -0,0 +1,238 @@
+import numpy as np
+import pandas as pd
+from PIL import Image
+import imageio.v3 as iio
+import json
+
+import os
+import inspect
+import platform
+import subprocess
+
+
+__all__ = [
+    "code",
+    "open",
+    "load",
+    "save"
+]
+
+
+ZLIB_MAP = { "xs": 1, "sm": 3, "md": 6, "lg": 8, "xl": 9 }
+JPG_MAP = { "xs": 98, "sm": 95, "md": 90, "lg": 80, "xl": 70 }
+
+COMPRESS_CONFIG = {
+    "png": {
+        "key": "compression",
+        "map": ZLIB_MAP
+    },
+
+    "tif": {
+        "key": "compressionargs",
+        "map": ZLIB_MAP,
+        "flags": { "plugin": "tifffile", "compression": "zlib" }
+    },
+
+    "jpg": {
+        "key": "quality",
+        "map": JPG_MAP
+    },
+}
+
+COMPRESS_CONFIG["tiff"] = COMPRESS_CONFIG["tif"]
+COMPRESS_CONFIG["jpeg"] = COMPRESS_CONFIG["jpg"]
+
+
+def code(input_):
+    if inspect.isfunction(input_) or inspect.ismodule(input_) or inspect.isclass(input_):
+        file_path = inspect.getfile(input_)
+    else:
+        file_path = os.path.expanduser(input_)
+
+    if platform.system() == "Darwin":
+        subprocess.run(["code", file_path], check=True)
+    elif platform.system() == "Windows":
+        subprocess.run(["powershell.exe", "-Command", rf"code '{file_path}'"], check=True)
+    else:
+        raise NotImplementedError("This function is supported on Windows and macOS only.")
+    
+    return os.path.abspath(file_path)
+
+
+
+def open(input_):
+    if inspect.isfunction(input_) or inspect.ismodule(input_) or inspect.isclass(input_):
+        file_dir = os.path.dirname(inspect.getfile(input_))
+    else:
+        file_dir = os.path.expanduser(input_)
+
+    if platform.system() == "Darwin":
+        subprocess.run(["open", file_dir], check=True)
+    elif platform.system() == "Windows":
+        subprocess.run(["start", "", file_dir], shell=True, check=True)
+    else:
+        raise NotImplementedError("This function is supported on Windows and macOS only.")
+    
+    return os.path.abspath(file_dir)
+
+
+
+class _FileReader:
+    def __init__(self, path):
+        self.path = os.path.expanduser(path)
+
+        if not os.path.exists(self.path):
+            raise FileNotFoundError(f"{path} does not exists")
+        
+        self.path = path
+        self.ext = os.path.splitext(path)[-1].lower()[1:]
+        self.name = os.path.basename(path)
+        self.stem = os.path.splitext(self.name)[0]
+
+    
+    def _iio(self):
+        return np.squeeze(iio.imread(self.path, extension=f".{self.ext}"))
+
+
+    def _json(self):
+        with open(self.path, "r") as f:
+            dic = json.load(f)
+        return dic
+
+
+    def _csv(self):
+        return np.array(pd.read_csv(self.path, header=None))
+
+
+    def _npy(self):
+        return np.load(self.path)
+
+
+    def _npz(self):
+        dic = dict(np.load(self.path))
+        for key in dic.keys():
+            dic[key] = dic[key]
+        return dic
+
+
+    def _other(self):
+        msg = f"No implemented method for '.{self.ext}', nothing to return."
+        if os.path.exists(self.path):
+            msg += f"The file '{self.name}' exists, you may use finder() to open it."
+        print(msg)
+        return None
+
+
+    def load(self):
+        if self.ext == "npz":
+            data = self._npz()
+
+        elif self.ext == "npy":
+            data = self._npy()
+
+        elif self.ext in ["jpg", "jpeg", "png", "bmp", "tif", "tiff", "avi"]:
+            data = self._iio()
+
+        elif self.ext == "csv":
+            data = self._csv()
+
+        elif self.ext == "json":
+            data = self._json()
+
+        else:
+            data = self._other()
+
+        return data
+
+
+
+class _FileWriter:
+    def __init__(self, path, data, compress):
+        self.path = os.path.abspath(os.path.expanduser(path))
+        self.data = data
+        self.compress = compress
+
+        self.ext = os.path.splitext(self.path)[-1].lower()[1:]
+        self.name = os.path.basename(self.path)
+        self.stem = os.path.splitext(self.name)[0]
+
+
+    def _json(self):
+        if isinstance(self.data, dict):
+            with open(self.path, "w") as f:
+                json.dump(self.data, f, indent=2)
+        else:
+            raise TypeError("'.json' format requires a dict of arrays")
+
+
+    def _csv(self):
+        arr = np.array(self.data)
+        pd.DataFrame(arr).to_csv(self.path, index=False, header=False)
+
+
+    def _npy(self):
+        np.save(self.path, np.array(self.data))
+
+    def _npz(self):
+        if isinstance(self.data, dict):
+            np.savez_compressed(self.path, **{k: np.array(v) for k, v in self.data.items()})
+            return self.path
+        else:
+            raise TypeError("'.npz' format requires a dict of arrays")
+        
+    def _iio(self):
+        if self.ext in ["jpg", "jpeg"] and self.compress is False:
+            raise ValueError(f"'.{self.ext}' format does not support lossless storage (compress=False).")
+        
+        if self.ext == "bmp" and self.compress is not False:
+            print(f"warning: '.bmp' format does not support compression, ignoring 'compress={self.compress}'")
+        
+        lvl = "md" if self.compress is True else self.compress
+        cfg = COMPRESS_CONFIG.get(self.ext)
+        if cfg is not None and self.compress:
+            params = {cfg.get("key"): {"level": cfg["map"].get(lvl, lvl)} if self.ext in ["tiff", "tif"] else cfg["map"].get(lvl, lvl)} 
+            flags = cfg.get("flags", {})
+        else:
+            params, flags = {}, {}
+
+        return iio.imwrite(self.path, self.data, extension=f".{self.ext}", **params, **flags)
+
+
+    def _other(self):
+        msg = f"No implemented method for '.{self.ext}', nothing saved."
+        print(msg)
+
+
+    def save(self):
+        if self.ext == "npz":
+            self._npz()
+        
+        elif self.ext == "npy":
+            self._npy()
+
+        elif self.ext in ["jpg", "jpeg", "png", "bmp", "tif", "tiff"]:
+            self._iio()
+        
+        elif self.ext == "csv":
+            self._csv()
+        
+        elif self.ext == "json":
+            self._json()
+        
+        else:
+            self._other()
+
+
+
+def load(path, dtype=None):
+    target = _FileReader(path)
+    return target.load() if dtype is None else target.load().astype(dtype)
+
+
+
+def save(path, data, dtype=None, compress=False):
+    data = np.asarray(data) if dtype is None else np.asarray(data).astype(dtype)
+    target = _FileWriter(path, data, compress)
+    target.save()
+    return target.path
+

hcn/preamble.py

@@ -0,0 +1,9 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+import os
+from time import sleep
+from tqdm import tqdm
+from math import e, pi
+
+from .assets import matlab_style

hcn/utils/cache.py

@@ -0,0 +1,143 @@
+"""
+WARNING: DO NOT ABUSE !!!
+
+Cache is stored on disk at the location specified by `CACHE_DIR`,
+and is by default deleted after 2 days of inactivity.
+
+Since the cache is saved on disk, it will persist across kernel or
+computer restarts. However, this may introduce a risk of computation
+errors.
+
+Additionally, because the cache is stored on disk, using it might
+be less efficient than recomputing when the input data or function
+output is very large.
+
+Thus, caching is generally most effective for time-consuming
+computations where the input and output data sizes are relatively small.
+"""
+
+
+import os
+import shutil
+import inspect
+import pickle
+import time
+
+from glob import glob
+from functools import wraps
+from hashlib import md5
+
+
+# CACHE_DIR = os.path.join(os.path.dirname(__file__), '__cache.py_cache_dir__/')
+CACHE_DIR = os.path.expanduser('~/.hcn.utils.cache.cache_dir')
+EXPIRATION_TIME = 2 * 24 * 60 * 60
+
+if not os.path.exists(CACHE_DIR):
+    os.mkdir(CACHE_DIR)
+
+
+__all__ = [
+    'clean_all_cache',
+    'clean_expired_cache',
+    'open_cache_dir',
+    'cache'
+]
+
+
+def extract_timestamp(file_path):
+    base_name = os.path.basename(file_path)
+    timestamp = base_name.split('_')[1].split('.pkl')[0]
+    return int(timestamp)
+
+
+def find_cache(hash_key):
+    time_stamp = int(time.time())
+    prefix_name = os.path.join(CACHE_DIR, f'{hash_key}_*')
+    cache_file = glob(prefix_name)
+
+    if len(cache_file) == 0:
+        cache_file = os.path.join(CACHE_DIR, f'{hash_key}_{time_stamp}.pkl')
+        return cache_file, False
+    
+    elif len(cache_file) == 1:
+        cache_file = cache_file[0]
+        return cache_file, True
+    
+    else:
+        raise
+
+
+def update_timestamp(cache_file):
+    time_stamp = int(time.time())
+    base_name = os.path.basename(cache_file)
+    hash_key = base_name.split('_')[0]
+    new_name = f'{hash_key}_{time_stamp}.pkl'
+    os.rename(cache_file, os.path.join(CACHE_DIR, new_name))
+    
+
+
+def open_cache_dir():
+    import platform
+    if platform.system() == 'Windows':
+        os.system('start ' + CACHE_DIR)
+    else:
+        os.system('open ' + CACHE_DIR)
+
+
+def clean_all_cache():
+    shutil.rmtree(CACHE_DIR)
+    os.mkdir(CACHE_DIR)
+    print('done')
+
+
+def clean_expired_cache():
+    now = int(time.time())
+    for file_name in os.listdir(CACHE_DIR):
+        file_path = os.path.join(CACHE_DIR, file_name)
+        
+        if file_name.endswith('.pkl'):
+            try:
+                timestamp = extract_timestamp(file_path)
+                if now - timestamp > EXPIRATION_TIME:
+                    os.remove(file_path)
+            except Exception as e:
+                print(f"Error processing file {file_path}: {e}")
+
+
+def cache(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        abspath = lambda p: os.path.abspath(os.path.normpath(p))
+        
+        args = tuple(
+            abspath(arg) if isinstance(arg, str) and os.path.isfile(arg) else arg
+            for arg in args
+        )
+
+        kwargs = {
+            k: abspath(v) if isinstance(v, str) and os.path.isfile(v) else v
+            for k, v in kwargs.items()
+        }
+
+        cache_key = str(inspect.getsource(func)) + str(func.__name__) + str(args) + str(kwargs)
+        cache_key = cache_key.encode('utf-8')
+        hash_key = md5(cache_key).hexdigest()
+        
+        cache_file, success = find_cache(hash_key)
+            
+        if success and os.path.isfile(cache_file):
+            try:
+                with open(cache_file, 'rb') as f:
+                    result = pickle.load(f)
+                update_timestamp(cache_file)
+                print('cache hit: reading result from cache file')
+                return result
+            except (EOFError, pickle.UnpicklingError, ValueError):
+                os.remove(cache_file)
+            
+        result = func(*args, **kwargs)
+        with open(cache_file, 'wb') as f:
+            pickle.dump(result, f)
+        return result
+    
+    return wrapper

hcn/utils/cpuid.py

@@ -0,0 +1,29 @@
+import subprocess
+import platform
+
+__all__ = ['cpuid']
+
+def cpuid():
+    system = platform.system().lower()
+    if system == "windows":
+        return _cpuid_windows()
+    elif system == "darwin":
+        return _cpuid_macos()
+    return None
+
+def _cpuid_windows():
+    try:
+        cpu_id = subprocess.check_output("wmic cpu get processorid", shell=True).decode().strip().split("\n")[1]
+        return cpu_id
+    except Exception as e:
+        print(f"Failed to get CPU ID (Windows): {e}")
+        return None
+
+def _cpuid_macos():
+    try:
+        serial_number = subprocess.check_output("system_profiler SPHardwareDataType | grep 'Serial Number (system)'", shell=True).decode().strip().split(":")[1].strip()
+        return serial_number
+    except Exception as e:
+        print(f"Failed to get hardware serial number (macOS): {e}")
+        return None
+

hcn/utils/crypt.py

@@ -0,0 +1,146 @@
+import os
+import base64
+import getpass
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+from cryptography.fernet import Fernet
+
+import hashlib
+import subprocess
+import platform
+
+
+def _fingerprint_windows():
+    try:
+        disk_sn = subprocess.check_output('wmic diskdrive get serialnumber', shell=True).decode().strip().split('\n')[1]
+        machine_id = subprocess.check_output('reg query "HKLM\\SOFTWARE\\Microsoft\\Cryptography" /v MachineGuid', shell=True).decode().strip().split('    ')[-1]
+        
+        hardware_info = f'{machine_id}|{disk_sn}'
+        return hashlib.sha256(hardware_info.encode()).hexdigest()
+    except Exception as e:
+        print(f'Failed to get hardware info (Windows): {e}')
+        return None
+
+
+def _fingerprint_macos():
+    try:
+        hw_uuid = subprocess.check_output("system_profiler SPHardwareDataType | grep 'Hardware UUID'", shell=True).decode().strip().split(':')[1].strip()
+        disk_uuid = subprocess.check_output("system_profiler SPStorageDataType | grep 'Volume UUID' | head -n 1", shell=True).decode().strip().split(':')[1].strip()
+
+        hardware_info = f'{hw_uuid}|{disk_uuid}'
+        return hashlib.sha256(hardware_info.encode()).hexdigest()
+    except Exception as e:
+        print(f'Failed to get hardware info (macOS): {e}')
+        return None
+
+
+def _fingerprint_linux():
+    try:
+        machine_id = subprocess.check_output('cat /etc/machine-id', shell=True).decode().strip()
+        disk_uuid = subprocess.check_output('lsblk -o NAME,UUID | grep \'sda\' | awk \'{print $2}\'', shell=True).decode().strip()
+
+        hardware_info = f'{machine_id}|{disk_uuid}'
+        return hashlib.sha256(hardware_info.encode()).hexdigest()
+    except Exception as e:
+        print(f'Failed to get hardware info (Linux): {e}')
+        return None
+
+
+def device_fingerprint():
+    system = platform.system().lower()
+
+    if system == 'windows':
+        return _fingerprint_windows()
+    elif system == 'darwin':
+        return _fingerprint_macos()
+    elif system == 'linux':
+        return _fingerprint_linux()
+    else:
+        return None
+
+
+def device_fingerprint():
+    system = platform.system().lower()
+
+    if system == 'windows':
+        return _fingerprint_windows()
+    elif system == 'darwin':
+        return _fingerprint_macos()
+    elif system == 'linux':
+        return _fingerprint_linux()
+    else:
+        return None
+
+
+# Internal function to derive the encryption key from the password
+def _derive_key(password: str, salt: bytes) -> bytes:
+    """
+    Derives a key from the password using PBKDF2-HMAC-SHA256.
+
+    Args:
+        password (str): The password used to derive the key.
+        salt (bytes): The salt value added to the password to prevent rainbow table attacks.
+
+    Returns:
+        bytes: The derived encryption key (32 bytes).
+    """
+    kdf = PBKDF2HMAC(
+        algorithm=hashes.SHA256(),  # Using SHA-256 as the hash algorithm
+        length=32,                  # The length of the derived key (32 bytes)
+        salt=salt,
+        iterations=2_000_000,       # Number of iterations (to slow down brute force)
+    )
+    key = kdf.derive(password.encode())  # Derive the key from the password
+    return key
+
+
+def _isNone(password):
+    if password is None:
+        return getpass.getpass('input password: ')
+    else:
+        return password
+
+
+def encrypt(message: str | bytes, password: str = None) -> bytes:
+    """
+    Encrypts a message using a password and a random salt.
+
+    Args:
+        message (str | bytes): The message to be encrypted (can be a string or bytes).
+        password (str): The password used to derive the encryption key.
+
+    Returns:
+        bytes: The encrypted message concatenated with the salt (used for decryption).
+    """
+    if isinstance(message, str):
+        message = message.encode()  # Convert string to bytes
+    
+    salt = os.urandom(16)  # Generate a 16-byte random salt
+    key = _derive_key(_isNone(password), salt)  # Derive the encryption key from the password and salt
+    f = Fernet(base64.urlsafe_b64encode(key))  # Create a Fernet object using the derived key
+    encrypted_message = f.encrypt(message)  # Encrypt the message
+    return salt + encrypted_message  # Return the salt and the encrypted message
+
+
+def decrypt(encrypted_message: bytes, password: str = None) -> str | bytes:
+    """
+    Decrypts an encrypted message using a password and the provided salt.
+
+    Args:
+        encrypted_message (bytes): The encrypted message concatenated with the salt.
+        password (str): The password used to derive the encryption key.
+
+    Returns:
+        str | bytes: The decrypted plaintext message (either a string or binary data).
+    """
+    salt = encrypted_message[:16]  # Extract the salt from the encrypted data
+    encrypted_message = encrypted_message[16:]  # Extract the actual encrypted message
+    key = _derive_key(_isNone(password), salt)  # Derive the encryption key from the password and salt
+    f = Fernet(base64.urlsafe_b64encode(key))  # Create a Fernet object using the derived key
+    
+    try:
+        # Try to decode as a string (for text files)
+        return f.decrypt(encrypted_message).decode()  # Try to return as string
+    except UnicodeDecodeError:
+        # If decoding fails, return the original binary data
+        return f.decrypt(encrypted_message)  # If it's binary data, return the raw binary data

hcn/utils/ezmail.py

@@ -0,0 +1,191 @@
+import os
+import json
+import base64
+
+import smtplib
+from email.mime.text import MIMEText
+from email.utils import formataddr
+
+import io
+import traceback
+import socket
+import getpass
+from datetime import datetime
+from contextlib import contextmanager, redirect_stdout, redirect_stderr
+from functools import wraps
+
+from .crypt import encrypt, decrypt, device_fingerprint
+
+
+CONFIG_PATH = os.path.expanduser('~/.hcn.utils.ezmail.config')
+_config_cache = None
+
+
+__all__ = ['auth', 'smtp', 'forget', 'send', 'context', 'decorator']
+
+
+def _save_auth_config():
+    config = _load_config()
+    keep = {}
+    if 'email' in config:
+        keep['email'] = config['email']
+    if 'password' in config:
+        keep['password'] = config['password']
+
+    if os.path.exists(CONFIG_PATH):
+        with open(CONFIG_PATH, 'r') as f:
+            raw = json.load(f)
+    else:
+        raw = {}
+    raw.update(keep)
+
+    with open(CONFIG_PATH, 'w') as f:
+        json.dump(raw, f, indent=4)
+
+
+
+def _save_smtp_config():
+    config = _load_config()
+    keep = {}
+    for k in ['smtp_host', 'smtp_port']:
+        if k in config:
+            keep[k] = config[k]
+
+    if os.path.exists(CONFIG_PATH):
+        with open(CONFIG_PATH, 'r') as f:
+            raw = json.load(f)
+    else:
+        raw = {}
+    raw.update(keep)
+
+    with open(CONFIG_PATH, 'w') as f:
+        json.dump(raw, f, indent=4)
+
+
+
+def _load_config():
+    global _config_cache
+    if _config_cache is None:
+        if os.path.exists(CONFIG_PATH):
+            with open(CONFIG_PATH, 'r') as f:
+                _config_cache = json.load(f)
+        else:
+            _config_cache = {}
+    return _config_cache
+
+
+
+def auth(save=False):
+    config = _load_config()
+
+    email_enc = encrypt(input('Email address: ').strip(), device_fingerprint())
+    passwd_enc = encrypt(getpass.getpass('Application password: ').strip(), device_fingerprint())
+
+    config['email'] = base64.b64encode(email_enc).decode()
+    config['password'] = base64.b64encode(passwd_enc).decode()
+
+    if save:
+        _save_auth_config()
+
+
+
+def smtp(save=False):
+    config = _load_config()
+
+    smtp_host = input('SMTP Host: ').strip()
+    smtp_port_str = input('SMTP Port: ').strip()
+
+    if not smtp_port_str.isdigit():
+        raise ValueError(f"Invalid SMTP Port: '{smtp_port_str}'")
+
+    smtp_port = int(smtp_port_str)
+
+    config.update({
+        'smtp_host': smtp_host,
+        'smtp_port': smtp_port,
+    })
+
+    if save:
+        _save_smtp_config()
+
+
+
+def forget():
+    if os.path.exists(CONFIG_PATH):
+        confirm = input(f"Are you sure you want to delete config at {os.path.expanduser('~')}? (y/N): ").lower().strip()
+        if confirm in ('y', 'yes', 'true'):
+            os.remove(CONFIG_PATH)
+            print('Configuration removed.')
+        else:
+            print('Abort.')
+    else:
+        print(f"No config found at '{os.path.expanduser('~')}'.")
+
+
+
+def send(subject, message, recipient):
+    config = _load_config()
+
+    for key in ['email', 'password', 'smtp_host', 'smtp_port']:
+        if key not in config:
+            raise ValueError(f"Missing '{key}' in config. Run `email_notify.auth()` or `email_notify.smtp()` to configure.")
+
+    sender = decrypt(base64.b64decode(config['email']), device_fingerprint())
+    password = decrypt(base64.b64decode(config['password']), device_fingerprint())
+    smtp_host = config['smtp_host']
+    smtp_port = config['smtp_port']
+
+    msg = MIMEText(message, 'plain', 'utf-8')
+    msg['From'] = formataddr([f'email_notify', sender])
+    msg['To'] = recipient
+    msg['Subject'] = subject
+
+    with smtplib.SMTP_SSL(smtp_host, smtp_port) as server:
+        server.login(sender, password)
+        server.sendmail(sender, [recipient], msg.as_string())
+        server.quit()
+
+
+class notify:
+    @staticmethod
+    @contextmanager
+    def context(recipient, task_name='Task'):
+        buf = io.StringIO()
+        start_time = datetime.now()
+        user_host = f'{getpass.getuser()}@{socket.gethostname()}'
+
+        def _body(status: str, output: str):
+            end_time = datetime.now()
+            elapsed = str(end_time - start_time).split('.')[0]
+            return (
+                f'Status: {status}\n'
+                f'Host: {user_host}\n'
+                f'Started: {start_time.strftime("%Y-%m-%d %H:%M:%S")}\n'
+                f'Ended: {end_time.strftime("%Y-%m-%d %H:%M:%S")}\n'
+                f'Elapsed: {elapsed}\n\n'
+
+                f'Console output:\n\n{output}\n'
+            )
+
+        try:
+            with redirect_stdout(buf), redirect_stderr(buf):
+                yield
+            send(f'{task_name} Completed', _body('Completed', buf.getvalue()), recipient)
+        except Exception as e:
+            buf.write('\n')
+            buf.write(traceback.format_exc())
+            send(f'{task_name} Failed', _body(type(e).__name__, buf.getvalue()), recipient)
+            raise
+
+
+    @classmethod
+    def decorator(cls, recipient):
+        def wrapper(func):
+            @wraps(func)
+            def inner(*args, **kwargs):
+                with cls.context(recipient, task_name=func.__name__):
+                    return func(*args, **kwargs)
+            return inner
+        return wrapper
+
+

hcn/utils/parallelize.py

@@ -0,0 +1,25 @@
+from functools import wraps
+from dask import delayed, compute
+from dask.distributed import Client
+import psutil
+
+# A useful decorator to enable multiprocessing, based on dask.
+def parallelize(cores: int = 0):
+    if cores <= 0:
+        cores = psutil.cpu_count(logical=False)
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(tasks, *args, **kwargs):
+
+            @delayed
+            def _delayed_func(*args, **kwargs):
+                return func(*args, **kwargs)
+            
+            all_tasks = [_delayed_func(task, *args, **kwargs) for task in tasks]
+            with Client(n_workers=cores, threads_per_worker=1):
+                results = compute(*all_tasks)
+
+            return results
+        return wrapper
+    return decorator

hcn-0.0.1.dist-info/METADATA

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: hcn
+Version: 0.0.1
+Summary: HCN's Collections of Nonpareils (or Nonsense)
+License: MIT License
+        
+        Copyright (c) 2023 Chao-Ning Hu
+        
+        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.
+        
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: gitpython
+Requires-Dist: imageio[ffmpeg,tifffile]
+Dynamic: license-file
+
+Refactoring...

hcn-0.0.1.dist-info/RECORD

@@ -0,0 +1,18 @@
+hcn/__init__.py,sha256=ozLvYoGAUoQjwkDWiNN79DQVQ6QJDmtdo81oL5G66BI,1497
+hcn/preamble.py,sha256=0QKXhTJyyeBRdyl3OzYvQu0MQNig0bf_UrRXjemXghg,163
+hcn/assets/matlab_style.py,sha256=8RIKNtdMeKq0VaUjn8YAVf1N7bgu5cBbhfqLhYtSKqM,4631
+hcn/assets/fonts/SourceHanSans.otf,sha256=hLvUrOkdMns60aWBxogZYnik5BMIUgF29BkYAGTkrys,16437608
+hcn/assets/fonts/lmroman10.otf,sha256=GqGM_vpYEyxSzl3nDbH9EVQgHBnNKyza_7pJBqM-aFI,111536
+hcn/io/__init__.py,sha256=79Ih1151rfcqZdr7F8HSZSTs_iT2SKd1xCkehMsXeXs,19
+hcn/io/core.py,sha256=OX-lMzz-DABBJCXsHNR-V_CZfapaZ5sXU-BKNHCc6xo,6340
+hcn/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hcn/utils/cache.py,sha256=z01pE4wAavNhCsPk8GT2x86jnmkSGDiih_cnU4h8bD8,3948
+hcn/utils/cpuid.py,sha256=etJiwzDioYNRp6ufJgoDMxXMYGCWQm2CHjlX8q1xC9Y,855
+hcn/utils/crypt.py,sha256=ZDdGi2BpefxhJvPr696YKpGoI2kkfLxEj8xl984Qsjo,5449
+hcn/utils/ezmail.py,sha256=ytRNbk74bMofaphBmjYAU0nCEP4VtSWEXAgaWQpVTqI,5185
+hcn/utils/parallelize.py,sha256=cdbPnuDWQX19R5x77e2S6dXGHrCBmoAxpGP4XCxxXgQ,759
+hcn-0.0.1.dist-info/licenses/LICENSE,sha256=UnqMTa01uNhGrBkbOqjHSp8ThkITiVhLqdehtq8MC9o,1069
+hcn-0.0.1.dist-info/METADATA,sha256=VVUWkjMzCuSm5OdAXyDI7wqGUwDnHNC9fh7yvx_CKfQ,1728
+hcn-0.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+hcn-0.0.1.dist-info/top_level.txt,sha256=ppbrdjujDMeufmiJrUOY9LoOaHHg65vl1zSp5rTlwLA,4
+hcn-0.0.1.dist-info/RECORD,,

hcn-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

hcn-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Chao-Ning Hu
+
+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.

hcn-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+hcn