def get_converter(self, source, target):
source_dialect_name = get_value(source)
target_dialect_name = get_value(target)
converter_name = '{}_to_{}'.format(source_dialect_name, target_dialect_name)
field_types_by_dialect = self.get_dialect_types()
types_by_dialects = field_types_by_dialect.get(self, {})
return types_by_dialects.get(converter_name, str)
def __init__(
self,
name: OptName = arg.AUTO,
level: Level = arg.AUTO,
formatter: Union[Formatter, arg.Auto] = arg.AUTO,
loggers: SubLoggers = arg.AUTO,
context: Context = None,
file: Optional[FileOrName] = None,
):
name = arg.acquire(name, DEFAULT_LOGGER_NAME)
level = arg.acquire(level, DEFAULT_LOGGING_LEVEL)
formatter = arg.acquire(formatter, DEFAULT_FORMATTER)
if not isinstance(level, LoggingLevel):
level = LoggingLevel(level)
if isinstance(loggers, list):
loggers = {i: i.get_name() for i in loggers}
elif not arg.is_defined(loggers):
loggers = dict()
if name not in loggers:
level_value = arg.get_value(level)
base_logger = self.build_base_logger(name, level_value, formatter)
loggers[name] = base_logger
self._level = level
super().__init__(name=name, children=loggers, context=context)
if file:
self.set_file(file)
def extrapolate(self,
how: InterpolationType = InterpolationType.ByYoy,
*args,
**kwargs) -> Series:
method_name = 'extrapolate_{}'.format(arg.get_value(how))
extrapolation_method = self.__getattribute__(method_name)
return extrapolation_method(*args, **kwargs)
def get_type_in(self, dialect: DialectType):
type_props = self.get_dialect_types()[self.get_value()]
dialect_value = get_value(dialect)
type_in_dialect = type_props.get(dialect_value)
if not type_in_dialect:
type_in_dialect = type_props[DialectType.get_default()]
return type_in_dialect
def build_base_logger(
name: Name = DEFAULT_LOGGER_NAME,
level: Level = logging.DEBUG,
formatter: Formatter = DEFAULT_FORMATTER,
) -> BaseLogger:
level = arg.get_value(level)
base_logger = logging.getLogger(name)
base_logger.setLevel(level)
if not base_logger.handlers:
stream_handler = logging.StreamHandler()
stream_handler.setLevel(level)
if isinstance(formatter, str):
formatter = logging.Formatter(formatter)
stream_handler.setFormatter(formatter)
base_logger.addHandler(stream_handler)
return base_logger
def interpolate(self,
dates: Iterable,
how: InterpolationType = InterpolationType.Linear,
*args,
**kwargs) -> Series:
method_name = '{}_interpolation'.format(arg.get_value(how))
requires_numeric_keys = how in (InterpolationType.Linear,
InterpolationType.Spline)
if requires_numeric_keys:
interpolation_method = self.to_days().__getattribute__(method_name)
series_class = SeriesType.DateSeries.get_class()
numeric_keys = series_class(dates, sort_items=True).to_days()
return interpolation_method(numeric_keys, *args,
**kwargs).to_dates()
else:
interpolation_method = self.__getattribute__(method_name)
return interpolation_method(dates, *args, **kwargs)
def get_interpolated_value(
self,
date: Date,
how: InterpolationType = InterpolationType.Linear,
*args,
**kwargs) -> NumericValue:
method_name = 'get_{}_interpolated_value'.format(arg.get_value(how))
requires_numeric_keys = how in (InterpolationType.Linear,
InterpolationType.Spline)
if requires_numeric_keys:
numeric_series = self.to_days()
interpolation_method = numeric_series.__getattribute__(method_name)
numeric_key = dt.get_day_abs_from_date(date)
return interpolation_method(numeric_key, *args, **kwargs)
else:
interpolation_method = self.__getattribute__(method_name)
return interpolation_method(date, *args, **kwargs)
def set_file(
self, file: Union[File, Name],
encoding: str = DEFAULT_ENCODING,
level: Level = DEFAULT_LOGGING_LEVEL,
formatter: Formatter = DEFAULT_FORMATTER,
if_not_added: bool = True,
) -> LoggerInterface:
filename = arg.get_name(file)
level = arg.get_value(level)
is_added = False
for h in self.get_handlers():
if hasattr(h, 'baseFilename'):
if h.baseFilename.endswidth(filename):
is_added = True
break
if not (is_added and if_not_added):
file_handler = logging.FileHandler(filename, encoding=encoding)
file_handler.setLevel(level)
if isinstance(formatter, str):
formatter = logging.Formatter(formatter)
file_handler.setFormatter(formatter)
self.add_handler(file_handler)
return self
def get_type_in(self, dialect):
type_props = self.get_dialect_types()[self.get_value()]
dialect_value = get_value(dialect)
return type_props[dialect_value]
def is_suitable_level(self, level: Level) -> bool:
proposed_level_value = arg.get_value(level)
selected_level_value = arg.get_value(self.get_level())
return proposed_level_value >= selected_level_value
def get_type_name(self) -> str:
type_name = arg.get_value(self.get_type())
if not isinstance(type_name, str):
type_name = arg.get_name(type_name)
return str(type_name)
