1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
# coding: utf-8
"""
utils functions for io
"""
from __future__ import annotations
import logging
import re
from silx.utils.enum import Enum as _Enum
from nxtomomill.io.framegroup import FrameGroup
_logger = logging.getLogger(__name__)
__all__ = [
"remove_parenthesis_or_brackets",
"filter_str_def",
"convert_str_to_tuple",
"convert_str_to_bool",
"is_url_path",
"convert_str_to_frame_grp",
"PathType",
]
def remove_parenthesis_or_brackets(input_str):
if (
input_str.startswith("(")
and input_str.endswith(")")
or input_str.startswith("[")
and input_str.endswith("]")
):
input_str = input_str[1:-1]
return input_str
def filter_str_def(elmt):
if elmt is None:
return None
assert isinstance(elmt, str)
elmt = elmt.lstrip(" ").rstrip(" ")
for character in ("'", '"'):
if elmt.startswith(character) and elmt.endswith(character):
elmt = elmt[1:-1]
return elmt
def convert_str_to_tuple(input_str: str, none_if_empty: bool = False) -> tuple | None:
"""
:param input_str: string to convert
:param none_if_empty: if true and the conversion is an empty tuple
return None instead of an empty tuple
"""
if isinstance(input_str, (list, set)):
input_str = tuple(input_str)
if isinstance(input_str, tuple):
return input_str
if input_str is None:
input_str = ""
if not isinstance(input_str, str):
raise TypeError(
f"input_str should be a string not {type(input_str)}, {input_str}"
)
input_str = input_str.lstrip(" ").rstrip(" ")
input_str = remove_parenthesis_or_brackets(input_str)
elmts = input_str.split(",")
elmts = [filter_str_def(elmt) for elmt in elmts]
rm_empty_str = lambda a: a != ""
elmts = list(filter(rm_empty_str, elmts))
if none_if_empty and len(elmts) == 0:
return None
else:
return tuple(elmts)
def convert_str_to_bool(value: str | bool):
if isinstance(value, bool):
return value
elif isinstance(value, str):
if value not in ("False", "True", "1", "0"):
raise ValueError("value should be 'True' or 'False'")
return value in ("True", "1")
else:
raise TypeError("value should be a string")
def is_url_path(url_str: str) -> bool:
"""
:param url_str: url as a string
:return: True if the provided string fit DataUrl pattern
[scheme]:://[file_path]?[data_path]
"""
pattern_str_seq = "[a-zA-Z0-9]*"
url_path_pattern = rf"{pattern_str_seq}\:\/\/{pattern_str_seq}"
pattern = re.compile(url_path_pattern)
return bool(re.match(pattern, url_str))
def convert_str_to_frame_grp(input_str: str) -> tuple:
"""
Convert a list such as:
.. code-block:: text
urls = (
(frame_type=dark, entry="silx:///file.h5?data_path=/dark", copy=True),
(frame_type=flat, entry="silx:///file.h5?data_path=/flat"),
(frame_type=projection, entry="silx:///file.h5?data_path=/flat"),
(frame_type=projection, entry="silx:///file.h5?data_path=/flat"),
)
to a list of InputUrl
"""
result = []
if not isinstance(input_str, str):
raise TypeError("input_str should be an instance of str")
# remove spaces at the beginning and at the end
input_str = input_str.replace("\n", "")
input_str = input_str.lstrip(" ").rstrip(" ")
input_str = remove_parenthesis_or_brackets(input_str)
# special case when the ")" is given in a line and ignored by configparser
input_str = input_str.replace("((", "(")
# split sub entries
re_expr = r"\([^\)]*\)"
frame_grp_str_list = re.findall(re_expr, input_str)
for frame_grp_str in frame_grp_str_list:
try:
frame_grp = FrameGroup.frm_str(frame_grp_str)
except Exception as e:
_logger.error(
f"Unable to create a valid entry from {frame_grp_str}. Error is {e}"
)
else:
result.append(frame_grp)
return tuple(result)
class PathType(_Enum):
ABSOLUTE = "absolute"
RELATIVE = "relative"
|
