ararpy 0.1.12__py3-none-any.whl → 0.1.13__py3-none-any.whl

ararpy/calc/arr.py

@@ -541,7 +541,8 @@ def get_item(obj: list, loc: (list, tuple, int), default: Union[str, int, float,
         return get_item(obj[loc[0] - base[0]], loc[1:], base=base[1:], default=default)
     except (IndexError, TypeError, ValueError):
         return default
-    raise ValueError(f"Cannot get a item from {obj = }, {loc = }")
+    except:
+        raise ValueError(f"Cannot get a item from {obj = }, {loc = }")
 
 
 # =======================

ararpy/calc/basic.py

@@ -10,9 +10,30 @@
 #
 """
 import copy
+import random
+import string
+from datetime import datetime, timezone, timedelta
+import pytz
 
 
-def get_datetime(t_year: int, t_month: int, t_day: int, t_hour: int, t_min: int, t_seconds: int = 0, base=None):
+def utc_dt(dt: datetime, tz: str = "utc", is_dst: bool = False) -> datetime:
+    """
+    Parameters
+    ----------
+    dt
+    tz
+    is_dst: only valid when an ambiguous time inputted
+
+    Returns
+    -------
+
+    """
+    tz = pytz.timezone(tz)
+    return tz.localize(dt, is_dst).astimezone(pytz.utc)
+
+
+def get_datetime(t_year: int, t_month: int, t_day: int, t_hour: int, t_min: int, t_seconds: int = 0,
+                 tz_hour: int = 0, tz_min: int = 0, base=None):
     """
     :param t_year: int
     :param t_month: int
@@ -20,22 +41,19 @@ def get_datetime(t_year: int, t_month: int, t_day: int, t_hour: int, t_min: int,
     :param t_hour: int
     :param t_min: int
     :param t_seconds: int, default == 0
+    :param tz_hour: int, default == 0
+    :param tz_min: int, default == 0
     :param base: base time [y, m, d, h, m]
-    :return: seconds since 1970-1-1 8:00
+    :return: seconds since 1970-1-1 0:00
     """
-    t_year, t_month, t_day, t_hour, t_min, t_seconds = \
-        int(t_year), int(t_month), int(t_day), int(t_hour), int(t_min), int(t_seconds)
+    t_year, t_month, t_day, t_hour, t_min, t_seconds, tz_hour, tz_min = \
+        int(t_year), int(t_month), int(t_day), int(t_hour), int(t_min), int(t_seconds), int(tz_hour), int(tz_min)
     if base is None:
-        base = [1970, 1, 1, 8, 0]
-    base_year, base_mouth, base_day, base_hour, base_min = base
-    if t_year % 4 == 0 and t_year % 100 != 0 or t_year % 400 == 0:
-        days = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-    else:
-        days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-    delta_seconds = ((((t_year - base_year) * 365 + ((t_year + 1 - base_year) - (t_year + 1 - base_year) % 4) / 4 +
-                       sum(days[base_mouth - 1:t_month - 1]) + t_day - base_day) * 24 + t_hour - base_hour) * 60 +
-                     t_min - base_min) * 60 + t_seconds
-    return delta_seconds
+        base = [1970, 1, 1, 0, 0]
+    base = datetime(*base, tzinfo=timezone.utc).timestamp()
+    ts = datetime(t_year, t_month, t_day, t_hour, t_min, t_seconds,
+                  tzinfo=timezone(offset=timedelta(hours=tz_hour, minutes=tz_min))).timestamp()
+    return ts - base
 
 
 def merge_dicts(a: dict, b: dict):
@@ -78,3 +96,7 @@ def update_dicts(a: dict, b: dict):
         else:
             res[key] = val
     return res
+
+
+def get_random_digits(length: int = 7) -> str:
+    return ''.join(random.choices(string.digits, k=length))

ararpy/calc/corr.py

@@ -11,7 +11,7 @@
 """
 import traceback
 
-from . import arr, err
+from . import arr, err, basic
 import numpy as np
 from typing import Tuple, List, Optional, Union
 from types import MethodType
@@ -169,8 +169,8 @@ def get_decay_factor(t1: list, t2: list, t3: list, f: float, sf: float,
     v2 = []
     e1 = []
     # t_year, t_month, t_day, t_hour, t_min = t1
-    t_test_start = get_datetime(*t1)  # the time when analysis began
-    t2 = [get_datetime(*i) for i in t2]  # the time when irradiation ended for all cycles, in second
+    t_test_start = basic.get_datetime(*t1)  # the time when analysis began
+    t2 = [basic.get_datetime(*i) for i in t2]  # the time when irradiation ended for all cycles, in second
     k2 = [t_test_start - i for i in t2]  # standing time in second between irradiation and analysing
 
     try:
@@ -203,33 +203,6 @@ def get_decay_factor(t1: list, t2: list, t3: list, f: float, sf: float,
         return k0, k1
 
 
-def get_datetime(t_year: int, t_month: int, t_day: int, t_hour: int, t_min: int,
-                 t_seconds: int = 0, base=None):
-    """
-    :param t_year: int
-    :param t_month: int
-    :param t_day: int
-    :param t_hour: int
-    :param t_min: int
-    :param t_seconds: int, default == 0
-    :param base: base time [y, m, d, h, m]
-    :return: seconds since 1970-1-1 8:00
-    """
-    t_year, t_month, t_day, t_hour, t_min, t_seconds = \
-        int(t_year), int(t_month), int(t_day), int(t_hour), int(t_min), int(t_seconds)
-    if base is None:
-        base = [1970, 1, 1, 8, 0]
-    base_year, base_mouth, base_day, base_hour, base_min = base
-    if t_year % 4 == 0 and t_year % 100 != 0 or t_year % 400 == 0:
-        days = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-    else:
-        days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-    delta_seconds = ((((t_year - base_year) * 365 + ((t_year + 1 - base_year) - (t_year + 1 - base_year) % 4) / 4 +
-                       sum(days[base_mouth - 1:t_month - 1]) + t_day - base_day) * 24 + t_hour - base_hour) * 60 +
-                     t_min - base_min) * 60 + t_seconds
-    return delta_seconds
-
-
 def get_irradiation_datetime_by_string(datetime_str: str):
     """
     Parameters

ararpy/calc/raw_funcs.py

@@ -57,11 +57,11 @@ def get_raw_data_regression_results(points_data, unselected: list = None):
         except TypeError or IndexError:
             line_data, line_results, reg_coeffs = [], ['NotEnoughPoints', np.nan, np.nan, np.nan, ], []
         except ZeroDivisionError:
-            line_data, line_results, reg_coeffs = [], [np.inf, np.nan, np.nan, np.nan, ], []
+            line_data, line_results, reg_coeffs = [], ['ZeroDivisionError', np.nan, np.nan, np.nan, ], []
         except ValueError:
             line_data, line_results, reg_coeffs = [], ['BadFitting', np.nan, np.nan, np.nan, ], []
         except:
-            line_data, line_results, reg_coeffs = [], [np.nan, np.nan, np.nan, np.nan, ], []
+            line_data, line_results, reg_coeffs = [], ['UncaughtError', np.nan, np.nan, np.nan, ], []
         # linesData.append(line_data)
         linesResults.append(line_results)
         regCoeffs.append(reg_coeffs)

ararpy/calc/regression.py

@@ -937,7 +937,9 @@ def exponential(a0: list, a1: list):
         raise RuntimeError
     except np.linalg.LinAlgError:
         raise np.linalg.LinAlgError
-    except TypeError or IndexError:
+    except TypeError:
+        raise TypeError
+    except IndexError:
         raise IndexError
 
     f = linest(a0, [b ** _x for _x in a1])

ararpy/files/calc_file.py

@@ -342,7 +342,7 @@ def general_adjustment(
         irradiation_name: str
 ):
     """
-        General handle for all age files, including set irradiaition time, initial ratios, error display
+        General handle for all age files, including set irradiation time, initial ratios, error display
     :param total_param:
     :param logs02:
     :param experimental_time:

ararpy/files/raw_file.py

@@ -21,6 +21,7 @@ from datetime import datetime
 from parse import parse as string_parser
 import dateutil.parser as datetime_parser
 from ..calc.arr import get_item
+from ..calc.basic import utc_dt
 
 """ Open raw data file """
 
@@ -159,16 +160,15 @@ def open_raw_xls(file_path, input_filter: List[Union[str, int]]):
         raise ValueError("The file does not comply with the extension in the given filter.")
 
     def _get_content_from_sheet(_index) -> List[List[Union[str, bool, int, float]]]:
-        _sheet = wb.sheet_by_index(_index)
-        return [[_sheet.cell(_row, _col).value for _col in range(_sheet.ncols)] for _row in range(_sheet.nrows)]
+        try:
+            _sheet = wb.sheet_by_index(_index)
+        except IndexError:
+            return []
+        else:
+            return [[_sheet.cell(_row, _col).value for _col in range(_sheet.ncols)] for _row in range(_sheet.nrows)]
 
     wb = open_workbook(file_path)
-    used_sheet_index = set([input_filter[i] - 1 if input_filter[i] != 0 else 0 for i in
-                            [4, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87,
-                             90, 93, 96, 99, 102, 105, 108, 111, 114, 117, 120, 123, 126, 129]])
-    contents = [[] if i not in used_sheet_index else _get_content_from_sheet(i)
-                for i in range(max(used_sheet_index) + 1)]
-
+    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])
     step_list = get_raw_data(contents, input_filter, file_name=file_name)
 
@@ -201,13 +201,15 @@ def get_raw_data(file_contents: List[List[Union[int, float, str, bool, list]]],
 
     """
 
-    def datetime_parse(string, format):
+    def datetime_parse(string, f):
         try:
-            return datetime.strptime(string, format)
+            return datetime.strptime(string, f)
         except ValueError as v:
-            if len(v.args) > 0 and v.args[0].startswith('unconverted data remains: '):
+            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, format)
+                return datetime.strptime(string, f)
             else:
                 raise
 
@@ -215,52 +217,51 @@ def get_raw_data(file_contents: List[List[Union[int, float, str, bool, list]]],
     idx = step_index = 0
 
     header = input_filter[5]
-    sample_info_index = input_filter[33:64]
     isotopic_data_index = input_filter[8:28]
+    sample_info_index = input_filter[33:65]
+    optional_info_index = input_filter[37:-6]
+    check_box_index = input_filter[-6:]
 
-    while True:
+    timezone = sample_info_index[3] if sample_info_index[3] != "" else "utc"
+    while True:  # measurment steps sloop
         # Zero datetime
         try:
-            if input_filter[134]:  # input_filter[134]: date in one string
-                if sample_info_index[1].strip() != "":
-                    zero_date = datetime_parse(
-                        get_item(file_contents, sample_info_index[15:18], base=[1, 1 - idx, 1]), sample_info_index[1])
-                else:
-                    zero_date = datetime_parser.parse(get_item(file_contents, sample_info_index[15:18], base=[1, 1 - idx, 1]))
+            if check_box_index[2]:  # input_filter[134]: date in one string
+                zero_date = datetime_parse(
+                    get_item(file_contents, sample_info_index[16:19], base=[1, 1 - idx, 1]), sample_info_index[1])
             else:
-                zero_date = datetime(year=get_item(file_contents, sample_info_index[15:18], base=1),
-                                     month=get_item(file_contents, sample_info_index[21:24], base=[1, 1 - idx, 1]),
-                                     day=get_item(file_contents, sample_info_index[27:30], base=[1, 1 - idx, 1]))
-
-            if input_filter[135]:  # input_filter[135]: time in one string
-                if sample_info_index[2].strip() != "":
-                    zero_time = datetime_parse(
-                        get_item(file_contents, sample_info_index[18:21], base=[1, 1 - idx, 1]), sample_info_index[2])
-                else:
-                    zero_time = datetime_parser.parse(get_item(file_contents, sample_info_index[18:21], base=[1, 1 - idx, 1]))
+                zero_date = datetime(year=get_item(file_contents, sample_info_index[16:19], base=1),
+                                     month=get_item(file_contents, sample_info_index[22:25], base=[1, 1 - idx, 1]),
+                                     day=get_item(file_contents, sample_info_index[28:31], base=[1, 1 - idx, 1]))
+
+            if check_box_index[3]:  # input_filter[135]: time in one string
+                zero_time = datetime_parse(
+                    get_item(file_contents, sample_info_index[19:22], base=[1, 1 - idx, 1]), sample_info_index[2])
             else:
                 zero_time = datetime(year=2020, month=12, day=31,
-                                     hour=get_item(file_contents, sample_info_index[18:21], base=[1, 1 - idx, 1]),
-                                     minute=get_item(file_contents, sample_info_index[24:27], base=[1, 1 - idx, 1]),
-                                     second=get_item(file_contents, sample_info_index[30:33], base=[1, 1 - idx, 1]))
-
-            zero_datetime = datetime(zero_date.year, zero_date.month, zero_date.day, zero_time.hour,
-                                 zero_time.minute, zero_time.second).isoformat(timespec='seconds')
+                                     hour=get_item(file_contents, sample_info_index[19:22], base=[1, 1 - idx, 1]),
+                                     minute=get_item(file_contents, sample_info_index[25:28], base=[1, 1 - idx, 1]),
+                                     second=get_item(file_contents, sample_info_index[31:34], base=[1, 1 - idx, 1]))
+
+            zero_datetime = datetime(
+                zero_date.year, zero_date.month, zero_date.day, zero_time.hour, zero_time.minute, zero_time.second)
+            # adjust to UTC
+            zero_datetime = utc_dt(zero_datetime, tz=timezone).isoformat(timespec='seconds')
         except (TypeError, ValueError, IndexError):
             # print(f"Cannot parse zero datetime")
-            zero_datetime = datetime(1949, 10, 1, 10, 0, 0).isoformat(timespec='seconds')
+            zero_datetime = datetime(1970, 1, 1, 0, 0, 0).isoformat(timespec='seconds')
 
         # Experiment name
         try:
-            experiment_name = get_item(file_contents, sample_info_index[3:6], default="", base=[1, 1 - idx, 1]) if input_filter[4] > 0 else ""
+            experiment_name = get_item(file_contents, sample_info_index[4:7], default="", base=[1, 1 - idx, 1])
         except (TypeError, ValueError, IndexError):
             # print(f"Cannot parse experiment name")
-            experiment_name = "ExpNameError"
+            experiment_name = "ExpName"
 
         # Step name
         try:
-            step_name = get_item(file_contents, sample_info_index[6:9], default="", base=[1, 1 - idx, 1]) if input_filter[7] > 0 else ""
-            if input_filter[133] and sample_info_index[0] != "":
+            step_name = get_item(file_contents, sample_info_index[7:10], default="", base=[1, 1 - idx, 1]) if input_filter[7] > 0 else ""
+            if check_box_index[1] and sample_info_index[0].strip() != "":
                 _res = string_parser(sample_info_index[0], file_name)
                 if _res is not None:
                     experiment_name = _res.named.get("en", experiment_name)
@@ -276,15 +277,15 @@ def get_raw_data(file_contents: List[List[Union[int, float, str, bool, list]]],
             break
 
         # other information
-        options = get_sample_info(file_contents, input_filter, default="", base=[1, 1 - idx, 1])
+        options = get_sample_info(file_contents, optional_info_index, default="", base=[1, 1 - idx, 1])
 
         current_step = [[step_name, zero_datetime, experiment_name, options]]
 
         break_num = 0
         cycle_num = 0
-        f = float(input_filter[31])
+        f = float(input_filter[31])  # Intensity Scale Factor
         data_content = file_contents[input_filter[4] - 1 if input_filter[4] != 0 else 0]
-        for i in range(2000):
+        for i in range(2000):  # measurement cycle sloop
             if break_num < input_filter[29]:
                 break_num += 1
                 continue
@@ -307,7 +308,8 @@ def get_raw_data(file_contents: List[List[Union[int, float, str, bool, list]]],
                         float(data_content[start_row + isotopic_data_index[ 0]][isotopic_data_index[ 1] - 1]) * f,
                     ])
                 except (ValueError, IndexError):
-                    # print(f"Cannot parse isotope data")
+                    print(f"Cannot parse isotope data")
+                    print(traceback.format_exc())
                     current_step.append([
                         str(cycle_num + 1), None, None, None, None, None, None, None, None, None, None,
                     ])
@@ -330,7 +332,8 @@ def get_raw_data(file_contents: List[List[Union[int, float, str, bool, list]]],
                         float(data_content[start_row][isotopic_data_index[ 1] + col_inc]) * f,
                     ])
                 except (ValueError, IndexError):
-                    # print(f"Cannot parse isotope data")
+                    print(f"Cannot parse isotope data")
+                    print(traceback.format_exc())
                     current_step.append([
                         str(cycle_num + 1), None, None, None, None, None, None, None, None, None, None,
                     ])
@@ -345,18 +348,18 @@ def get_raw_data(file_contents: List[List[Union[int, float, str, bool, list]]],
         step_index += 1
         idx = input_filter[32] * step_index
 
-        if not input_filter[132] or step_index >= 500:  # input_filter[132]: multiple sequences
+        if not check_box_index[0] or step_index >= 500:  # check_box_index[0]: multiple sequences
             break
 
     return step_list
 
 
-def get_sample_info(file_contents: list, input_filter: list, default="", base=1) -> dict:
+def get_sample_info(file_contents: list, index_list: list, default="", base: Union[int, tuple, list] = 1) -> dict:
     """
     Parameters
     ----------
     file_contents
-    input_filter
+    index_list
     default
     base
 
@@ -364,41 +367,40 @@ def get_sample_info(file_contents: list, input_filter: list, default="", base=1)
     -------
 
     """
-    sample_info_index = input_filter[36:132]
     sample_info = DEFAULT_SAMPLE_INFO.copy()
     sample_info.update({
-        "ExpName": get_item(file_contents, sample_info_index[0:3], default=default, base=base),
-        "StepName": get_item(file_contents, sample_info_index[3:6], default=default, base=base),
-        "SmpType": get_item(file_contents, sample_info_index[6:9], default=default, base=base),
-        "StepLabel": get_item(file_contents, sample_info_index[9:12], default=default, base=base),
-        "ZeroYear": get_item(file_contents, sample_info_index[12:15], default=default, base=base),  # year
-        "ZeroHour": get_item(file_contents, sample_info_index[15:18], default=default, base=base),  # hour
-        "ZeroMon": get_item(file_contents, sample_info_index[18:21], default=default, base=base),  # month
-        "ZeroMin": get_item(file_contents, sample_info_index[21:24], default=default, base=base),  # minute
-        "ZeroDay": get_item(file_contents, sample_info_index[24:27], default=default, base=base),  # day
-        "ZeroSec": get_item(file_contents, sample_info_index[27:30], default=default, base=base),  # second
-        "SmpName": get_item(file_contents, sample_info_index[30:33], default=default, base=base),
-        "SmpLoc": get_item(file_contents, sample_info_index[33:36], default=default, base=base),
-        "SmpMatr": get_item(file_contents, sample_info_index[36:39], default=default, base=base),
-        "ExpType": get_item(file_contents, sample_info_index[39:42], default=default, base=base),
-        "SmpWeight": get_item(file_contents, sample_info_index[42:45], default=default, base=base),
-        "Stepunit": get_item(file_contents, sample_info_index[45:48], default=default, base=base),
-        "HeatingTime": get_item(file_contents, sample_info_index[48:51], default=default, base=base),
-        "InstrName": get_item(file_contents, sample_info_index[51:54], default=default, base=base),
-        "Researcher": get_item(file_contents, sample_info_index[54:57], default=default, base=base),
-        "Analyst": get_item(file_contents, sample_info_index[57:60], default=default, base=base),
-        "Lab": get_item(file_contents, sample_info_index[60:63], default=default, base=base),
-        "Jv": get_item(file_contents, sample_info_index[63:66], default=default, base=base),
-        "Jsig": get_item(file_contents, sample_info_index[66:69], default=default, base=base),
-        "CalcName": get_item(file_contents, sample_info_index[69:72], default=default, base=base),
-        "IrraName": get_item(file_contents, sample_info_index[72:75], default=default, base=base),
-        "IrraLabel": get_item(file_contents, sample_info_index[75:78], default=default, base=base),
-        "IrraPosH": get_item(file_contents, sample_info_index[78:81], default=default, base=base),
-        "IrraPosX": get_item(file_contents, sample_info_index[81:84], default=default, base=base),
-        "IrraPosY": get_item(file_contents, sample_info_index[84:87], default=default, base=base),
-        "StdName": get_item(file_contents, sample_info_index[87:90], default=default, base=base),
-        "StdAge": get_item(file_contents, sample_info_index[90:93], default=default, base=base),
-        "StdAgeSig": get_item(file_contents, sample_info_index[93:96], default=default, base=base),
+        "ExpName": get_item(file_contents, index_list[0:3], default=default, base=base),
+        "StepName": get_item(file_contents, index_list[3:6], default=default, base=base),
+        "SmpType": get_item(file_contents, index_list[6:9], default=default, base=base),
+        "StepLabel": get_item(file_contents, index_list[9:12], default=default, base=base),
+        "ZeroYear": get_item(file_contents, index_list[12:15], default=default, base=base),  # year
+        "ZeroHour": get_item(file_contents, index_list[15:18], default=default, base=base),  # hour
+        "ZeroMon": get_item(file_contents, index_list[18:21], default=default, base=base),  # month
+        "ZeroMin": get_item(file_contents, index_list[21:24], default=default, base=base),  # minute
+        "ZeroDay": get_item(file_contents, index_list[24:27], default=default, base=base),  # day
+        "ZeroSec": get_item(file_contents, index_list[27:30], default=default, base=base),  # second
+        "SmpName": get_item(file_contents, index_list[30:33], default=default, base=base),
+        "SmpLoc": get_item(file_contents, index_list[33:36], default=default, base=base),
+        "SmpMatr": get_item(file_contents, index_list[36:39], default=default, base=base),
+        "ExpType": get_item(file_contents, index_list[39:42], default=default, base=base),
+        "SmpWeight": get_item(file_contents, index_list[42:45], default=default, base=base),
+        "Stepunit": get_item(file_contents, index_list[45:48], default=default, base=base),
+        "HeatingTime": get_item(file_contents, index_list[48:51], default=default, base=base),
+        "InstrName": get_item(file_contents, index_list[51:54], default=default, base=base),
+        "Researcher": get_item(file_contents, index_list[54:57], default=default, base=base),
+        "Analyst": get_item(file_contents, index_list[57:60], default=default, base=base),
+        "Lab": get_item(file_contents, index_list[60:63], default=default, base=base),
+        "Jv": get_item(file_contents, index_list[63:66], default=default, base=base),
+        "Jsig": get_item(file_contents, index_list[66:69], default=default, base=base),
+        "CalcName": get_item(file_contents, index_list[69:72], default=default, base=base),
+        "IrraName": get_item(file_contents, index_list[72:75], default=default, base=base),
+        "IrraLabel": get_item(file_contents, index_list[75:78], default=default, base=base),
+        "IrraPosH": get_item(file_contents, index_list[78:81], default=default, base=base),
+        "IrraPosX": get_item(file_contents, index_list[81:84], default=default, base=base),
+        "IrraPosY": get_item(file_contents, index_list[84:87], default=default, base=base),
+        "StdName": get_item(file_contents, index_list[87:90], default=default, base=base),
+        "StdAge": get_item(file_contents, index_list[90:93], default=default, base=base),
+        "StdAgeSig": get_item(file_contents, index_list[93:96], default=default, base=base),
         # "Experiment Name": get_item(file_contents, sample_info_index[0:3], default=default, base=base),
         # "Step Name": get_item(file_contents, sample_info_index[3:6], default=default, base=base),
         # "Sample Type": get_item(file_contents, sample_info_index[6:9], default=default, base=base),

ararpy/smp/EXPORT_TO_PDF_DATA_PROPERTIES.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+"""
+# ==========================================
+# Copyright 2024 Yang 
+# webarar - EXPORT_TO_PDF_DATA_PROPERTIES
+# ==========================================
+#
+#
+# 
+"""
+
+def plot_data(data: dict):
+    """
+
+    Parameters
+    ----------
+    data: dict
+        - file_name: string
+            file name, like "24WHA0001"
+        - data: list of dicts
+            properties:
+            - name: string
+                diagram name, like "Age spectra"
+
+            - xAxis: list
+                properties:
+                - extend: list
+                    limits of values of axis, like [0, 100]
+                - interval: list
+                    sticks location, like [0, 20, 40, 60, 80, 100]
+                - title: string
+                - nameLocation: string
+                    axis title location, 'middle'
+
+            - yAxis: same as xAxis
+
+            - series: list
+                properties:
+                - type: string
+                    series type, 'line', 'scatter', 'text', and any string contains these characters
+                - id: string
+                - name: string
+                - color: string or list
+                    color for outlines, color name | RGB triplet | Hex color code
+                - fillColor: string or list
+                    color for filling markers, format is similar to that of color
+                - data: 2-dimensional array
+                    [[x1, y1], [x2, y2], ...]
+
+                optional:
+                - lineCaps: string
+                    for lines only, 'square', 'none', 'butt'
+                - text: string
+                    for texts only
+                - size: int
+                    for scatters only
+
+
+    Returns
+    -------
+
+    """
+    pass
+
+
+data = {
+    "data": [
+        {
+            'name': 'spectra',
+            'xAxis': [{'extent': [0, 100], 'interval': [0, 20, 40, 60, 80, 100],
+                       'title': 'Cumulative <sup>39</sup>Ar Released (%)', 'title_location': 'middle', }],
+            'yAxis': [{'extent': [0, 25], 'interval': [0, 5, 10, 15, 20, 25],
+                       'title': 'Apparent Age (Ma)', 'title_location': 'middle', }],
+            'series': [
+                {
+                    'type': 'text', 'id': f'text_0', 'name': f'text_0', 'color': '#222222',
+                    'text': f'xxx<r>xxxxxx', 'size': 10,
+                    'data': [[5, 23]],
+                },
+                {
+                    'type': 'series.line', 'id': f'line_0', 'name': f'line_0',
+                    'color': '#333333',
+                    'data': [[]], 'line_caps': 'square',
+                },
+                {
+                    'type': 'series.line', 'id': f'line_2', 'name': f'line_2',
+                    'color': '#555555',
+                    'data': [[]], 'line_caps': 'square',
+                }
+            ]
+        }
+    ],
+    "file_name": "WHA"
+}

ararpy/smp/basic.py

@@ -11,6 +11,7 @@
 """
 # === Internal imports ===
 import os
+import re
 import traceback
 import pandas as pd
 import numpy as np
@@ -521,15 +522,15 @@ def set_params(smp: Sample, params: Union[List, str], flag: Optional[str] = None
             smp.TotalParam[30] = [params[-5]] * n
         try:
             stand_time_second = [
-                calc.basic.get_datetime(*smp.TotalParam[31][i].split('-')) - calc.basic.get_datetime(
-                    *smp.TotalParam[30][i].split('-')) for i in range(n)]
-        except Exception as e:
-            # print(f'Error in calculate standing duration: {traceback.format_exc()}')
-            pass
+                calc.basic.get_datetime(*re.findall(r"\d+", smp.TotalParam[31][i])) - calc.basic.get_datetime(
+                    *re.findall(r"\d+", smp.TotalParam[30][i])) for i in range(n)]
+        except TypeError:
+            print(f'Error in calculate standing duration: {traceback.format_exc()}')
         else:
             smp.TotalParam[32] = [i / (3600 * 24 * 365.242) for i in stand_time_second]  # stand year
 
     elif flag == 'smp':
+        print(params)
         smp.TotalParam[67:71] = remove_none(smp.TotalParam[67:71], params[0:4], n, 71 - 67)
         smp.TotalParam[58:67] = remove_none(smp.TotalParam[58:67], params[4:13], n, 67 - 58)
         smp.TotalParam[97:100] = remove_none(smp.TotalParam[97:100], params[13:16], n, 100 - 97)

ararpy/smp/calculation.py

@@ -64,10 +64,10 @@ def recalculate(
     if re_initial:  # 1
         initial.re_set_smp(sample)
     # --- calculating ---
-    if re_corr_blank:  # 2
-        corr.corr_blank(sample)
     if re_corr_gain:  # 2 2024-10-04 add
         corr.corr_gain(sample)
+    if re_corr_blank:  # 2
+        corr.corr_blank(sample)
     if re_corr_massdiscr:  # 3
         corr.corr_massdiscr(sample)
     if re_corr_decay:  # 4