def _get_datetime_from_string(self, value: str) -> datetime.datetime:
if not self.formats:
try:
return self.parser(value)
except ValueError:
raise ColumnError(f'Unable to convert "{value}" to date.')
for date_format in self.formats:
try:
return datetime.datetime.strptime(value, date_format)
except ValueError:
pass
raise ColumnError(f'Value "{value}" is not accordance with the format {self.formats}.')
def process_value(self, value: Any) -> Any:
str_value = super().process_value(value)
if str_value and len(str_value) > self.max_length:
raise ColumnError(
f'"{value}" exceeds max length {self.max_length}')
return str_value
def clean_unique_value(self, column: Column, value: Any, row_index: int) -> Any:
if value is not None and column.unique:
duplicate_row = self._unique_column_values[column.name].get(value, None)
if duplicate_row:
raise ColumnError(f'value {value} is a duplicate of row {duplicate_row}')
else:
self._unique_column_values[column.name][value] = row_index
return value
def process_value_error(self, value: Any, exc_info: Exception) -> Any:
if self.raise_error:
if isinstance(exc_info, ColumnError):
raise exc_info
raise ColumnError(str(exc_info)) from exc_info
if self.none_if_error:
value = None
return value
def process_value(self, value: Any) -> Any:
value = super().process_value(value)
if not (self.min_value < value <= self.max_value):
raise ColumnError(
f'{value} is not in range ({self.min_value}..{self.max_value}].'
)
return value
def process_value(self, value: Any) -> Optional[str]:
email_value = super().process_value(value)
if email_value:
email_value = lower(email_value)
try:
validate_email(email_value)
except EmailNotValidError:
raise ColumnError(f'{value} is not a valid postal address.')
return email_value
class Parser(BaseParser):
columns = [
Column('first_name', index=0),
Column('last_name', index=1),
Column('age',
index=2,
processor=lambda x: x
if isinstance(x, int) else raise_(ColumnError())),
]
def process_value(self, value: Any) -> Any:
if isinstance(value, str):
value = self._get_datetime_from_string(value.strip())
elif isinstance(value, datetime.datetime):
pass
elif isinstance(value, datetime.date):
value = datetime.datetime.combine(value, datetime.time.min)
else:
raise ColumnError(f'Unable to convert to date {value}.')
return value
def process_value(self, value: Any) -> Any:
raw_value = value
if isinstance(raw_value, str):
raw_value = raw_value.strip()
if raw_value in self.true_values:
return True
elif raw_value in self.false_values:
return False
raise ColumnError('It is expected one of values: {0}'.format(list(self.true_values) + list(self.false_values)))
def process_value(self, value: Any) -> Any:
value: Any = self.raw_value_processor(value)
for item, choice_function in self.choices:
if not callable(choice_function) and choice_function == value:
return item
try:
if choice_function(value):
return item
except TypeError:
pass
raise ColumnError('Unknown value.')
def process_value(self, value: Any) -> Any:
int_value = value
if isinstance(value, float):
int_value = self._process_float_value(value)
elif isinstance(value, str):
int_value = self._process_str_value(value)
if not isinstance(int_value, int):
raise ColumnError(f'{value} is not an integer.')
return int_value
def process_value(self, value: Any) -> Any:
if isinstance(value, Decimal):
decimal_value = value
elif isinstance(value, (int, float)):
decimal_value = Decimal(value)
else:
try:
decimal_value = Decimal(str(value).strip().replace(',', '.'))
except InvalidOperation:
raise ColumnError(f'{value} is not a floating point number.')
return decimal_value
def process_value(self, value: Any) -> Any:
if isinstance(value, float):
float_value = value
elif isinstance(value, int):
float_value = float(value)
else:
try:
float_value = float(str(value).strip().replace(',', '.'))
except (ValueError, TypeError):
raise ColumnError(f'{value} is not a floating point number.')
return float_value
def parse_column(self, row: List[Any], column: Column, row_index: int) -> Any:
try:
value = row[column.index]
except IndexError:
value = None
try:
value = column.processor(value)
value = self.clean_column(column, value)
except StopParsing as e:
raise e
except Exception as e:
raise ColumnError(getattr(e, 'messages', str(e))) from e
return value
def process_value(self, value: Any) -> Any:
value = self.raw_value_processor(value)
try:
return self.choices[value]
except KeyError:
raise ColumnError(f'Unknown value {value}.')
