ararpy 0.1.34__tar.gz → 0.1.36__tar.gz

{ararpy-0.1.34 → ararpy-0.1.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ararpy
-Version: 0.1.34
+Version: 0.1.36
 Summary: A project for Ar-Ar geochronology
 Home-page: https://github.com/wuyangchn/ararpy.git
 Author: Yang Wu

{ararpy-0.1.34 → ararpy-0.1.36}/ararpy/__init__.py

@@ -16,10 +16,10 @@ from . import calc, smp, files, thermo, test
 """ Information """
 
 name = 'ararpy'
-version = '0.1.34'
+version = '0.1.36'
 __version__ = version
 full_version = version
-last_update = '2025-10-22'
+last_update = '2025-12-08'
 
 """ ArArPy Functions """
 

{ararpy-0.1.34 → ararpy-0.1.36}/ararpy/calc/basic.py

@@ -10,8 +10,7 @@
 #
 """
 import copy
-import random
-import string
+import secrets
 import numpy as np
 from scipy import stats
 from datetime import datetime, timezone, timedelta
@@ -100,8 +99,8 @@ def update_dicts(a: dict, b: dict):
     return res
 
 
-def get_random_digits(length: int = 7) -> str:
-    return ''.join(random.choices(string.digits, k=length))
+def get_random_string(length: int = 8) -> str:
+    return secrets.token_hex(max(int(length/2), 1))
 
 
 def monte_carlo(func, inputs, confidence_level, **kwargs):

{ararpy-0.1.34 → ararpy-0.1.36}/ararpy/calc/raw_funcs.py

@@ -30,8 +30,8 @@ def get_raw_data_regression_results(points_data, unselected: list = None):
 
     """
     def power(a0, a1):
-        return regression.power(a0, a1)
-        # raise ValueError("Deprecated regression")
+        # return regression.power(a0, a1)
+        raise ValueError("Deprecated regression")
     # if unselected is None:
     #     unselected = []
     # linesData = []
@@ -42,9 +42,9 @@ def get_raw_data_regression_results(points_data, unselected: list = None):
         power, regression.average]
     # size = 50
     # lines_x = [(max(x + un_x) - 0) / size * i for i in range(size + 1)]
+    x, y = transpose(points_data, ignore=False)
     for i in range(len(reg_handler)):
         try:
-            x, y = transpose(points_data, ignore=False)
             res = reg_handler[i](a0=y, a1=x)
             # line_data = transpose([lines_x, res[7](lines_x)])
             line_results = res[0:4]

{ararpy-0.1.34 → ararpy-0.1.36}/ararpy/calc/regression.py

@@ -16,7 +16,7 @@ import traceback
 import numpy as np
 import pandas as pd
 from scipy.stats import distributions
-from scipy.optimize import fsolve
+from scipy.optimize import minimize_scalar
 import warnings
 from scipy.optimize import minimize
 warnings.simplefilter(action="ignore", category=RuntimeWarning)
@@ -495,16 +495,19 @@ def linest(a0: list, a1: list, *args):
     # calculate Y values base on the fitted formula
     estimate_y = np.matmul(x, beta)
     resid = (estimate_y - y) ** 2
-    reg = (estimate_y - np.mean(estimate_y)) ** 2
-    ssresid = resid.sum()
-    ssreg = reg.sum()
-    sstotal = ssreg + ssresid
+    reg = (estimate_y - np.mean(y)) ** 2
+    ssresid = resid.sum()  # 残差平方和
+    ssreg = reg.sum()  # 回归平方和
+    sstotal = ((y - np.mean(y)) ** 2).sum()
+    r2 = ssreg / sstotal if sstotal != 0 else np.inf
+
     df = m - n
-    m_ssresid = ssresid / df
-    se_beta = (m_ssresid * np.diagonal(inv_xtx)) ** .5
-    beta = beta.transpose()[0]
+    m_ssresid = ssresid / df  # 均方残差，与加权平均中的MSWD对应
+    cov_beta = m_ssresid * inv_xtx
+    se_beta = np.diagonal(cov_beta) ** .5
+
+    beta = beta.flatten()
     rse_beta = se_beta / beta
-    r2 = ssreg / sstotal if sstotal != 0 else np.inf
 
     def get_adjusted_y(*args):
         args = [[1] * len(args[0]), *args]
@@ -538,7 +541,7 @@ def average(a0: list, a1=None):
     k1 = pow(sum([(i - k0) ** 2 for i in a0]) / df, 0.5)  # standard deviation
     k2 = k1 / k0 * 100 if k0 != 0 else 0  # relative standard error
     k3 = r2  # determination coefficient
-    k4 = 'MSWD'
+    k4 = m_ssresid  # 'MSWD'
     k5 = [k0]
     k6 = [k1]
     k8 = m_ssresid
@@ -869,92 +872,101 @@ def power(a0: list, a1: list):
 
 
 def exponential(a0: list, a1: list):
-    """
-    :param a0: known_y's, y = a * b ^ x + c
-    :param a1: known_x's
-    :return: intercept | standard error of intercept | relative error | R2 | MSWD | [m, c, b] | [sem, sec, seb]
-    """
 
-    def _exp_func(x, a, b, c):
-        return a * b ** x + c
+    X = np.array(a1)
+    Y = np.array(a0)
+    y = np.array([a0]).transpose()
 
-    def _residuals(params):
-        a, b, c = params
-        return [_exp_func(xi, a, b, c) - yi for xi, yi in zip(a1, a0)]
+    def _exp_func(xi, a, b, c):
+        return a * np.exp(b * xi) + c
 
-    def _sum_squared_error(params):
-        return sum(r**2 for r in _residuals(params))
+    @np.vectorize
+    def _get_s(b):
+        x = np.concatenate(([np.ones(len(a1))], [np.exp(b * np.array(a1))]), axis=0).transpose()
+        try:
+            inv_xtx = np.linalg.inv(np.matmul(x.transpose(), x))
+        except np.linalg.LinAlgError:
+            raise np.linalg.LinAlgError(f"The determinant of the given matrix must not be zero ")
+        beta = np.matmul(inv_xtx, np.matmul(x.transpose(), y))
+        c, a = beta.flatten()
+        reg_y = _exp_func(X, a, b, c)
+        resid = (reg_y - Y) ** 2
+        ssresid = sum(resid)
+        return ssresid
 
-    def _get_ac(b):
-        f = linest(a0, [b ** xi for xi in a1])
-        return f[5][1], b, f[0]
 
-    def _get_init():
-        f = linest(np.log(np.array(a0)), np.array(a1))
-        return np.exp(f[0]), np.exp(f[5][1]), 0
+    ini_f = linest(np.log(Y), X)
+    ini_b = ini_f[5][1]
 
+    # 替换原来的 minimize_scalar 部分
     try:
-        a, b, c = _get_init()
-        # a, b, c = minimize(_sum_squared_error, [a, b, c], method="Nelder-Mead").x  # 优化方法
-        count = 0
-        step = 0.01
-        while count < 100:
-            a, b, c = _get_ac(b)
-            s = _sum_squared_error([a, b, c])
-            b_left, b_right = b - step * b, b + step * b
-            s_left = _sum_squared_error(_get_ac(b_left))
-            s_right = _sum_squared_error(_get_ac(b_right))
-            if s_left > s > s_right:
-                b = b_right
-                continue
-            elif s_left < s < s_right:
-                b = b_left
-                continue
-            elif s_left < s_right:
-                b = (b + b_left) / 2
-            else:
-                b = (b + b_right) / 2
-            count += 1
-            step = step * 0.5
-            if step < 0.000001:
-                break
+        b, count = newton_minimize_1d(_get_s, x0=ini_b, h=1e-5, tol=1e-8, max_iter=30)
+    except Exception as e:
+        # 使用 scipy 一维优化
+        res = minimize_scalar(_get_s, bounds=(-2, 2), method='bounded', options={'xatol': 1e-8})
+        b, count = res.x, res.nfev
 
-    except RuntimeError:
-        raise RuntimeError
-    except np.linalg.LinAlgError:
-        raise np.linalg.LinAlgError
-    except TypeError:
-        raise TypeError
-    except IndexError:
-        raise IndexError
-
-    f = linest(a0, [b ** _x for _x in a1])
-    a, sea, c, sec = f[5][1], f[6][1], f[0], f[1]
+    # print(f"{b = }, {count = }")
 
-    calculated_y = [_exp_func(i, a, b, c) for i in a1]
-    resid = [(calculated_y[i] - a0[i]) ** 2 for i in range(len(a0))]
-    reg = [(i - sum(calculated_y) / len(calculated_y)) ** 2 for i in calculated_y]
-    ssresid = sum(resid)
-    ssreg = sum(reg)
-    sstotal = ssreg + ssresid
-    dp = len(a1)
-    df = dp - 1
-    m_ssresid = ssresid / df
+    x = np.concatenate(([np.ones(len(a1))], [np.exp(b * np.array(a1))]), axis=0).transpose()
+    m, n = x.shape  # number of data, number of unknown x
+    try:
+        inv_xtx = np.linalg.inv(np.matmul(x.transpose(), x))
+    except np.linalg.LinAlgError:
+        raise np.linalg.LinAlgError(f"The determinant of the given matrix must not be zero ")
+    beta = np.matmul(inv_xtx, np.matmul(x.transpose(), y))
+    estimate_y = np.matmul(x, beta)
+    resid = (estimate_y - y) ** 2
+    reg = (estimate_y - np.mean(y)) ** 2
+    ssresid = resid.sum()  # 残差平方和
+    ssreg = reg.sum()  # 回归平方和
+    sstotal = ((y - np.mean(y)) ** 2).sum()
     r2 = ssreg / sstotal if sstotal != 0 else 1
 
-    z = [b ** i for i in a1]
+    df = m - n
+    m_ssresid = ssresid / df  # 均方残差，与加权平均中的MSWD对应
+    cov_beta = m_ssresid * inv_xtx
+
+    sc, sa = np.diagonal(cov_beta) ** .5
+    c, a = beta.flatten()
     intercept = a + c
-    se_intercept_1 = np.sqrt(sea ** 2 + sec ** 2)
-    # calculate error of intercept
-    errfz = pow(sum([i ** 2 for i in z]) / (dp * sum([i ** 2 for i in z]) - sum(z) ** 2), 0.5)
-    errfx = pow(sum([i ** 2 for i in a1]) / (dp * sum([i ** 2 for i in a1]) - sum(a1) ** 2), 0.5)
-    # seb = errfz * sey = errfz * ssresid / df -> se_intercept = sey * errfx = seb / errfz * errfx
-    se_intercept = sec / errfz * errfx
-    rse_intercept = se_intercept / intercept * 100
+    se_intercept = pow(sa ** 2 + sc ** 2 + 2 * cov_beta[0][1] , 0.5)
 
-    return intercept, se_intercept, rse_intercept, r2, 'mswd', [a, b, c], 'se', \
-           lambda x: [_exp_func(i, a, b, c) for i in x], m_ssresid
+    return intercept, se_intercept, se_intercept / intercept * 100, r2, m_ssresid, [a, b, c], 'se', \
+           lambda x: [_exp_func(xi, a, b, c) for xi in x], m_ssresid
+
+
+def newton_minimize_1d(func, x0, h=1e-5, tol=1e-8, max_iter=20):
+    x = x0
+    for i in range(max_iter):
+        fx = func(x)
+        if not np.isfinite(fx):
+            raise ValueError("Newton Minimize: Function returned non-finite value at x={}".format(x))
+
+        # 一阶导数（中心差分）
+        f_plus = func(x + h)
+        f_minus = func(x - h)
+        if not (np.isfinite(f_plus) and np.isfinite(f_minus)):
+            raise ValueError("Newton Minimize: Non-finite values in derivative computation")
+
+        df = (f_plus - f_minus) / (2 * h)
+        d2f = (f_plus - 2 * fx + f_minus) / (h * h)
+
+        # 牛顿步长
+        if abs(d2f) < 1e-12:  # 避免除零或平坦区域
+            print("Newton Minimize: Second derivative too small, stopping.")
+            break
+
+        step = df / d2f
+        x_new = x - step
+
+        if abs(step) < tol:
+            x = x_new
+            break
+
+        x = x_new
 
+    return x, i + 1
 
 """ line functions """
 

{ararpy-0.1.34 → ararpy-0.1.36}/ararpy/files/basic.py

@@ -12,31 +12,9 @@
 
 import os
 import pickle
-import traceback
 import json
 
 
-def upload(file, media_dir):
-    try:
-        name, suffix = os.path.splitext(file.name)
-        if suffix.lower() not in [
-            '.xls', '.age', '.xlsx', '.arr', '.jpg', '.png', '.txt',
-            '.log', '.seq', '.json', '.ahd', '.csv', '.ngxdp']:
-            raise TypeError(f"The imported file is not supported: {suffix}")
-        web_file_path = os.path.join(media_dir, file.name)
-        with open(web_file_path, 'wb') as f:
-            for chunk in file.chunks():
-                f.write(chunk)
-        print("File path on the server: %s" % web_file_path)
-    except PermissionError:
-        raise ValueError(f'Permission denied')
-    except (Exception, BaseException) as e:
-        print(traceback.format_exc())
-        raise ValueError(f'Error in opening file: {e}')
-    else:
-        return web_file_path, name, suffix
-
-
 def read(file_path):
     """ Read text files, default 'r', 'rb'
     Parameters

{ararpy-0.1.34 → ararpy-0.1.36}/ararpy/files/calc_file.py

@@ -493,40 +493,41 @@ def open_full_xls(file_path: str, sample_name: str = ''):
         res['Inverse Isochron Table'], rows, [4, 5, 6, 7, 10])
     total_param = arr.partial(
         res['Sample Parameters'], rows, [
-            # 1, 2,  # 0-1
-            -1, -1, -1, -1,  # 2-5
-            -1, -1, -1, -1,  # 6-9
-            -1, -1, -1, -1, -1, -1,  # 10-15
-            -1, -1, -1, -1,  # 16-19
-            -1, -1,  # 20-21
-            23, 24, -1, -1, -1, -1,  # 22-27
-            -1, -1,  # 28-29
-            22, -1, -1, -1,  # 30-33
-            -1, -1,  # 34-35
-            -1, -1,  # 36-37
-            -1, -1,  # 38-39
-            -1, -1,  # 40-41
-            -1, -1,  # 42-43
-            -1, -1,  # 44-45
-            -1, -1,  # 46-47
-            -1, -1,  # 48-49
-            -1, -1,  # 50-51
-            -1, -1,  # 52-53
-            -1, -1,  # 54-55
-            -1, -1,  # 56-57
-            -1, -1,  # 58-59
-            -1, -1, -1, -1, -1, -1, -1, -1, -1,  # 60-68
-            10, 11, 12, 13,  # 69-72
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  # 73-84
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  # 85-94
-            -1, -1, -1, -1,  # 95-98
-            -1, -1, -1, -1,  # 99-102
-            -1, -1, -1, -1,  # 103-106
-            -1, -1, -1, -1,  # 107-110
-            -1, -1, -1, -1,  # 111-114
-            -1, -1, -1, -1, -1, -1, -1, -1,  # 115-122
-            -1, -1, -1, -1, -1, -1, -1, -1,  # 123-130
-            -1, -1, -1, -1, -1,  # 131-135
+            # 1, 2, -1, # 0-2
+            -1, -1, -1, -1,  # 3-6
+            -1, -1, -1, -1,  # 7-10
+            -1, -1, -1, -1, -1, -1,  # 11-16
+            -1, -1, -1, -1,  # 17-20
+            -1, -1,  # 21-22
+            23, 24, -1, -1, -1, -1,  # 23-28
+            -1, -1,  # 29-30
+            22, -1, -1, -1,  # 31-34
+            -1, -1,  # 35-36
+            -1, -1,  # 37-38
+            -1, -1,  # 39-40
+            -1, -1,  # 41-42
+            -1, -1,  # 43-44
+            -1, -1,  # 45-46
+            -1, -1,  # 47-48
+            -1, -1,  # 49-50
+            -1, -1,  # 51-52
+            -1, -1,  # 53-54
+            -1, -1,  # 55-56
+            -1, -1,  # 57-58
+            -1, -1,  # 59-60
+            -1, -1, -1, -1, -1, -1, -1, -1, -1,  # 61-69
+            10, 11, 12, 13,  # 70-73
+            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  # 74-85
+            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  # 86-95
+            -1, -1, -1, -1,  # 96-99
+            -1, -1, -1, -1,  # 100-103
+            -1, -1, -1, -1,  # 104-107
+            -1, -1, -1, -1,  # 108-111
+            -1, -1, -1, -1,  # 112-115
+            -1, -1, -1, -1, -1, -1, -1, -1,  # 116-123
+            -1, -1, -1, -1, -1, -1, -1, -1,  # 124-131
+            -1, -1, -1, -1, -1,  # 132-136
+            -1, -1, -1, -1,  # 137-140
         ])
 
     month_convert = {'Jan': '01', 'Feb': '02', 'Mar': '03', 'Apr': '04', 'May': '05', 'Jun': '06',

{ararpy-0.1.34 → ararpy-0.1.36}/ararpy/files/raw_file.py

@@ -65,7 +65,7 @@ DEFAULT_SAMPLE_INFO = {
 
 
 
-def open_file(file_path: str, input_filter: List[Union[str, int, bool]]):
+def open_file(file_path: str, input_filter: List[Union[str, int, bool]], name=None):
     """
     Parameters
     ----------
@@ -94,63 +94,14 @@ def open_file(file_path: str, input_filter: List[Union[str, int, bool]]):
     """
     extension = str(os.path.split(file_path)[-1]).split('.')[-1]
     try:
-        handler = {'txt': open_raw_txt, 'excel': open_raw_xls,
-                   'Qtegra Exported XLS': open_qtegra_exported_xls, 'Seq': open_raw_seq}[
-            ['txt', 'excel', 'Qtegra Exported XLS', 'Seq'][int(input_filter[1])]]
+        handler = {'txt': open_raw_txt, 'excel': open_raw_xls, 'Seq': open_raw_seq}[
+            ['txt', 'excel', 'Qtegra Excel (deleted)', 'Seq'][int(input_filter[1])]]
     except KeyError:
         raise FileNotFoundError("Wrong File.")
-    return handler(file_path, input_filter)
+    return handler(file_path, input_filter, name)
 
 
-def open_qtegra_exported_xls(filepath, input_filter=None):
-    if input_filter is None:
-        input_filter = []
-    try:
-        wb = open_workbook(filepath)
-        sheets = wb.sheet_names()
-        sheet = wb.sheet_by_name(sheets[0])
-        value, step_header, step_list = [], [], []
-        for row in range(sheet.nrows):
-            row_set = []
-            for col in range(sheet.ncols):
-                if sheet.cell(row, col).value == '':
-                    pass
-                else:
-                    row_set.append(sheet.cell(row, col).value)
-            if row_set != [] and len(row_set) > 1:
-                value.append(row_set)
-        for each_row in value:
-            # if the first item of each row is float (1.0, 2.0, ...) this row is the header of a step.
-            if isinstance(each_row[0], float):
-                each_row[0] = int(each_row[0])
-                if "M" in each_row[1].upper():
-                    each_row[1] = datetime.strptime(each_row[1], '%m/%d/%Y  %I:%M:%S %p').isoformat(timespec='seconds')
-                else:
-                    each_row[1] = datetime.strptime(each_row[1], '%m/%d/%Y  %H:%M:%S').isoformat(timespec='seconds')
-                step_header.append(each_row)
-        for step_index, each_step_header in enumerate(step_header):
-            row_start_number = value.index(each_step_header)
-            try:
-                row_stop_number = value.index(step_header[step_index + 1])
-            except IndexError:
-                row_stop_number = len(value) + 1
-            step_values = [
-                each_step_header[0:4],
-                *list(map(
-                    # lambda x: [x[0], x[1], x[2], x[1], x[3], x[1], x[4], x[1], x[5], x[1], x[6]],
-                    # x[1] = time, x[2] = H2:40, x[3] = H1: 39, x[4] = AX: 38, x[5] = L1: 37, x[6] = L2: 36
-                    lambda x: [x[0], x[1], x[6], x[1], x[5], x[1], x[4], x[1], x[3], x[1], x[2]],
-                    # in sequence: Ar36, Ar37, Ar38, Ar39, Ar40
-                    [value[i] for i in range(row_start_number + 2, row_stop_number - 7, 1)]))
-            ]
-            step_list.append(step_values)
-    except Exception as e:
-        raise ValueError('Error in opening the original file: %s' % str(e))
-    else:
-        return {'data': step_list}
-
-
-def open_raw_txt(file_path, input_filter: List[Union[str, int]]):
+def open_raw_txt(file_path, input_filter: List[Union[str, int]], name=None):
     """
     Parameters
     ----------
@@ -173,12 +124,12 @@ def open_raw_txt(file_path, input_filter: List[Union[str, int]]):
         lines = [line.strip().split(['\t', ';', " ", ",", input_filter[3]][int(input_filter[2])])
                  for line in contents.decode(encoding=encoding["encoding"]).split('\r\n')]
 
-    file_name = os.path.basename(file_path).rstrip(os.path.splitext(file_path)[-1])
+    file_name = os.path.basename(file_path).rstrip(os.path.splitext(file_path)[-1]) if name is None else name
     step_list = get_raw_data([lines], input_filter, file_name=file_name)
     return {'data': step_list}
 
 
-def open_raw_xls(file_path, input_filter: List[Union[str, int]]):
+def open_raw_xls(file_path, input_filter: List[Union[str, int]], name):
     """
     Parameters
     ----------
@@ -205,13 +156,13 @@ def open_raw_xls(file_path, input_filter: List[Union[str, int]]):
 
     wb = open_workbook(file_path)
     contents = [_get_content_from_sheet(i) for i in range(100)]
-    file_name = os.path.basename(file_path).rstrip(os.path.splitext(file_path)[-1])
+    file_name = os.path.basename(file_path).rstrip(os.path.splitext(file_path)[-1]) if name is None else name
     step_list = get_raw_data(contents, input_filter, file_name=file_name)
 
     return {'data': step_list}
 
 
-def open_raw_seq(file_path, input_filter=None):
+def open_raw_seq(file_path, input_filter=None, name=None):
 
     class RenameUnpickler(pickle.Unpickler):
         def find_class(self, module: str, name: str):
@@ -257,20 +208,29 @@ def get_raw_data(file_contents: List[List[Union[int, float, str, bool, list]]],
 
     """
 
-    def datetime_parse(string, f):
+    def datetime_parse(string: str, f: str):
         try:
             return datetime.strptime(string, f)
         except ValueError as v:
+            print(traceback.format_exc())
             if f.strip() == "":
                 return datetime_parser.parse(string)
             elif len(v.args) > 0 and v.args[0].startswith('unconverted data remains: '):
-                string = string[:-(len(v.args[0]) - 26)]
-                return datetime.strptime(string, f)
+                # %f handles microseconds (6 digits), remove the remains
+                return datetime_parse(string[:-(len(v.args[0]) - 26)], f)
+            # elif f.upper()[-2:] in ['PM', 'AM']:
+            #     return datetime_parse(string, f[:-2])
             else:
                 raise
 
+    def step_num_parse(s: str):
+        try:
+            return f"{round(float(s)):02d}"
+        except (ValueError, TypeError):
+            return s
+
     step_list = []
-    idx = step_index = 0
+    idx = 0  # step_index
 
     header = input_filter[5]
     isotope_index = input_filter[8:28]
@@ -293,13 +253,10 @@ def get_raw_data(file_contents: List[List[Union[int, float, str, bool, list]]],
                 if res is not None and "en" in res.named.keys():
                     experiment_name = res.named.get("en")
                 if res is not None and "sn" in res.named.keys():
-                    step_index = res.named.get("sn")
-                    if step_index.isnumeric():
-                        step_name = f"{experiment_name}-{int(step_index):02d}"
-                    else:
-                        step_name = f"{experiment_name}-{step_index}"
-            if step_name == "":
-                raise ValueError(f"Step name not found")
+                    step_name = res.named.get("sn")
+            if str(step_name) == "":
+                raise ValueError(f"Step name not found, break reading steps")
+            step_name = f"{experiment_name}-{step_num_parse(step_name)}"
         except (TypeError, ValueError, IndexError):
             # When parsing the step name fails, the end of the file has been reached
             # raise
@@ -417,7 +374,7 @@ def get_raw_data(file_contents: List[List[Union[int, float, str, bool, list]]],
         step_list.append(current_step)
         idx = data_index[28] * len(step_list)
         if not check_box_index[0] or len(step_list) >= 500:  # check_box_index[0]: multiple sequences
-            print(f"Multiple Sequence = {check_box_index[0]}, Step number = {len(step_list)}")
+            # print(f"Multiple Sequence = {check_box_index[0]}, Step number = {len(step_list)}")
             break
 
     if not step_list:

{ararpy-0.1.34 → ararpy-0.1.36}/ararpy/smp/diffusion_funcs.py

@@ -4436,7 +4436,7 @@ def get_random_dir(path: str, length=7, random_index=""):
     try:
         exist_ok = random_index != ""
         if random_index == "":
-            random_index = calc.basic.get_random_digits(length=length)
+            random_index = calc.basic.get_random_string(length=length)
         destination_folder = os.path.join(path, random_index)
         os.makedirs(destination_folder, exist_ok=exist_ok)
         return destination_folder, random_index