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

ararpy/calc/arr.py

@@ -499,6 +499,8 @@ def transpose(obj, ignore: bool = True):
 
     """
     try:
+        if len(obj) == 0:
+            return obj
         if not is_twoD(obj):
             raise ValueError("The requested object is not two dimensional.")
         obj = obj if is_homo(obj) else homo(obj)
@@ -539,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
@@ -30,6 +30,18 @@ def blank(a0: list, e0: list, a1: list, e1: list):
     return arr.sub((a0, e0), (a1, e1))
 
 
+def gain(a0: list, e0: list, a1: list, e1: list):
+    """
+    :param a0: a list of tested isotope value
+    :param e0: 1 sigma error of a0, list type
+    :param a1: a list of blank isotope value
+    :param e1: 1 sigma error of a1, list type
+    :return: list of corrected data | error list
+    """
+    # Do not force negative value to zero in correcting blank...
+    return arr.div((a0, e0), (a1, e1))
+
+
 def mdf(rm: float, srm: float, m1: float, m2: float, ra: float = 298.56,
         sra: float = 0):
     """
@@ -157,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:
@@ -191,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/isochron.py

@@ -134,7 +134,7 @@ def get_ellipse(x: float, sx: float, y: float, sy: float, r: float, plt_sfactor:
     return ellipse_points
 
 
-def get_line_points(xscale, yscale, coeffs=None):
+def get_line_points(xscale, yscale, coeffs):
     """
 
     Parameters
@@ -147,7 +147,9 @@ def get_line_points(xscale, yscale, coeffs=None):
     -------
     List of data points
     """
-
+    xscale = [float(i) for i in xscale]
+    yscale = [float(i) for i in yscale]
+    coeffs = [float(i) for i in coeffs]
     if not isinstance(coeffs, list) or len(coeffs) < 2:
         raise ValueError(f"Coeffs should be a list with length with 2.")
     get_y = lambda x: coeffs[0] + coeffs[1] * x

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])