21944637261

Committed 12 Feb 2026 11:24AM UTC coverage: 86.453% (+0.1%) from 86.341%

Build # 21944637261

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #77 from kit-data-manager/improv_code_cleanup

Various code fixes and cleanups
Cleaner type hints
Cleaner inheritance
More None checks

parse functions (parse_setup, parse_run, parse) do not return raw parse result anymore (was never used anywhere anyway)

Code now passes a static code check such as pyright.

Coverage Stats

159 of 198 new or added lines in 30 files covered. (80.3%)

3 existing lines in 3 files now uncovered.

2425 of 2805 relevant lines covered (86.45%)

0.86 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

48.89

/src/parser/impl/Dataset_infoParser.py

from typing import List, Tuple

from src.model.SchemaConcepts.Acquisition_simplified import Acquisition
from src.model.SchemaConcepts.Dataset_simplified import Dataset
from src.model.SetupMD import SetupMD
from src.parser.SetupMD_Parser import SetupMD_Parser
from src.parser.mapping_util import map_a_dict
from src.resources.maps.mapping import setup_tescan
from src.util import input_to_dict
from src.Preprocessor import Preprocessor


class Dataset_infoParser(SetupMD_Parser):

    @staticmethod
    def supported_input_sources() -> List[str]:
        return ['Tescan Solaris']

    def __init__(self):
        self.internal_mapping = input_to_dict(setup_tescan.read_text())

    def parse_setup(self, payload):
        parsed = self._read_input(payload)
        #print("..............",parsed)
        mapping_dict = self.internal_mapping
        ac_md = map_a_dict(parsed, mapping_dict)

        Preprocessor.normalize_all_units(ac_md)

        acquisition = self._create_acquisition(ac_md)
        datasets = self._create_datasets(ac_md)

        if len(datasets) == 1:
            acquisition.dataset_template = datasets[0]
        if len(datasets) > 1:
            acquisition.datasets = datasets
        return SetupMD(acquisition_metadata=acquisition)

    def _create_acquisition(self, ac_md) -> Acquisition:

        ac_md_format = {
            "genericMetadata": ac_md["genericMetadata"]
        }

        acquisition = Acquisition(**ac_md_format)
        #datasets = self._create_datasets(metadata_dict)
        #acquisition.datasets = datasets
        return acquisition

    def _create_datasets(self, ac_md) -> list:
        datasets = []
        for ds in ac_md["dataset"]:
            datasets.append(self._create_dataset(ds))
        return datasets

    def _create_dataset(self, ds_dict) -> Dataset:
        ds = Dataset(**ds_dict)
        return ds


    @staticmethod
    def retrievable_datasets():
        return True

    @staticmethod
    def expected_input_format():
        return "text/plain"

1	from typing import List, Tuple	1✔
2
3	from src.model.SchemaConcepts.Acquisition_simplified import Acquisition	1✔
4	from src.model.SchemaConcepts.Dataset_simplified import Dataset	1✔
5	from src.model.SetupMD import SetupMD	1✔
6	from src.parser.SetupMD_Parser import SetupMD_Parser	1✔
7	from src.parser.mapping_util import map_a_dict	1✔
8	from src.resources.maps.mapping import setup_tescan	1✔
9	from src.util import input_to_dict	1✔
10	from src.Preprocessor import Preprocessor	1✔
11
12
13	class Dataset_infoParser(SetupMD_Parser):	1✔
14
15	@staticmethod	1✔
16	def supported_input_sources() -> List[str]:	1✔
17	return ['Tescan Solaris']	×
18
19	def __init__(self):	1✔
20	self.internal_mapping = input_to_dict(setup_tescan.read_text())	1✔
21
22	def parse_setup(self, payload):	1✔
23	parsed = self._read_input(payload)	×
24	#print("..............",parsed)
25	mapping_dict = self.internal_mapping	×
26	ac_md = map_a_dict(parsed, mapping_dict)	×
27
28	Preprocessor.normalize_all_units(ac_md)	×
29
30	acquisition = self._create_acquisition(ac_md)	×
31	datasets = self._create_datasets(ac_md)	×
32
33	if len(datasets) == 1:	×
34	acquisition.dataset_template = datasets[0]	×
NEW 35	if len(datasets) > 1:	×
36	acquisition.datasets = datasets	×
NEW 37	return SetupMD(acquisition_metadata=acquisition)	×
38
39	def _create_acquisition(self, ac_md) -> Acquisition:	1✔
40
41	ac_md_format = {	×
42	"genericMetadata": ac_md["genericMetadata"]
43	}
44
45	acquisition = Acquisition(**ac_md_format)	×
46	#datasets = self._create_datasets(metadata_dict)
47	#acquisition.datasets = datasets
48	return acquisition	×
49
50	def _create_datasets(self, ac_md) -> list:	1✔
51	datasets = []	×
52	for ds in ac_md["dataset"]:	×
53	datasets.append(self._create_dataset(ds))	×
54	return datasets	×
55
56	def _create_dataset(self, ds_dict) -> Dataset:	1✔
57	ds = Dataset(**ds_dict)	×
58	return ds	×
59
60
61	@staticmethod	1✔
62	def retrievable_datasets():	1✔
63	return True	×
64
65	@staticmethod	1✔
66	def expected_input_format():	1✔
67	return "text/plain"	×

kit-data-manager / tomo_mapper / 21944637261

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous