ararpy 0.1.199__py3-none-any.whl → 0.2.1__py3-none-any.whl

ararpy/files/raw_file.py

@@ -22,13 +22,50 @@ 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
+from ..smp.sample import RawData
 
 """ Open raw data file """
 
-DEFAULT_SAMPLE_INFO = {}
-
-
-def open_file(file_path: str, input_filter: List[Union[str, int, bool]]):
+DEFAULT_SAMPLE_INFO = {
+    "ExpName": "en",        # "Experiment Name"
+    "StepName": "sn",       # "Step Name"
+    "StepType": "st",       # "Step Type"
+    "StepLabel": "sl",      # "Step Label"
+    "ZeroYear": "date",     # "Zero Date Year"
+    "ZeroHour": "time",     # "Zero Time Hour"
+    "ZeroMon": "mon",       # "Zero Date Month"
+    "ZeroMin": "min",       # "Zero Time Minute"
+    "ZeroDay": "day",       # "Zero Date Day"
+    "ZeroSec": "sec",       # "Zero Time Second"
+    "SmpName": "smpn",      # "Sample Name"
+    "SmpLoc": "smpl",       # "Sample location"
+    "SmpMatr": "smpm",      # "Sample Material"
+    "ExpType": "et",        # "Experiment Type"
+    "SmpWeight": "smpw",    # "Sample Weight"
+    "Stepunit": "su",       # "Step unit"
+    "HeatingTime": "ht",    # "Heating time"
+    "InstrName": "inn",     # "Instrument name"
+    "Researcher": "re",     # "Researcher"
+    "Analyst": "an",        # "Analyst"
+    "Lab": "la",            # "Laboratory"
+    "Jv": "jv",             # "J value"
+    "Jsig": "je",           # "J value error"
+    "MDF": "mdf",           # "MDF"
+    "MDFSig": "mdfe",       # "MDF error"
+    "CalcName": "cp",       # "Calc params"
+    "IrraName": "in",       # "Irra name"
+    "IrraLabel": "il",      # "Irra label"
+    "IrraPosH": "ih",       # "Irra position H"
+    "IrraPosX": "ix",       # "Irra position X"
+    "IrraPosY": "iy",       # "Irra position Y"
+    "StdName": "stdn",      # "Standard name"
+    "StdAge": "stda",       # "Standard age"
+    "StdAgeSig": "stde",    # "Standard age error"
+}
+
+
+
+def open_file(file_path: str, input_filter: List[Union[str, int, bool]], name=None):
     """
     Parameters
     ----------
@@ -57,64 +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:
-        print(traceback.format_exc())
         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
     ----------
@@ -125,11 +112,14 @@ def open_raw_txt(file_path, input_filter: List[Union[str, int]]):
     -------
 
     """
+    file_name = os.path.basename(file_path).rstrip(os.path.splitext(file_path)[-1]) if name is None else name
+
     if not input_filter:
         raise ValueError("Input filter is empty array.")
 
     if os.path.splitext(file_path)[1][1:].lower() != input_filter[0].strip().lower():
-        raise ValueError("The file does not comply with the extension in the given filter.")
+        raise ValueError(f"The file extension does not match the filter: {file_name}, "
+                         f"{input_filter[0].strip().lower()} required.")
 
     with open(file_path, 'rb') as f:
         contents = f.read()
@@ -137,12 +127,11 @@ 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])
     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=None):
     """
     Parameters
     ----------
@@ -153,11 +142,14 @@ def open_raw_xls(file_path, input_filter: List[Union[str, int]]):
     -------
 
     """
+    file_name = os.path.basename(file_path).rstrip(os.path.splitext(file_path)[-1]) if name is None else name
+
     if not input_filter:
         raise ValueError("Input filter is empty array.")
 
     if os.path.splitext(file_path)[1][1:].lower() != input_filter[0].strip().lower():
-        raise ValueError("The file does not comply with the extension in the given filter.")
+        raise ValueError(f"The file extension does not match the filter: {file_name}, "
+                         f"{input_filter[0].strip().lower()} required.")
 
     def _get_content_from_sheet(_index) -> List[List[Union[str, bool, int, float]]]:
         try:
@@ -169,15 +161,34 @@ 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])
     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):
+            MODULE = RawData().__module__
+            renamed_module = module
+            if '.sample' in module and module != MODULE:
+                renamed_module = MODULE
+            try:
+                return super(RenameUnpickler, self).find_class(renamed_module, name)
+            except AttributeError:
+                return super(RenameUnpickler, self).find_class(renamed_module, 'ArArBasic')
+
+    def renamed_load(file_obj):
+        return RenameUnpickler(file_obj).load()
+
     with open(file_path, 'rb') as f:
-        sequences = pickle.load(f)
+        sequences = renamed_load(f)
+
+    # with open(file_path, 'rb') as f:
+    #     sequences = pickle.load(f)
+    #     print(sequences[0].__module__)
+
     name_list = []
     for seq in sequences:
         while seq.name in name_list:
@@ -201,155 +212,187 @@ 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
+
+    def step_type_parse(s: str):
+        if any([s.lower().__contains__(each) for each in ['blk', 'blank']]):
+            return "Blank"
+        return "Unknown"
+
     step_list = []
-    idx = step_index = 0
+    step_idx = 0  # step_index rows
 
     header = input_filter[5]
-    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:]
+    isotope_index = input_filter[8:28]
+    data_index = input_filter[4:33]
+    strings_index = input_filter[33:41]         # strings: filename, parsing information, datetime, timezone
+    optional_info_index = input_filter[41:-7]       # from Exp Name to Std Age Error
+    check_box_index = input_filter[-7:]
 
-    timezone = sample_info_index[3] if sample_info_index[3] != "" else "utc"
     while True:  # measurment steps sloop
-        # Zero datetime
+
+        # ============ all text information ============
+        options = get_sample_info(file_contents, optional_info_index, default="", base=[1, 1 - step_idx, 1])
+
+        # ============ Step name ============
         try:
-            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])
+            step_name = options.get('StepName')
+            experiment_name = options.get('ExpName')
+            if check_box_index[1] and strings_index[0].strip() != "":
+                res = string_parser(strings_index[0], file_name)
+                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_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
+            print(traceback.format_exc())
+            break
+        else:
+            options.update({'StepName': step_name})
+            options.update({'ExpName': experiment_name})
+
+        # ============ Step information ============
+        try:
+            if check_box_index[2]:
+                string = get_item(file_contents, strings_index[1:4], default="", base=[1, 1 - step_idx, 1])
+                res = string_parser(strings_index[4], string)
+                if res is not None:
+                    options.update(dict(zip(DEFAULT_SAMPLE_INFO.keys(), [res.named.get(value, options.get(key)) for key, value in DEFAULT_SAMPLE_INFO.items()])))
+        except (TypeError, ValueError, IndexError):
+            print(traceback.format_exc())
+            break
+        else:
+            pass
+
+        # ============ Zero datetime ============
+        timezone = strings_index[7] if strings_index[7] != "" else "utc"
+        options.update({'TimeZone': timezone})
+        try:
+            if check_box_index[3]:  # date in one string
+                zero_date = datetime_parse(options.get('ZeroYear'), strings_index[5])
             else:
-                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]))
+                zero_date = datetime(year=options.get('ZeroYear'), month=options.get('ZeroMon'),
+                                     day=options.get('ZeroDay'))
 
-            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])
+            if check_box_index[4]:  # time in one string
+                zero_time = datetime_parse(options.get('ZeroHour'), strings_index[6])
             else:
-                zero_time = datetime(year=2020, month=12, day=31,
-                                     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_time = datetime(year=2020, month=12, day=31, hour=options.get('ZeroHour'),
+                                     minute=options.get('ZeroMin'), second=options.get('ZeroSec'))
 
             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(1970, 1, 1, 0, 0, 0).isoformat(timespec='seconds')
-
-        # Experiment name
-        try:
-            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 = "ExpName"
+            options.update({'ZeroDT': zero_datetime})
+        except (TypeError, ValueError, IndexError) as e:
+            print(traceback.format_exc())
+            raise ValueError(f"Failed to parse zero datetime: {e}")
+            # zero_datetime = datetime(1970, 1, 1, 0, 0, 0).isoformat(timespec='seconds')
 
-        # Step name
-        try:
-            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)
-                    step_index = _res.named.get("sn", step_name)
-                    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")
-        except (TypeError, ValueError, IndexError):
-            # When parsing the step name fails, the end of the file has been reached
-            raise
+        # ============== Step Type =============
+        step_type = step_type_parse(options.get("StepType"))  # blank or unknown
+        options.update({'StepType': step_type})
 
-        # other information
-        options = get_sample_info(file_contents, optional_info_index, default="", base=[1, 1 - idx, 1])
+        # ============== Step Type =============
+        exp_type = options.get("ExpType")  # crushing, laser, heating, air
+        options.update({'ExpType': exp_type})
 
-        current_step = [[step_name, zero_datetime, experiment_name, options]]
+        current_step = [[step_name, zero_datetime, options]]
 
+        # ============ isotope data ============
         break_num = 0
         cycle_num = 0
-        f = float(input_filter[31])  # Intensity Scale Factor
-        data_content = file_contents[input_filter[4] - 1 if input_filter[4] != 0 else 0]
+        f = float(data_index[27])  # Intensity Scale Factor
+        data_content = file_contents[data_index[0] - 1 if data_index[0] != 0 else 0]
+        base = 1
         for i in range(2000):  # measurement cycle sloop
-            if break_num < input_filter[29]:
+            if break_num < data_index[25]:
                 break_num += 1
                 continue
             break_num = 0
-            if int(input_filter[6]) == 0:  # == 0, vertical
-                start_row = input_filter[28] * cycle_num + input_filter[29] * cycle_num + header + idx - 1
-                try:
+            try:
+                if int(data_index[2]) == 0:  # == 0, vertical
+                    start_row = data_index[24] * cycle_num + data_index[25] * cycle_num + header + step_idx
+                    if check_box_index[0] and start_row - step_idx - header >= data_index[28]:
+                        break
                     current_step.append([
                         str(cycle_num + 1),
                         # in sequence: Ar36, Ar37, Ar38, Ar39, Ar40
-                        float(data_content[start_row + isotopic_data_index[18]][isotopic_data_index[19] - 1]),
-                        float(data_content[start_row + isotopic_data_index[16]][isotopic_data_index[17] - 1]) * f,
-                        float(data_content[start_row + isotopic_data_index[14]][isotopic_data_index[15] - 1]),
-                        float(data_content[start_row + isotopic_data_index[12]][isotopic_data_index[13] - 1]) * f,
-                        float(data_content[start_row + isotopic_data_index[10]][isotopic_data_index[11] - 1]),
-                        float(data_content[start_row + isotopic_data_index[ 8]][isotopic_data_index[ 9] - 1]) * f,
-                        float(data_content[start_row + isotopic_data_index[ 6]][isotopic_data_index[ 7] - 1]),
-                        float(data_content[start_row + isotopic_data_index[ 4]][isotopic_data_index[ 5] - 1]) * f,
-                        float(data_content[start_row + isotopic_data_index[ 2]][isotopic_data_index[ 3] - 1]),
-                        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(traceback.format_exc())
-                    current_step.append([
-                        str(cycle_num + 1), None, None, None, None, None, None, None, None, None, None,
+                        float(data_content[start_row + isotope_index[18] - base][isotope_index[19] - base]),
+                        float(data_content[start_row + isotope_index[16] - base][isotope_index[17] - base]) * f,
+                        float(data_content[start_row + isotope_index[14] - base][isotope_index[15] - base]),
+                        float(data_content[start_row + isotope_index[12] - base][isotope_index[13] - base]) * f,
+                        float(data_content[start_row + isotope_index[10] - base][isotope_index[11] - base]),
+                        float(data_content[start_row + isotope_index[ 8] - base][isotope_index[ 9] - base]) * f,
+                        float(data_content[start_row + isotope_index[ 6] - base][isotope_index[ 7] - base]),
+                        float(data_content[start_row + isotope_index[ 4] - base][isotope_index[ 5] - base]) * f,
+                        float(data_content[start_row + isotope_index[ 2] - base][isotope_index[ 3] - base]),
+                        float(data_content[start_row + isotope_index[ 0] - base][isotope_index[ 1] - base]) * f,
                     ])
-            elif int(input_filter[6]) == 1:  # == 1, horizontal
-                start_row = input_filter[5] + idx
-                col_inc = input_filter[28] * cycle_num + input_filter[29] * cycle_num - 1
-                try:
+                elif int(data_index[2]) == 1:  # == 1, horizontal
+                    start_row = data_index[1] + step_idx
+                    col_inc = data_index[24] * cycle_num + data_index[25] * cycle_num
                     current_step.append([
                         str(cycle_num + 1),
                         # Ar36, Ar37, Ar38, Ar39, Ar40
-                        float(data_content[start_row][isotopic_data_index[19] + col_inc]),
-                        float(data_content[start_row][isotopic_data_index[17] + col_inc]) * f,
-                        float(data_content[start_row][isotopic_data_index[15] + col_inc]),
-                        float(data_content[start_row][isotopic_data_index[13] + col_inc]) * f,
-                        float(data_content[start_row][isotopic_data_index[11] + col_inc]),
-                        float(data_content[start_row][isotopic_data_index[ 9] + col_inc]) * f,
-                        float(data_content[start_row][isotopic_data_index[ 7] + col_inc]),
-                        float(data_content[start_row][isotopic_data_index[ 5] + col_inc]) * f,
-                        float(data_content[start_row][isotopic_data_index[ 3] + col_inc]),
-                        float(data_content[start_row][isotopic_data_index[ 1] + col_inc]) * f,
+                        float(data_content[start_row][isotope_index[19] + col_inc - base]),
+                        float(data_content[start_row][isotope_index[17] + col_inc - base]) * f,
+                        float(data_content[start_row][isotope_index[15] + col_inc - base]),
+                        float(data_content[start_row][isotope_index[13] + col_inc - base]) * f,
+                        float(data_content[start_row][isotope_index[11] + col_inc - base]),
+                        float(data_content[start_row][isotope_index[ 9] + col_inc - base]) * f,
+                        float(data_content[start_row][isotope_index[ 7] + col_inc - base]),
+                        float(data_content[start_row][isotope_index[ 5] + col_inc - base]) * f,
+                        float(data_content[start_row][isotope_index[ 3] + col_inc - base]),
+                        float(data_content[start_row][isotope_index[ 1] + col_inc - base]) * f,
                     ])
-                except (ValueError, IndexError):
-                    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,
-                    ])
-            else:
-                raise ValueError(f"{input_filter[6]} not in [0, 1]")
+                else:
+                    raise ValueError(f"{data_index[2]} not in [0, 1]")
+            except Exception as e:
+                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,
+                ])
 
             cycle_num += 1
-            if cycle_num >= input_filter[7]:
+            if cycle_num >= data_index[3]:
                 break
 
         step_list.append(current_step)
-        idx = input_filter[32] * len(step_list)
-
+        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)}")
             break
 
+    if not step_list:
+        raise ValueError("Failed to read the original file. It might be because the names of the experiments or steps were not recognized.")
+
     return step_list
 
 
@@ -368,69 +411,39 @@ def get_sample_info(file_contents: list, index_list: list, default="", base: Uni
     """
     sample_info = DEFAULT_SAMPLE_INFO.copy()
     sample_info.update({
-        "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),
-        # "Step Label": get_item(file_contents, sample_info_index[9:12], default=default, base=base),
-        # "Zero Date Year": get_item(file_contents, sample_info_index[12:15], default=default, base=base),
-        # "Zero Time Hour": get_item(file_contents, sample_info_index[15:18], default=default, base=base),
-        # "Zero Date Month": get_item(file_contents, sample_info_index[18:21], default=default, base=base),
-        # "Zero Time Minute": get_item(file_contents, sample_info_index[21:24], default=default, base=base),
-        # "Zero Date Day": get_item(file_contents, sample_info_index[24:27], default=default, base=base),
-        # "Zero Time Second": get_item(file_contents, sample_info_index[27:30], default=default, base=base),
-        # "Sample Name": get_item(file_contents, sample_info_index[30:33], default=default, base=base),
-        # "Sample location": get_item(file_contents, sample_info_index[33:36], default=default, base=base),
-        # "Sample Material": get_item(file_contents, sample_info_index[36:39], default=default, base=base),
-        # "Experiment Type": get_item(file_contents, sample_info_index[39:42], default=default, base=base),
-        # "Sample Weight": get_item(file_contents, sample_info_index[42:45], default=default, base=base),
-        # "Step unit": get_item(file_contents, sample_info_index[45:48], default=default, base=base),
-        # "Heating time": get_item(file_contents, sample_info_index[48:51], default=default, base=base),
-        # "Instrument name": 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),
-        # "Laboratory": get_item(file_contents, sample_info_index[60:63], default=default, base=base),
-        # "J value": get_item(file_contents, sample_info_index[63:66], default=default, base=base),
-        # "J value error": get_item(file_contents, sample_info_index[66:69], default=default, base=base),
-        # "Calc params": get_item(file_contents, sample_info_index[69:72], default=default, base=base),
-        # "Irra name": get_item(file_contents, sample_info_index[72:75], default=default, base=base),
-        # "Irra label": get_item(file_contents, sample_info_index[75:78], default=default, base=base),
-        # "Irra position H": get_item(file_contents, sample_info_index[78:81], default=default, base=base),
-        # "Irra position X": get_item(file_contents, sample_info_index[81:84], default=default, base=base),
-        # "Irra position Y": get_item(file_contents, sample_info_index[84:87], default=default, base=base),
-        # "Standard name": get_item(file_contents, sample_info_index[87:90], default=default, base=base),
-        # "Standard age": get_item(file_contents, sample_info_index[90:93], default=default, base=base),
-        # "Standard age error": 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).strip(),
+        "StepName": get_item(file_contents, index_list[3:6], default=default, base=base).strip(),
+        "StepType": get_item(file_contents, index_list[6:9], default=default, base=base).strip(),
+        "StepLabel": get_item(file_contents, index_list[9:12], default=default, base=base).strip(),
+        "ZeroYear": get_item(file_contents, index_list[12:15], default=default, base=base).strip(),
+        "ZeroHour": get_item(file_contents, index_list[15:18], default=default, base=base).strip(),
+        "ZeroMon": get_item(file_contents, index_list[18:21], default=default, base=base).strip(),
+        "ZeroMin": get_item(file_contents, index_list[21:24], default=default, base=base).strip(),
+        "ZeroDay": get_item(file_contents, index_list[24:27], default=default, base=base).strip(),
+        "ZeroSec": get_item(file_contents, index_list[27:30], default=default, base=base).strip(),
+        "SmpName": get_item(file_contents, index_list[30:33], default=default, base=base).strip(),
+        "SmpLoc": get_item(file_contents, index_list[33:36], default=default, base=base).strip(),
+        "SmpMatr": get_item(file_contents, index_list[36:39], default=default, base=base).strip(),
+        "ExpType": get_item(file_contents, index_list[39:42], default=default, base=base).strip(),
+        "SmpWeight": get_item(file_contents, index_list[42:45], default=default, base=base).strip(),
+        "Stepunit": get_item(file_contents, index_list[45:48], default=default, base=base).strip(),
+        "HeatingTime": get_item(file_contents, index_list[48:51], default=default, base=base).strip(),
+        "InstrName": get_item(file_contents, index_list[51:54], default=default, base=base).strip(),
+        "Researcher": get_item(file_contents, index_list[54:57], default=default, base=base).strip(),
+        "Analyst": get_item(file_contents, index_list[57:60], default=default, base=base).strip(),
+        "Lab": get_item(file_contents, index_list[60:63], default=default, base=base).strip(),
+        "Jv": get_item(file_contents, index_list[63:66], default=default, base=base).strip(),
+        "Jsig": get_item(file_contents, index_list[66:69], default=default, base=base).strip(),
+        "MDF": get_item(file_contents, index_list[69:72], default=default, base=base).strip(),
+        "MDFSig": get_item(file_contents, index_list[72:75], default=default, base=base).strip(),
+        "CalcName": get_item(file_contents, index_list[75:78], default=default, base=base).strip(),
+        "IrraName": get_item(file_contents, index_list[78:81], default=default, base=base).strip(),
+        "IrraLabel": get_item(file_contents, index_list[81:84], default=default, base=base).strip(),
+        "IrraPosH": get_item(file_contents, index_list[84:87], default=default, base=base).strip(),
+        "IrraPosX": get_item(file_contents, index_list[87:90], default=default, base=base).strip(),
+        "IrraPosY": get_item(file_contents, index_list[90:93], default=default, base=base).strip(),
+        "StdName": get_item(file_contents, index_list[93:96], default=default, base=base).strip(),
+        "StdAge": get_item(file_contents, index_list[96:99], default=default, base=base).strip(),
+        "StdAgeSig": get_item(file_contents, index_list[99:102], default=default, base=base).strip(),
     })
     return sample_info