async def drop_control_actions_older_than(self,
timestamp: pd.Timestamp) -> None:
logger.debug(
f"Requested deleting control actions older than {timestamp}")
async with self._get_rwlock().writer_lock:
self._storage = self._drop_filter_algorithm.filter_df_by_min_max_timestamp(
self._storage, timestamp, None)
async def drop_weather_forecast_older_than(
self, timestamp: pd.Timestamp) -> None:
logger.debug(
f"Requested deleting weather forecast older than {timestamp}")
async with self._get_rwlock().writer_lock:
self._storage = self._drop_filter_algorithm.filter_df_by_min_max_timestamp(
self._storage, timestamp, None)
def __init__(
self,
settings_repository: AbstractSettingsRepository,
) -> None:
self._settings_repository = settings_repository
logger.debug("Creating instance")
def init(self,
loader: AbstractSyncTimedeltaLoader
) -> pd.DataFrame:
logger.debug("Initialization of Resource")
timedelta_df = loader.load_timedelta()
return timedelta_df
def __init__(self, provider: Provider, **kwargs) -> None:
super().__init__(**kwargs)
self._provider = provider
logger.debug(f"Creating instance:" f"service provider: {provider}")
def init(self, api_routers: list) -> FastAPI:
logger.debug("Initialization of FastAPI app")
app = FastAPI()
for router in api_routers:
app.include_router(router)
return app
async def init(self, db_url: str) -> AsyncEngine:
logger.debug(f"Initialize db engine with url: {db_url}")
db_engine = create_async_engine(db_url)
async with db_engine.begin() as conn:
await conn.run_sync(Setting.metadata.create_all)
return db_engine
async def set_weather_forecast(self, weather_df: pd.DataFrame) -> None:
logger.debug(f"Add {len(weather_df)} weather rows")
async with self._get_rwlock().writer_lock:
self._storage = self._storage.append(weather_df)
self._storage = self._storage.drop_duplicates(
column_names.TIMESTAMP, keep="last", ignore_index=True)
self._storage = self._storage.sort_values(
by=column_names.TIMESTAMP, ignore_index=True)
def __init__(self,
timestamp_report_pattern_v1: str,
control_action_repository: ControlActionsRepository
) -> None:
self._timestamp_report_pattern_v1 = timestamp_report_pattern_v1
self._control_action_repository = control_action_repository
logger.debug("Creating instance")
async def init(self, db_engine: AsyncEngine) -> scoped_session:
logger.debug("Initialize db session factory")
session_factory = scoped_session(sessionmaker(autocommit=False,
autoflush=False,
bind=db_engine,
class_=AsyncSession),
scopefunc=asyncio.current_task)
return session_factory
async def add_control_actions(self,
control_actions_df: pd.DataFrame) -> None:
logger.debug(
f"Add the {len(control_actions_df)} control actions to repository")
async with self._get_rwlock().writer_lock:
self._storage = self._storage.append(control_actions_df)
self._storage = self._storage.drop_duplicates(
column_names.TIMESTAMP, keep="last", ignore_index=True)
self._storage = self._storage.sort_values(
by=column_names.TIMESTAMP, ignore_index=True)
async def init(self, session_factory,
dtype_converters: List[DTypeConverter],
default_settings: Dict) -> AbstractSettingsRepository:
logger.debug("Initialization of Resource")
settings_repository = DBSettingsRepository(session_factory,
dtype_converters)
current_settings = await settings_repository.get_all()
new_settings = deepcopy(default_settings)
new_settings.update(current_settings)
await settings_repository.set_all(new_settings)
return settings_repository
def __init__(self,
weather_forecast_loader: AbstractAsyncWeatherLoader,
weather_forecast_processor: AbstractWeatherProcessor,
weather_forecast_repository: WeatherForecastRepository,
preload_timedelta: pd.Timedelta = pd.Timedelta(hours=3),
executor: ThreadPoolExecutor = None) -> None:
self._weather_forecast_loader = weather_forecast_loader
self._weather_forecast_processor = weather_forecast_processor
self._weather_forecast_repository = weather_forecast_repository
self._preload_timedelta = preload_timedelta
self._executor = executor
logger.debug("Creating instance")
async def get_weather_forecast_by_timestamp_range(
self, start_timestamp: pd.Timestamp,
end_timestamp: pd.Timestamp) -> pd.DataFrame:
logger.debug(f"Requested weather forecast for timestamp range: "
f"{start_timestamp}: {end_timestamp}")
async with self._get_rwlock().reader_lock:
weather_forecast_df = \
self._filter_algorithm.filter_df_by_min_max_timestamp(
self._storage,
start_timestamp,
end_timestamp
)
return weather_forecast_df
async def get_control_actions_by_timestamp_range(
self, start_timestamp: pd.Timestamp,
end_timestamp: pd.Timestamp) -> pd.DataFrame:
logger.debug(f"Requested control actions for timestamp range: "
f"{start_timestamp}: {end_timestamp}")
async with self._get_rwlock().reader_lock:
control_actions_df = \
self._filter_algorithm.filter_df_by_min_max_timestamp(
self._storage,
start_timestamp,
end_timestamp
)
return control_actions_df
def __init__(
self,
filter_algorithm:
AbstractTimestampFilterAlgorithm = LeftClosedTimestampFilterAlgorithm(
),
drop_filter_algorithm:
AbstractTimestampFilterAlgorithm = LeftClosedTimestampFilterAlgorithm(
)
) -> None:
self._rwlock = None
self._storage: pd.DataFrame = dataset_prototypes.CONTROL_ACTION.copy()
self._filter_algorithm = filter_algorithm
self._drop_filter_algorithm = drop_filter_algorithm
logger.debug(f"Creating instance:"
f"filter_algorithm: {filter_algorithm}"
f"drop_filter_algorithm: {drop_filter_algorithm}")
async def get_predicted_boiler_temp(
datetime_range: InputDatetimeRange = Depends(),
work_timezone: InputTimezone = Depends(),
control_action_report_service: ControlActionReportService = Depends(
Provide[Services.control_action_report_pkg.
control_action_report_service])):
# noinspection SpellCheckingInspection
"""
Метод для получения рекомендуемой температуры, которую необходимо выставить на бойлере.
Принимает 3 **опциональных** параметра.
- **start_datetime**: Дата время начала управляющего воздействия в формате ISO 8601.
- **end_datetime**: Дата время окончания управляющего воздействия в формате ISO 8601.
- **timezone**: Имя временной зоны для обработки запроса и генерации ответа.
Если не указан - используется временная зона из конфигов.
ISO 8601: https://en.wikipedia.org/wiki/ISO_8601
Временные зоны: см. «TZ database name» https://en.wikipedia.org/wiki/List_of_tz_database_time_zones#List
---
Формат времени в запросе:
- YYYY-MM-DD?HH:MM[:SS[.fffffff]][+HH:MM] где ? это T или символ пробела.
Примеры:
- 2020-01-30T00:17:01.1234567+05:00 - Для обработки даты и времени используется временная зона из самой строки,
формат «O» в C#.
- 2020-01-30 00:17:07+05:00 - Для обработки даты и времени используется временная зона из самой строки.
- 2020-01-30 00:17+05:30 - Для обработки даты и времени используется временная зона из самой строки.
- 2020-01-30 00:17+05 - Для обработки даты и времени используется временная зона из самой строки.
- 2020-01-30 00:17 - Используется временная зона из параметра timezone.
---
Формат времени в ответе:
- 2020-01-30T00:17:07+05:00 - Парсится при помощи DateTimeStyle.RoundtripKind в C#.
При формировании ответа используется врменная зона из парметра timezone.
"""
logger.debug(
f"Requested predicted boiler temp for dates range "
f"from {datetime_range.start_datetime} to {datetime_range.end_datetime} "
f"with timezone {work_timezone.name}")
control_action = await control_action_report_service.report_v2(
datetime_range.start_datetime, datetime_range.end_datetime,
work_timezone.timezone)
return control_action
def __init__(self,
weather_forecast_repository: WeatherForecastRepository,
control_actions_repository: ControlActionsRepository,
control_action_predictor: AbstractControlActionPredictor,
model_requirements: AbstractModelRequirements,
timestamp_round_algo: AbstractTimestampRoundAlgorithm,
timedelta: pd.Timedelta,
timedelta_predict_forward: pd.Timedelta = pd.Timedelta(
seconds=3600),
executor: ThreadPoolExecutor = None) -> None:
self._weather_forecast_repository = weather_forecast_repository
self._control_action_repository = control_actions_repository
self._control_action_predictor = control_action_predictor
self._model_requirements = model_requirements
self._timestamp_round_algo = timestamp_round_algo
self._timedelta_predict_forward = timedelta_predict_forward
self._timedelta = timedelta
self._executor = executor
logger.debug("Creating instance")
async def get_predicted_boiler_temp(
dates_range: InputDatesRange = Depends(),
work_timezone: InputTimezone = Depends(),
control_action_report_service: ControlActionReportService = Depends(
Provide[Services.control_action_report_pkg.
control_action_report_service])):
"""
Метод для получения рекомендуемой температуры, которую необходимо выставить на бойлере.
Принимает 3 **опциональных** параметра.
- **start_datetime**: Дата время начала управляющего воздействия (формат см. в конфигах).
- **end_datetime**: Дата время окончания управляющего воздействия (формат см. в конфигах).
- **timezone**: Имя временной зоны для обработки запроса и генерации ответа.
Если не указан - используется временная зона из конфигов.
"""
logger.debug(f"Requested predicted boiler temp for dates range "
f"from {dates_range.start_date} to {dates_range.end_date} "
f"with timezone {work_timezone.name}")
control_action = await control_action_report_service.report_v1(
dates_range.start_date, dates_range.end_date, work_timezone.timezone)
return control_action
def init(self, filepath: str) -> pd.DataFrame:
filepath = os.path.abspath(filepath)
logger.debug(f"Loading correlation temp table from {filepath}")
temp_correlation_table = pd.read_pickle(filepath)
return temp_correlation_table
async def _run_update_async(self):
logger.debug("Run update")
service: ControlActionPredictionService = await self._provider()
await service.update_control_actions_async()
async def _run_update_async(self):
logger.debug("Run update")
service: TempGraphUpdateService = self._provider()
await service.update_temp_graph_async()
def __init__(self, provider: Provider, **kwargs) -> None:
super().__init__(**kwargs)
self._provider = provider
logger.debug(f"Service provider is set to {provider}")
async def _run_update_async(self):
logger.debug("Run update")
service: SimpleWeatherForecastService = self._provider()
await service.update_weather_forecast_async()
async def update_temp_graph_async(self) -> None:
logger.info("Requesting temp graph update")
temp_graph = await self._temp_graph_loader.load_temp_graph()
self._temp_graph_dumper.dump_temp_graph(temp_graph)
logger.debug("temp graph is updated")
def __init__(self, temp_graph_loader: AbstractAsyncTempGraphLoader,
temp_graph_dumper: AbstractSyncTempGraphDumper) -> None:
self._temp_graph_loader = temp_graph_loader
self._temp_graph_dumper = temp_graph_dumper
logger.debug("Creating instance")
