ararpy 0.0.1a1__py3-none-any.whl

ararpy/files/json.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+"""
+# ==========================================
+# Copyright 2023 Yang
+# ararpy - files - json
+# ==========================================
+#
+#
+#
+"""
+from ..smp import Sample, Info, Table, Plot
+
+import json
+import numpy as np
+import pandas as pd
+
+
+def dumps(a):
+    # return json.dumps(a, default=lambda o: o.__dict__ if hasattr(0, '__dict__') else o, sort_keys=True, indent=4)
+    return json.dumps(a, cls=MyEncoder, indent=4)
+
+
+def loads(a):
+    return json.loads(a)
+
+
+class MyEncoder(json.JSONEncoder):
+    def default(self, obj):
+        # np.array
+        if isinstance(obj, np.ndarray):
+            return obj.tolist()
+        # pd.DataFrame
+        if isinstance(obj, pd.DataFrame):
+            print(obj)
+            raise ValueError(f"DataFrame objects found.")
+        # complex number
+        if isinstance(obj, complex):
+            return "complex number"
+        # numpy.int32
+        if isinstance(obj, np.int32):
+            return int(obj)
+        # sample instance
+        if isinstance(obj, (Sample, Info, Plot, Table, Plot.Text,
+                            Plot.Axis, Plot.Label, Plot.Set, Plot.BasicAttr)):
+            return obj.__dict__
+        if not isinstance(obj, (int, str, list, dict, tuple, float)):
+            print(f"Special type, {type(obj) = }, {obj = }")
+        return super(MyEncoder, self).default(obj)

ararpy/files/new_file.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+"""
+# ==========================================
+# Copyright 2023 Yang 
+# webarar - new_file
+# ==========================================
+#
+#
+# 
+"""
+from .. import smp
+
+
+def to_sample(file_path: str = '', sample_name: str = None):
+    """
+    Parameters
+    ----------
+    file_path
+    sample_name
+
+    Returns
+    -------
+
+    """
+    sample = smp.Sample()
+    # initial settings
+    smp.initial.initial(sample)
+    if sample_name is not None:
+        sample.Info.sample.name = sample_name
+    return sample

ararpy/files/raw.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+"""
+# ==========================================
+# Copyright 2023 Yang
+# ararpy - files - raw
+# ==========================================
+#
+#
+#
+"""
+import traceback
+from xlrd import open_workbook
+
+
+def open_file(filepath: str, extension: str = 'xls'):
+    """
+    :param filepath: directory of file
+    :param extension: filter 1 for .xls files, 2 for .ahd files
+    :return: step_list -> [[[header of step one], [cycle one in the step], [cycle two in the step]],[[],[]]]
+        example:
+            [
+                [
+                    [1, '6/8/2019  8:20:51 PM', 'BLK', 'B'],  # step header
+                    # [sequence index, date time, label, value]
+                    ['1', 12.30, 87.73, 12.30, 1.30, 12.30, 0.40, 12.30, 0.40, 12.30, 0.44],  # step/sequence 1
+                    # [cycle index, time, Ar40 signal, time, Ar39 signal, ..., time, Ar36 signal]
+                    ['2', 24.66, 87.70, 24.66, 1.14, 24.66, 0.36, 24.66, 0.35, 24.66, 0.43],  # step/sequence 2
+                    ...
+                    ['10', 123.06, 22262.68, 123.06, 6.54, 123.06, 8.29, 123.06, 0.28, 123.06, 29.22],
+                ],
+                [
+                    ...
+                ]
+            ]
+    """
+    try:
+        handler = {'xls': open_raw_xls, 'ahd': open_raw_ahd}[extension.lower()]
+    except KeyError:
+        print(traceback.format_exc())
+        return False
+    else:
+        return handler(filepath)
+
+
+def open_raw_xls(filepath):
+    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])
+                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]],
+                    [value[i] for i in range(row_start_number + 2, row_stop_number - 7, 1)]))
+            ]
+            step_list.append(step_values)
+    except Exception as e:
+        print('Error in opening the original file: %s' % str(e))
+        return False
+    else:
+        return step_list
+
+
+def open_raw_ahd(filepath):
+    try:
+        value, step_header, step_list = [], [], []
+        with open(filepath, 'r', encoding='utf-16-le') as f:
+            value = f.read()
+        value = [[j for j in i.split('\t') if j != ''] for i in value.split('\n')]
+        datetime = 'ddmmyyyy'
+        if datetime == 'ddmmyyyy':
+            dd, mm, yyyy = value[6][1].split('/')
+            value[6][1] = '/'.join([mm, dd, yyyy])
+        step_count = int(value[12][2])
+        step_header = [1, '  '.join(value[6][1:3]), value[0][1], value[8][1]]
+        step_list.append([step_header])
+        for step_index in range(step_count):
+            start_row = 15 + 5 * step_index
+            step_list[0].append([
+                str(step_index+1),
+                float(value[start_row+4][0]), float(value[start_row+4][1]),
+                float(value[start_row+3][0]), float(value[start_row+3][1]),
+                float(value[start_row+2][0]), float(value[start_row+2][1]),
+                float(value[start_row+1][0]), float(value[start_row+1][1]),
+                float(value[start_row+0][0]), float(value[start_row+0][1]),
+            ])
+    except Exception as e:
+        print('Error in opening the original file: %s' % str(e))
+        return False
+    else:
+        return step_list
+
+

ararpy/files/raw_file.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+"""
+# ==========================================
+# Copyright 2023 Yang 
+# webarar - raw_file
+# ==========================================
+#
+#
+# 
+"""
+
+pass
+

ararpy/files/xls.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+"""
+# ==========================================
+# Copyright 2023 Yang
+# ararpy - files - xls
+# ==========================================
+#
+#
+#
+"""
+from xlrd import open_workbook, biffh
+
+
+def open_xls(filepath: str):
+    res = {}
+    try:
+        wb = open_workbook(filepath)
+        for sheet_name in wb.sheet_names():
+            sheet = wb.sheet_by_name(sheet_name)
+            res[sheet_name] = [[sheet.cell(row, col).value for col in range(sheet.ncols)] for row in range(sheet.nrows)]
+    except biffh.XLRDError as e:
+        print('Error in opening excel file: %s' % str(e))
+        return e
+    else:
+        return res
+

ararpy/smp/__init__.py

@@ -0,0 +1,17 @@
+
+from . import (
+    sample as samples, consts, basic, corr, initial,
+    plots, style, table, calculation
+)
+
+Sample = samples.Sample
+Info = samples.Info
+Table = samples.Table
+Plot = samples.Plot
+Set = samples.Plot.Set
+Label = samples.Plot.Label
+Axis = samples.Plot.Axis
+Text = samples.Plot.Text
+
+VERSION = samples.VERSION
+

ararpy/smp/basic.py

@@ -0,0 +1,371 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+"""
+# ==========================================
+# Copyright 2023 Yang
+# ararpy - smp - basic
+# ==========================================
+#
+#
+#
+"""
+# === Internal imports ===
+
+import traceback
+import pandas as pd
+import numpy as np
+import copy
+from .. import calc
+from .sample import Sample, Info, Table, Plot
+
+Set = Plot.Set
+Label = Plot.Label
+Axis = Plot.Axis
+Text = Plot.Text
+
+pd.options.mode.chained_assignment = None  # default='warn'
+
+
+# =======================
+# Calculate ages
+# =======================
+def calc_apparent_ages(smp: Sample):
+    """
+
+    Parameters
+    ----------
+    smp
+
+    Returns
+    -------
+
+    """
+    age = calc_age(smp=smp)
+    smp.ApparentAgeValues[2:6] = age
+    smp.PublishValues[5:7] = copy.deepcopy(age[0:2])
+
+
+def calc_age(ar40ar39=None, params: dict = None, smp: Sample = None, index: list = None):
+    """
+    40Ar/39Ar age calculation, two methods are supported: Min et al. (2000) or general equation.
+    Parameters
+    ----------
+    ar40ar39 : 2D DataFrame, Series, list
+    params : dict
+    smp : Sample instance
+    index:
+
+    Returns
+    -------
+
+    """
+    params_index_dict = {
+        34: 'L', 35: 'sL', 36: 'Le', 37: 'sLe', 38: 'Lb', 39: 'sLb', 48: 'A', 49: 'sA',
+        50: 'Ae', 51: 'sAe', 52: 'Ab', 53: 'sAb', 59: 't', 60: 'st', 67: 'J', 68: 'sJ',
+        81: 'W', 82: 'sW', 83: 'No', 84: 'sNo', 85: 'Y', 86: 'sY', 87: 'f', 88: 'sf', 110: 'Min'
+    }
+
+    if isinstance(ar40ar39, pd.Series):
+        ar40ar39 = [ar40ar39.tolist(), [0] * ar40ar39.size]
+    if isinstance(ar40ar39, pd.DataFrame):
+        ar40ar39 = ar40ar39.transpose().values.tolist()
+    if ar40ar39 is None and smp is not None:
+        ar40ar39 = smp.ApparentAgeValues[0:2]
+    if len(np.shape(ar40ar39)) == 1:
+        ar40ar39 = np.reshape(ar40ar39, (2, 1))
+    if index is None:
+        index = list(range(np.shape(ar40ar39)[-1]))
+
+    if smp is None and params is None:
+        raise ValueError(f"Parameters are required for calculating ages, or it is empty.")
+    if params is not None:
+        for key, val in params.items():
+            if not isinstance(val, list):
+                params[key] = list(val)
+    if smp is not None:
+        try:
+            params_from_smp = dict(zip(
+                list(params_index_dict.values()),
+                [[smp.TotalParam[i][j] for j in index] for i in params_index_dict.keys()]
+            ))
+        except Exception:
+            print(traceback.format_exc())
+            raise ValueError(f"Parameters cannot be found in the given sample object")
+        if params is not None:
+            params_from_smp.update(params)
+        params = params_from_smp
+
+    # check if using Min equation
+    params['Min'] = [i if isinstance(i, bool) else False for i in params['Min']]
+
+    idx1 = np.flatnonzero(np.where(params['Min'], True, False))  # True, using Min euqation
+    idx2 = np.flatnonzero(np.where(params['Min'], False, True))  # False
+    k1, k2 = [], []
+    if np.size(idx1) > 0:
+        k1 = calc.age.calc_age_min(
+            F=[ar40ar39[0][i] for i in idx1], sF=[ar40ar39[1][i] for i in idx1],
+            **dict(zip(params.keys(), [[val[i] for i in idx1] for val in params.values()])))
+    if np.size(idx2) > 0:
+        k2 = calc.age.calc_age_general(
+            F=[ar40ar39[0][i] for i in idx2], sF=[ar40ar39[1][i] for i in idx2],
+            **dict(zip(params.keys(), [[val[i] for i in idx2] for val in params.values()])))
+
+    # idx1 = params[params['Min'].astype(bool)].index
+    # idx2 = params[~params['Min'].astype(bool)].index  # The operators are: | for or, & for and, and ~ for not
+    # k1, k2 = [], []
+    # if idx1.size > 0:
+    #     k1 = calc.age.calc_age_min(
+    #         F=ar40ar39.take(idx1)[0], sF=ar40ar39.take(idx1)[1], **params.take(idx1).to_dict('list'))
+    # if idx2.size > 0:
+    #     k2 = calc.age.calc_age_general(
+    #         F=ar40ar39.take(idx2)[0], sF=ar40ar39.take(idx2)[1], **params.take(idx2).to_dict('list'))
+
+    columns = ['age', 's1', 's2', 's3']
+    ages = pd.concat([
+        pd.DataFrame([*k1], columns=idx1, index=columns),
+        pd.DataFrame([*k2], columns=idx2, index=columns)
+    ], axis=1).transpose().reset_index(drop=True)
+
+    if len(index) == 1:
+        return ages.transpose().squeeze().tolist()
+    else:
+        return ages.transpose().values.tolist()
+
+
+# =======================
+# Search components
+# =======================
+def get_content_dict(smp: Sample):
+    """
+
+    Parameters
+    ----------
+    smp
+
+    Returns
+    -------
+
+    """
+    return dict(zip(
+        ['smp', 'blk', 'cor', 'deg', 'pub', 'age', 'iso', 'pam', 'mak', 'seq'],
+        [smp.SampleIntercept, smp.BlankIntercept, smp.CorrectedValues, smp.DegasValues,
+         smp.PublishValues, smp.ApparentAgeValues, smp.IsochronValues, smp.TotalParam,
+         [smp.IsochronMark], [smp.SequenceName, smp.SequenceValue]]
+    ))
+
+
+def get_dict_from_obj(obj: (Sample, Info, Plot, Table, Set, Label, Axis, Text)):
+    """
+
+    Parameters
+    ----------
+    obj
+
+    Returns
+    -------
+
+    """
+    res = {}
+    for key, attr in obj.__dict__.items():
+        if not isinstance(attr, (Sample, Info, Plot, Table, Set, Label, Axis, Text)):
+            res.update({key: attr})
+        else:
+            res.update({key: get_dict_from_obj(attr)})
+    return res
+
+
+def get_components(smp: Sample):
+    """
+    Get updated sample.Components dict
+    Parameters
+    ----------
+    smp
+
+    Returns
+    -------
+
+    """
+    components_name = [
+        '0', '1', '2', '3', '4', '5', '6', '7', '8',
+        'figure_1', 'figure_2', 'figure_3', 'figure_4', 'figure_5', 'figure_6', 'figure_7', 'figure_8', 'figure_9',
+    ]
+    components = {}
+    for key in components_name:
+        comp = get_component_byid(smp, key)
+        components.update({key: comp})
+    return components
+
+
+def get_component_byid(smp: Sample, comp_id: str):
+    """
+    Get a component (Table or Plot) based on input id
+    Parameters
+    ----------
+    smp
+    comp_id
+
+    Returns
+    -------
+
+    """
+    for key, val in smp.__dict__.items():
+        if isinstance(val, (Plot, Table, Info)) and getattr(val, 'id') == comp_id:
+            return val
+
+
+def get_plot_set(plot: Plot, comp_id):
+    """
+    Get a Set, Text, Axis, Label of a sample instance based on given id
+    """
+    for v in [getattr(plot, k) for k in dir(plot)]:
+        if isinstance(v, Plot.BasicAttr) and v.id.lower() == comp_id.lower():
+            return v
+    return None
+
+
+# =======================
+# Update
+# =======================
+def update_plot_from_dict(plot, attrs: dict):
+    """
+    plot is a Sample.Plot instance, attrs should be a dict like {'xaxis': {'show_splitline': False}, 'yaxis': {...}}
+    """
+
+    def _do(plot, attrs: dict):
+        for k1, v1 in attrs.items():
+            if isinstance(v1, dict):
+                if hasattr(plot, k1):
+                    if isinstance(getattr(plot, k1), dict):
+                        setattr(plot, k1, v1)
+                    else:
+                        _do(getattr(plot, k1), v1)
+            else:
+                setattr(plot, k1, v1)
+
+    _do(plot=plot, attrs=attrs)
+    return plot
+
+
+# =======================
+# Merge sample instances
+# =======================
+def get_merged_smp(a: Sample, b: (Sample, dict)):
+    """ Comparing two sample instances a and b
+        This function is used to update sample instance to make sure JS can read properties it required.
+    Parameters
+    ----------
+    a : sample instance that has old attributes,
+    b : new sample instance that has some new attributes or a has similar but different name for this attribute
+
+    Returns
+    -------
+    None
+        return none, but a will be updated after calling this function
+
+            for example:
+                A = Sample(id = 'a', set1 = Set(id = 'set1', data = [], symbolSize = 10)),
+                B = Sample(id = 'b', set1 = Set(id = 'set1', data = [2023], symbol_size = 5, line_type = 'solid')),
+                after get_merged_smp(A, B), A will be Sample(id = 'a', 'set1' = Set(id = 'set1', data = [],
+                                                        symbol_size = 10, line_type = 'solid'))
+    """
+
+    def get_similar_name(_name: str):
+        res = []
+        for i in range(len(_name) + 1):
+            str_list = [i for i in _name]
+            str_list.insert(i, '_')
+            res.append(''.join(str_list))
+        for i in range(len(_name)):
+            str_list = [i for i in _name]
+            str_list[i] = str_list[i].capitalize()
+            res.append(''.join(str_list))
+        for i in range(len(_name)):
+            str_list = [i for i in _name]
+            if _name[i] in '-_':
+                str_list.pop(i)
+                res.append(''.join(str_list))
+        return res
+
+    if not isinstance(b, dict):
+        b = b.__dict__
+
+    for name, attr in b.items():
+        if hasattr(a, name):
+            if isinstance(attr, (Plot, Table, Info, Plot.BasicAttr)):
+                if not type(getattr(a, name)) == type(attr):
+                    setattr(a, name, type(attr)())
+                get_merged_smp(getattr(a, name), attr)
+            if isinstance(attr, dict) and isinstance(getattr(a, name), dict):
+                setattr(a, name, calc.basic.merge_dicts(getattr(a, name), attr))
+            if isinstance(attr, list) and isinstance(getattr(a, name), list):
+                if len(attr) > len(getattr(a, name)):
+                    setattr(a, name, getattr(a, name) + attr[len(getattr(a, name)):])
+            continue
+        else:
+            for xxx in get_similar_name(name):
+                for xx in get_similar_name(xxx):
+                    for x in get_similar_name(xx):
+                        if hasattr(a, x):
+                            # print(f'Has similar {name} = {x}: {getattr(a, x)}')
+                            setattr(a, name, getattr(a, x))
+                            break
+                    else:
+                        continue
+                    break
+                else:
+                    continue
+                break
+            if not hasattr(a, name):
+                setattr(a, name, attr)
+
+
+# =======================
+# Difference between two sample instances
+# =======================
+def get_diff_smp(backup: (dict, Sample), smp: (dict, Sample)):
+    """ Comparing two sample component dicts or sample instances, and return difference between them.
+    Parameters
+    ----------
+    backup : backup of sample.Components or sample before changed.
+    smp : sample.Components or sample after changed
+
+    Returns
+    -------
+    dict
+        dict of keys and values that have difference, iterate to a sepcial difference,
+
+            for example:
+                A = Sample(id = 'a', set1 = Set(id = 'set1', data = [])),
+                B = Sample(id = 'b', set1 = Set(id = 'set1', data = [2023])),
+                res = get_diff_smp(A, B) will be {'id': 'b', 'set1': {'data': [2023]}}
+
+    """
+    res = {}
+    if isinstance(backup, Sample) and isinstance(smp, Sample):
+        return get_diff_smp(backup.__dict__, smp.__dict__)
+    for name, attr in smp.items():
+        if name not in backup.keys() or not isinstance(backup[name], type(attr)):
+            res.update({name: attr})
+            continue
+        if isinstance(attr, dict):
+            # if name not in backup.keys():
+            #     res.update({name: attr})
+            #     continue
+            _res = get_diff_smp(backup[name], attr)
+            if _res != {}:
+                res.update({name: _res})
+            continue
+        if isinstance(attr, np.ndarray):
+            if not np.array_equal(attr, backup[name]):
+                res.update({name: attr})
+            continue
+        if isinstance(attr, (Plot, Table, Plot.Text, Plot.Axis, Plot.Set,
+                             Plot.Label, Plot.BasicAttr, Info)):
+            _res = get_diff_smp(backup[name].__dict__, attr.__dict__)
+            if _res != {}:
+                res.update({name: _res})
+            continue
+        if str(backup[name]) == str(attr) or backup[name] == attr:
+            continue
+        res.update({name: attr})
+    return res