16725814017

Committed 04 Aug 2025 02:09PM UTC coverage: 86.311% (-3.3%) from 89.629%

Build # 16725814017

Build Type

push

github

Committed by

web-flow

Commit Message

Release v1.1.0

Run Details

350 of 449 new or added lines in 22 files covered. (77.95%)

9 existing lines in 2 files now uncovered.

2396 of 2776 relevant lines covered (86.31%)

0.86 hits per line

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

53.06

/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() -> List[str]:
        return ['Tescan Solaris']

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

    def parse_setup(self, payload) -> tuple[SetupMD, dict]:
        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 not datasets:
            return acquisition, parsed

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

    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 "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() -> List[str]:	1✔
NEW 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) -> tuple[SetupMD, dict]:	1✔
NEW 27	parsed = self._read_input(payload)	×
28
NEW 29	mapping_dict = self.internal_mapping	×
NEW 30	ac_md = map_a_dict(parsed, mapping_dict)	×
NEW 31	acquisition = self._create_acquisition(ac_md)	×
NEW 32	datasets = self._create_datasets(ac_md)	×
NEW 33	if not datasets:	×
NEW 34	return acquisition, parsed	×
35
NEW 36	if len(datasets) == 1:	×
NEW 37	acquisition.dataset_template = datasets[0]	×
38	else:
NEW 39	acquisition.datasets = datasets	×
NEW 40	return SetupMD(acquisition_metadata=acquisition), parsed	×
41
42	def _create_acquisition(self, ac_md) -> Acquisition:	1✔
43
NEW 44	ac_md_format = {	×
45	"genericMetadata": ac_md["genericMetadata"]
46	}
47
NEW 48	acquisition = Acquisition(**ac_md_format)	×
49	#datasets = self._create_datasets(metadata_dict)
50	#acquisition.datasets = datasets
NEW 51	return acquisition	×
52
53	def _create_datasets(self, ac_md) -> list:	1✔
NEW 54	datasets = []	×
NEW 55	for ds in ac_md["dataset"]:	×
NEW 56	datasets.append(self._create_dataset(ds))	×
NEW 57	return datasets	×
58
59	def _create_dataset(self, ds_dict) -> Dataset:	1✔
NEW 60	ds = Dataset(**ds_dict)	×
NEW 61	return ds	×
62
63
64	@staticmethod	1✔
65	def retrievable_datasets():	1✔
NEW 66	return True	×
67
68	@staticmethod	1✔
69	def expected_input_format():	1✔
NEW 70	return "xml"	×
71
72
73

kit-data-manager / tomo_mapper / 16725814017

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