from .interfaces.sorted_numeric_series_interface import SortedNumericSeriesInterface
from .interfaces.date_series_interface import DateSeriesInterface
from .interfaces.key_value_series_interface import KeyValueSeriesInterface
from .interfaces.sorted_key_value_series_interface import SortedKeyValueSeriesInterface
from .interfaces.sorted_numeric_key_value_series_interface import SortedNumericKeyValueSeriesInterface
from .interfaces.date_numeric_series_interface import DateNumericSeriesInterface
from .simple.any_series import AnySeries
from .simple.numeric_series import NumericSeries
from .simple.sorted_series import SortedSeries
from .simple.sorted_numeric_series import SortedNumericSeries
from .simple.date_series import DateSeries
from .pairs.key_value_series import KeyValueSeries
from .pairs.sorted_key_value_series import SortedKeyValueSeries
from .pairs.sorted_numeric_key_value_series import SortedNumericKeyValueSeries
from .pairs.date_numeric_series import DateNumericSeries
from ..functions.primary import numeric as nm, dates as dt
DICT_SERIES_CLASSES = dict(
AnySeries=AnySeries,
SortedSeries=SortedSeries,
DateSeries=DateSeries,
NumericSeries=NumericSeries,
SortedNumericSeries=SortedNumericSeries,
KeyValueSeries=KeyValueSeries,
SortedKeyValueSeries=SortedKeyValueSeries,
SortedNumericKeyValueSeries=SortedNumericKeyValueSeries,
DateNumericSeries=DateNumericSeries,
)
SeriesType.set_dict_classes(DICT_SERIES_CLASSES)
result = self.map_values(value_function, inplace=inplace) or self
result = result.map_keys(key_function, sorting_changed, inplace=inplace) or self
return self._assume_native(result)
def exclude(self, first_key: Any, last_key: Any, inplace: bool = False) -> Native:
result = self.filter_keys(lambda k: k < first_key or k > last_key, inplace=inplace) or self
return self._assume_native(result)
def span(self, first_key: Any, last_key: Any, inplace: bool = False) -> Native:
result = self.filter_keys(lambda k: first_key <= k <= last_key, inplace=inplace) or self
return self._assume_native(result)
def __repr__(self):
count, keys, values = self.get_count(), self.get_keys(), self.get_values()
if count == 0:
return '{}(0)'.format(self.__class__.__name__)
elif count == 1:
keys = keys[0]
values = values[0]
else:
keys = '{}..{}'.format(keys[0], keys[-1])
values = '{}..{}'.format(values[0], values[-1])
return '{}({}, {}, {})'.format(self.__class__.__name__, count, keys, values)
@staticmethod
def _assume_native(series) -> Native:
return series
SeriesType.add_classes(SortedSeries, KeyValueSeries, SortedKeyValueSeries)
def derivative(self,
extend: bool = False,
default: NumericValue = 0,
inplace: bool = False) -> Series:
derivative = self.value_series(set_closure=True).derivative(
extend=extend, default=default)
result = self.set_values(derivative.get_values(),
inplace=inplace,
set_closure=True,
validate=False)
return self._assume_series(result)
@staticmethod
def get_names() -> tuple:
return 'date', 'value'
def plot(self, fmt: str = '-') -> None:
plot(self.get_keys(), self.get_values(), fmt=fmt)
@staticmethod
def _assume_series(series) -> Series:
return series
@staticmethod
def _assume_native(series) -> Native:
return series
SeriesType.add_classes(DateSeries, DateNumericSeries,
SortedNumericKeyValueSeries)
inplace: bool = False) -> Native:
distance_func = self.get_distance_func(value, take_abs=take_abs)
distance_series = self.value_series().map(distance_func,
inplace=inplace)
series_class = SeriesType.SortedNumericKeyValueSeries.get_class()
result = series_class(self.get_values(), distance_series)
if inplace:
self.set_values(result.get_values(), inplace=True)
return result
def get_distance_for_nearest_value(self,
value: NumericValue,
take_abs: bool = True) -> NumericValue:
nearest_value = self.get_nearest_value(value)
distance_func = self.value_series().get_distance_func()
return distance_func(value, nearest_value, take_abs)
def get_nearest_value(
self,
value: NumericValue,
distance_func: Optional[Callable] = None) -> NumericValue:
distance_func = distance_func or self.get_distance_func()
return super().get_nearest_value(value, distance_func)
@staticmethod
def _assume_sorted(series) -> SortedSeries:
return series
SeriesType.add_classes(SortedSeries, NumericSeries, SortedNumericSeries)
def get_first_item(self) -> Any:
return self.get_first_value()
def get_last_item(self) -> Any:
return self.get_last_value()
def get_borders(self) -> tuple:
return self.get_first_item(), self.get_last_item()
def get_mutual_borders(self, other: Native) -> list:
assert isinstance(other, (SortedSeries, SortedSeriesInterface, SortedKeyValueSeriesInterface))
first_item = max(self.get_first_item(), other.get_first_item())
last_item = min(self.get_last_item(), other.get_last_item())
if first_item < last_item:
return [first_item, last_item]
def borders(self, other: Native = None) -> Native:
if other:
result = self.new(self.get_mutual_borders(other))
else:
result = self.new(self.get_borders())
return self._assume_native(result)
@staticmethod
def _assume_native(series) -> Native:
return series
SeriesType.add_classes(AnySeries, SortedSeries)
return None
distance_for_base_date = candidates.distance(self.date_series())
filtered_distances_for_base_date = distance_for_base_date.filter_values(
lambda d: abs(d) <= max_distance)
if filtered_distances_for_base_date.has_items():
distance_for_cur_date = filtered_distances_for_base_date.distance(
date, take_abs=True)
else:
distance_for_cur_date = distance_for_base_date.distance(
date, take_abs=True)
base_date = distance_for_cur_date.get_arg_min()
if return_increment:
increment = self.get_distance_func()(
base_date, date, take_abs=False) / dt.DAYS_IN_YEAR
increment = round(increment)
increment = int(increment)
return base_date, increment
else:
return base_date
@staticmethod
def _assume_native(series) -> Native:
return series
@staticmethod
def _assume_sorted_numeric(series) -> SortedNumericSeriesInterface:
return series
SeriesType.add_classes(SortedSeries, DateSeries)
def spline_interpolation(self, keys: Iterable) -> Native:
spline_function = self.get_spline_function(from_cache=True,
to_cache=True)
result = self.new(
keys=keys,
values=spline_function(list(keys)),
save_meta=True,
)
return self._assume_native(result)
def get_value_by_key(self,
key: NumericValue,
*args,
interpolate: str = 'linear',
**kwargs) -> NumericValue:
value = self.get_dict().get(key)
if value is None:
value = self.get_interpolated_value(key,
how=interpolate,
*args,
**kwargs)
return value
@staticmethod
def _assume_native(series) -> Native:
return series
SeriesType.add_classes(SortedNumericSeries, SortedKeyValueSeries,
SortedNumericKeyValueSeries)
window: Window = WINDOW_NEIGHBORS,
local_min: bool = False,
local_max: bool = True,
inplace: bool = False,
):
deviation = self.deviation_from_neighbors(window=window,
relative=True,
inplace=False)
if local_min or local_max:
deviation = deviation.map_zip_values(
lambda x, m: x if m else None,
self.mark_local_extremes(local_min=local_min,
local_max=local_max),
inplace=inplace,
) or deviation
spikes = deviation.map_values(
lambda x: abs(x or 0) > threshold,
inplace=inplace,
) or deviation
return spikes
def plot(self, fmt: str = '-') -> None:
plot(self.get_range_numbers(), self.get_values(), fmt=fmt)
@staticmethod
def _assume_native(series) -> Native:
return series
SeriesType.add_classes(AnySeries, NumericSeries)
lambda a: series_class(a).filter_values_defined().get_mean(), )
return self._assume_native(result)
@staticmethod
def get_names() -> tuple:
return 'key', 'value'
def get_dataframe(self) -> nm.DataFrame:
return nm.get_dataframe(data=self.get_list(), columns=self.get_names())
def plot(self, fmt: str = '-') -> None:
nm.plot(self.get_keys(), self.get_values(), fmt=fmt)
def __repr__(self):
count, keys, values = self.get_count(), self.get_keys(
), self.get_values()
if count > 3:
keys = keys[:2] + ['...'] + keys[-1:]
values = values[:2] + ['...'] + values[-1:]
keys = ', '.join(map(str, keys))
values = ', '.join(map(str, values))
return "{}(count={}, keys={}, values={})".format(
self.__class__.__name__, count, keys, values)
@staticmethod
def _assume_native(series) -> Native:
return series
SeriesType.add_classes(AnySeries, KeyValueSeries)
if v < prev:
return False
prev = v
return True
else:
return DEFAULT_SORTED
def is_numeric(self, check: bool = False) -> bool:
if check:
return self.assume_numeric(validate=False).has_valid_items()
else:
return DEFAULT_NUMERIC
@staticmethod
def get_names() -> list:
return ['value']
def get_dataframe(self) -> nm.DataFrame:
return nm.get_dataframe(self.get_values(), columns=self.get_names())
@staticmethod
def _assume_native(series) -> Native:
return series
@staticmethod
def _assume_sorted(series) -> SortedSeriesInterface:
return series
SeriesType.add_classes(AnySeries)