def normalize_data(self, data: Any, fill_with=None, literal_eval=True, **kwargs) -> Union[List[str], Any]:
normalized_data = []
if is_sequence(data):
for row in data:
if not is_sequence(row):
if not self._fieldnames:
self._fieldnames = (None,)
assert len(data) <= len(
self._fieldnames), f'number of lines ({len(data)}) > number of cols {len(self._fieldnames)}'
data += [fill_with] * abs((len(self._fieldnames) - len(data)))
normalized_data.append(self._ast(data) if literal_eval else data)
break
if not self._fieldnames:
self._fieldnames = (None,) * len(row)
assert len(row) <= len(
self._fieldnames), f'number of lines ({len(row)}) > number of cols {len(self._fieldnames)}'
row = list(row)
row += [fill_with] * abs((len(self._fieldnames) - len(row)))
normalized_data.append(self._ast(row) if literal_eval else row)
else:
assert not isinstance(data, dict), TypeError("dict data isn't valid.")
data = [data]
if not self._fieldnames:
self._fieldnames = (None,)
data += [fill_with] * (len(self._fieldnames) - len(data))
normalized_data.append(self._ast(data) if literal_eval else data)
self._fieldnames = tuple(value if value is not None else f'unamed_col_{i}' for i, value in
enumerate(self._fieldnames))
return normalized_data
def __init__(self, func: FunctionType, sequence: Sequence[Any]):
if not isinstance(func, FunctionType):
raise TypeError(f"{func} is not a function.")
if not is_sequence(sequence):
raise TypeError(f"sequence is not valid.")
self.func = func
self.sequence = sequence
def normalize_data(cls, data: Any, *args, **kwargs) -> Union[List[str], Any]:
if not data:
return data
if is_iterable(data) or isinstance(data, int):
if is_sequence(data) and not isinstance(data, int):
data = [str(line).replace(CRLF, '').replace(CR, '').replace(LF, '') for line in data]
elif isinstance(data, str):
data = data.splitlines()
elif isinstance(data, int):
data = str(data)
return data
else:
raise ValueError(f"{data} Invalid value. Send other ")
def insert(self, line: int, data: Union[Sequence, str, int], **kwargs):
data = self.normalize_data(data, **kwargs)
if is_sequence(data):
if line == -1:
self._lines += list(data)
return
for pos, i in enumerate(data, line):
self._lines.insert(pos, i)
if isinstance(data, str):
if line == -1:
self._lines.append(data)
return
self._lines.insert(line, data)
self._set_change('_lines', self._lines.copy())
def normalize_data(cls, data: Any, *args, **kwargs) -> dict:
if data is None:
return {}
if isinstance(data, (dict, set)):
return cls.parse(data)
if is_sequence(data):
if len(data) == 2:
if len(flatten(data)) == 2:
return cls.parse(cls._parse_key_value(data))
normalized_data = {}
for item in data:
k, v = cls._parse_key_value(item, take_tuple=True)
assert k not in normalized_data, ValueError(f'Data contains duplicate keys <{k}>')
normalized_data[k] = v
return cls.parse(normalized_data)
return cls.parse({data: None})
def _parse_key_value(data: Tuple[Any, Any], take_tuple=False) -> Union[dict, Any]:
if isinstance(data, dict):
return data
try:
key, value = data
return (key, value) if take_tuple is True else {key: value}
except Exception as err:
if is_sequence(data):
if len(data) > 2:
raise ValueError(f"Invalid data {data}.")
if len(data) == 1:
return (data[0], None) if take_tuple is True else {data[0]: None}
if isinstance(data, (str, int, float, complex)):
return (data, None) if take_tuple is True else {data: None}
logger.error(
f"Internal Error: Intern function '_parse_key_value' error {err}. Please report this issue on "
f"github https://github.com/jlsneto/cereja")
return data
def test_is_sequence(self):
sequence = [[1, 2, 3], [], [[2, [3], 4], 6]]
self.assertTrue(is_sequence(sequence))
self.assertFalse(is_sequence('hi cereja'))
