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.

Run Details

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

54.17

/src/parser/impl/TomographyProjectParser.py

from typing import List

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.RunMD_Parser import RunMD_Parser
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.model.SchemaConcepts.codegen.SchemaClasses_TOMO import DatasetType
from src.model.SchemaConcepts.TOMO_Image import TOMO_Image
from src.model.RunMD import RunMD
from src.util import normalize_path


class TomographyProjectParser(SetupMD_Parser):

    @staticmethod
    def supported_input_sources():
        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)

        mapping_dict = self.internal_mapping
        ac_md = map_a_dict(parsed, mapping_dict)
        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/xml"




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

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