From 8c9e2ccbbd23a440d964b9f400e66aeea3208d71 Mon Sep 17 00:00:00 2001 From: Ricardo Garcia Silva Date: Fri, 10 May 2024 17:22:50 +0100 Subject: [PATCH 01/11] Started adding code for getting values of NetCDF datasets via THREDDS NCSS --- arpav_ppcv/operations.py | 75 +++++++++++++++++++++++++++++++++ arpav_ppcv/thredds/models.py | 23 ++++++++++ arpav_ppcv/thredds/ncss.py | 81 ++++++++++++++++++++++++++++++++++++ 3 files changed, 179 insertions(+) create mode 100644 arpav_ppcv/operations.py create mode 100644 arpav_ppcv/thredds/ncss.py diff --git a/arpav_ppcv/operations.py b/arpav_ppcv/operations.py new file mode 100644 index 00000000..62bb6211 --- /dev/null +++ b/arpav_ppcv/operations.py @@ -0,0 +1,75 @@ +import datetime as dt + +import httpx +import shapely.io +import sqlmodel + +from . import database +from .config import ArpavPpcvSettings +from .thredds import ncss + + +def get_coverage_time_series( + settings: ArpavPpcvSettings, + session: sqlmodel.Session, + http_client: httpx.Client, + coverage_identifier: str, + coordinates: str, # a wkt Point + temporal_range: str, + include_coverage_data: bool = True, + include_observation_data: bool = False, + coverage_data_smoothing: str | None = None, + observation_data_smoothing: str | None = None, + include_coverage_uncertainty: bool = False, + include_coverage_related_data: bool = False, +): + coverage_configuration_name = coverage_identifier.partition("-")[0] + coverage_configuration = database.get_coverage_configuration_by_name( + session, coverage_configuration_name) + if coverage_configuration is not None: + start, end = _parse_temporal_range(temporal_range) + geom = shapely.io.from_wkt(coordinates) + + ncss_url = "/".join(( + settings.thredds_server.base_url, + settings.thredds_server.netcdf_subset_service_url_fragment, + coverage_configuration.get_thredds_url_fragment(coverage_identifier) + )) + + coverage_data = ncss.query_dataset( + http_client, + thredds_ncss_url=ncss_url, + variable_name=None, + longitude=geom.x, + latitude=geom.y, + time_start=start, + time_end=end, + ) + else: + raise ValueError("Invalid coverage identifier") + + +def _parse_temporal_range( + raw_temporal_range: str) -> tuple[dt.datetime | None, dt.datetime | None]: + """Parse a temporal range string. + + The expected format for the input temporal range is described in the + OGC API - EDR standard: + + https://docs.ogc.org/is/19-086r6/19-086r6.html#req_core_rc-time-response + + Basically it is a string with an optional start datetime and an optional end + datetime. + """ + + raw_start, raw_end = raw_temporal_range.partition("/")[::2] + open_interval_pattern = ".." + if raw_start != open_interval_pattern: + start = dt.datetime.fromisoformat(raw_start) + else: + start = None + if raw_end != open_interval_pattern: + end = dt.datetime.fromisoformat(raw_end) + else: + end = None + return start, end diff --git a/arpav_ppcv/thredds/models.py b/arpav_ppcv/thredds/models.py index c66e362e..4d0c9a39 100644 --- a/arpav_ppcv/thredds/models.py +++ b/arpav_ppcv/thredds/models.py @@ -1,8 +1,11 @@ import dataclasses +import datetime as dt import enum import fnmatch import urllib.parse +import shapely + @dataclasses.dataclass class _ForecastTemporalPeriodMetadata: @@ -46,6 +49,26 @@ class AveragingPeriod(enum.Enum): THIRTY_YEAR = "thirty-year" +@dataclasses.dataclass +class ThreddsDatasetDescriptionVariable: + name: str + description: str + units: str + + +@dataclasses.dataclass +class ThreddsDatasetDescriptionTemporalBounds: + start: dt.datetime + end: dt.datetime + + +@dataclasses.dataclass +class ThreddsDatasetDescription: + variables: list[ThreddsDatasetDescriptionVariable] + spatial_bounds: shapely.Polygon + temporal_bounds: ThreddsDatasetDescriptionTemporalBounds + + @dataclasses.dataclass class ThreddsClientService: name: str diff --git a/arpav_ppcv/thredds/ncss.py b/arpav_ppcv/thredds/ncss.py new file mode 100644 index 00000000..241c0741 --- /dev/null +++ b/arpav_ppcv/thredds/ncss.py @@ -0,0 +1,81 @@ +"""Utilities for interacting with the THREDDS NetCDF Subset Service (NCSS). + +Get more detail about NCSS at: + +https://docs.unidata.ucar.edu/tds/current/userguide/netcdf_subset_service_ref.html + +""" +import datetime as dt +import xml.etree.ElementTree as etree + +import httpx +import shapely + +from . import models + + +def get_dataset_description( + http_client: httpx.Client, + thredds_ncss_url: str, +) -> models.ThreddsDatasetDescription: + response = http_client.get(f"{thredds_ncss_url}/dataset.xml") + response.raise_for_status() + root = etree.fromstring(response.text) + variables = [] + for var_info in root.findall("./gridSet/grid"): + variables.append( + models.ThreddsDatasetDescriptionVariable( + name=var_info.get("name"), + description=var_info.get("desc"), + units=var_info.findall("./*[@name='units']")[0].get("value") + ) + ) + time_span_el = root.findall("./TimeSpan")[0] + temporal_bounds = models.ThreddsDatasetDescriptionTemporalBounds( + start=dt.datetime.fromisoformat(time_span_el.findall("./begin")[0].text), + end=dt.datetime.fromisoformat(time_span_el.findall("./end")[0].text), + ) + lat_lon_el = root.findall("./LatLonBox")[0] + spatial_bounds = shapely.box( + xmin=float(lat_lon_el.findall("./west")[0].text), + ymin=float(lat_lon_el.findall("./south")[0].text), + xmax=float(lat_lon_el.findall("./east")[0].text), + ymax=float(lat_lon_el.findall("./north")[0].text) + ) + return models.ThreddsDatasetDescription( + variables=variables, + spatial_bounds=spatial_bounds, + temporal_bounds=temporal_bounds + ) + + +def query_dataset( + http_client: httpx.Client, + thredds_ncss_url: str, + variable_name: str, + longitude: float, + latitude: float, + time_start: dt.datetime | None = None, + time_end: dt.datetime | None = None, +): + if time_start is None or time_end is None: + dataset_description = get_dataset_description(http_client, thredds_ncss_url) + start = time_start or dataset_description.temporal_bounds.start + end = time_end or dataset_description.temporal_bounds.end + else: + start = time_start + end = time_end + response = http_client.get( + thredds_ncss_url, + params={ + "var": variable_name, + "time_start": start.isoformat(), + "time_end": end.isoformat(), + "latitude": latitude, + "longitude": longitude, + "accept": "CSV" + } + ) + response.raise_for_status() + raw_data = response.text + return raw_data \ No newline at end of file From c283cf0e2fab728f8f8bf271dfa72a996d3360c5 Mon Sep 17 00:00:00 2001 From: Ricardo Garcia Silva Date: Sun, 12 May 2024 19:02:39 +0100 Subject: [PATCH 02/11] Adding query-related stuff --- arpav_ppcv/config.py | 1 + arpav_ppcv/database.py | 24 +++++++++++-- arpav_ppcv/operations.py | 54 +++++++++++++++++++++++++++--- arpav_ppcv/schemas/coverages.py | 20 +++++++++++ arpav_ppcv/schemas/observations.py | 11 +++++- arpav_ppcv/thredds/ncss.py | 17 +++++----- 6 files changed, 111 insertions(+), 16 deletions(-) diff --git a/arpav_ppcv/config.py b/arpav_ppcv/config.py index 545e3911..7148cdd5 100644 --- a/arpav_ppcv/config.py +++ b/arpav_ppcv/config.py @@ -160,6 +160,7 @@ class ArpavPpcvSettings(BaseSettings): # noqa templates_dir: Optional[Path] = Path(__file__).parent / "webapp/templates" static_dir: Optional[Path] = Path(__file__).parent / "webapp/static" thredds_server: ThreddsServerSettings = ThreddsServerSettings() + nearest_station_radius_meters: int = 10_000 v1_api_mount_prefix: str = "/api/v1" v2_api_mount_prefix: str = "/api/v2" django_app: DjangoAppSettings = DjangoAppSettings() diff --git a/arpav_ppcv/database.py b/arpav_ppcv/database.py index 64ff87a2..9e67a097 100644 --- a/arpav_ppcv/database.py +++ b/arpav_ppcv/database.py @@ -14,6 +14,7 @@ import sqlalchemy.exc import sqlmodel from geoalchemy2.shape import from_shape +from sqlalchemy import func from . import config from .schemas import ( @@ -240,12 +241,20 @@ def list_stations( limit: int = 20, offset: int = 0, include_total: bool = False, + polygon_intersection_filter: shapely.Polygon = None, ) -> tuple[Sequence[observations.Station], Optional[int]]: """List existing stations.""" statement = ( sqlmodel.select(observations.Station) .order_by(observations.Station.code) ) + if polygon_intersection_filter is not None: + statement = statement.where( + func.ST_Intersects( + observations.Station.geom, + func.ST_GeomFromWKB(shapely.io.to_wkb(polygon_intersection_filter)) + ) + ) items = session.exec(statement.offset(offset).limit(limit)).all() num_items = ( _get_total_num_records(session, statement) if include_total else None) @@ -254,9 +263,20 @@ def list_stations( def collect_all_stations( session: sqlmodel.Session, + polygon_intersection_filter: shapely.Polygon = None, ) -> Sequence[observations.Station]: - _, num_total = list_stations(session, limit=1, include_total=True) - result, _ = list_stations(session, limit=num_total, include_total=False) + _, num_total = list_stations( + session, + limit=1, + include_total=True, + polygon_intersection_filter=polygon_intersection_filter + ) + result, _ = list_stations( + session, + limit=num_total, + include_total=False, + polygon_intersection_filter=polygon_intersection_filter + ) return result diff --git a/arpav_ppcv/operations.py b/arpav_ppcv/operations.py index 62bb6211..a960165c 100644 --- a/arpav_ppcv/operations.py +++ b/arpav_ppcv/operations.py @@ -1,8 +1,14 @@ import datetime as dt +import functools import httpx +import pyproj +import shapely import shapely.io import sqlmodel +from geoalchemy2.shape import to_shape +from pyproj.enums import TransformDirection +from shapely.ops import transform from . import database from .config import ArpavPpcvSettings @@ -28,23 +34,34 @@ def get_coverage_time_series( session, coverage_configuration_name) if coverage_configuration is not None: start, end = _parse_temporal_range(temporal_range) - geom = shapely.io.from_wkt(coordinates) - + point_geom = shapely.io.from_wkt(coordinates) ncss_url = "/".join(( settings.thredds_server.base_url, settings.thredds_server.netcdf_subset_service_url_fragment, coverage_configuration.get_thredds_url_fragment(coverage_identifier) )) - coverage_data = ncss.query_dataset( http_client, thredds_ncss_url=ncss_url, variable_name=None, - longitude=geom.x, - latitude=geom.y, + longitude=point_geom.x, + latitude=point_geom.y, time_start=start, time_end=end, ) + point_buffer_geom = _get_spatial_buffer( + point_geom, settings.nearest_station_radius_meters) + nearby_stations = database.collect_all_stations( + session, polygon_intersection_filter=point_buffer_geom) + if len(nearby_stations) > 0: + sorted_stations = sorted( + nearby_stations, key=lambda s: to_shape(s.geom).distance(point_geom)) + # order nearby stations by distance and then iterate through them in order to + # try to get measurements for the relevant variable and temporal aggregation + for station in sorted_stations: + ... + else: + station_data = [] else: raise ValueError("Invalid coverage identifier") @@ -73,3 +90,30 @@ def _parse_temporal_range( else: end = None return start, end + + +def _get_spatial_buffer(point_geom: shapely.Point, distance_meters: int) -> shapely.Polygon: + """Buffer input point. + + This function expects the input point geometry to be in EPSG:4326 CRS and will + return a buffer also in the same CRS. However, the buffer's distance is expected + to be provided in meters. This function takes care of reprojecting the input + geometry and the output buffer too. + """ + coordinate_transformer = pyproj.Transformer.from_crs( + pyproj.CRS("EPSG:4326"), + pyproj.CRS("EPSG:3004"), + always_xy=True + ).transform + forward_coordinate_transformer = functools.partial( + coordinate_transformer, direction=TransformDirection.FORWARD) + inverse_coordinate_transformer = functools.partial( + coordinate_transformer, direction=TransformDirection.INVERSE) + point_geom_projected = transform( + forward_coordinate_transformer, point_geom) + buffer_geom_projected = shapely.buffer( + point_geom_projected, + distance=distance_meters + ) + return transform( + inverse_coordinate_transformer, buffer_geom_projected) \ No newline at end of file diff --git a/arpav_ppcv/schemas/coverages.py b/arpav_ppcv/schemas/coverages.py index 3252dc5a..b99bbe0e 100644 --- a/arpav_ppcv/schemas/coverages.py +++ b/arpav_ppcv/schemas/coverages.py @@ -1,3 +1,4 @@ +import enum import logging import re import uuid @@ -5,16 +6,26 @@ Annotated, Optional, Final, + TYPE_CHECKING, ) import pydantic import sqlalchemy import sqlmodel +if TYPE_CHECKING: + from . import observations + logger = logging.getLogger(__name__) _NAME_PATTERN: Final[str] = r"^[a-z][a-z0-9_]+$" +class ObservationAggregationType(enum.Enum): + MONTHLY = "MONTHLY" + SEASONAL = "SEASONAL" + YEARLY = "YEARLY" + + class ConfigurationParameterValue(sqlmodel.SQLModel, table=True): __table_args__ = ( sqlalchemy.ForeignKeyConstraint( @@ -118,11 +129,17 @@ class CoverageConfiguration(sqlmodel.SQLModel, table=True): primary_key=True ) name: str = sqlmodel.Field(unique=True, index=True) + dataset_name: str thredds_url_pattern: str unit: str = "" palette: str color_scale_min: float = 0.0 color_scale_max: float = 1.0 + observation_variable_id: Optional[uuid.UUID] = sqlmodel.Field( + default=None, + foreign_key="variable.id" + ) + observation_variable_aggregation_type: Optional[ObservationAggregationType] = None possible_values: list["ConfigurationParameterPossibleValue"] = sqlmodel.Relationship( back_populates="coverage_configuration", @@ -131,6 +148,9 @@ class CoverageConfiguration(sqlmodel.SQLModel, table=True): "passive_deletes": True, } ) + related_observation_variable: "observations.Variable" = sqlmodel.Relationship( + back_populates="related_coverage_configurations" + ) @pydantic.computed_field() @property diff --git a/arpav_ppcv/schemas/observations.py b/arpav_ppcv/schemas/observations.py index 53002159..ec94a600 100644 --- a/arpav_ppcv/schemas/observations.py +++ b/arpav_ppcv/schemas/observations.py @@ -1,7 +1,10 @@ import datetime as dt import enum import uuid -from typing import Optional +from typing import ( + Optional, + TYPE_CHECKING, +) import geojson_pydantic import geoalchemy2 @@ -11,6 +14,9 @@ from . import fields +if TYPE_CHECKING: + from . import coverages + class Season(enum.Enum): WINTER = "WINTER" @@ -114,6 +120,9 @@ class VariableBase(sqlmodel.SQLModel): class Variable(VariableBase, table=True): + related_coverage_configurations: list["coverages.CoverageConfiguration"] = sqlmodel.Relationship( + back_populates="related_observation_variable" + ) monthly_measurements: list["MonthlyMeasurement"] = sqlmodel.Relationship( back_populates="variable", sa_relationship_kwargs={ diff --git a/arpav_ppcv/thredds/ncss.py b/arpav_ppcv/thredds/ncss.py index 241c0741..b6586992 100644 --- a/arpav_ppcv/thredds/ncss.py +++ b/arpav_ppcv/thredds/ncss.py @@ -59,21 +59,22 @@ def query_dataset( time_end: dt.datetime | None = None, ): if time_start is None or time_end is None: - dataset_description = get_dataset_description(http_client, thredds_ncss_url) - start = time_start or dataset_description.temporal_bounds.start - end = time_end or dataset_description.temporal_bounds.end + temporal_parameters = { + "time": "all", + } else: - start = time_start - end = time_end + temporal_parameters = { + "time_start": time_start.isoformat(), + "time_end": time_end.isoformat(), + } response = http_client.get( thredds_ncss_url, params={ "var": variable_name, - "time_start": start.isoformat(), - "time_end": end.isoformat(), "latitude": latitude, "longitude": longitude, - "accept": "CSV" + "accept": "CSV", + **temporal_parameters, } ) response.raise_for_status() From ee596dd534baad39d42de28c7c9906d2550bce51 Mon Sep 17 00:00:00 2001 From: Ricardo Garcia Silva Date: Sun, 12 May 2024 23:22:54 +0100 Subject: [PATCH 03/11] Added initial jupyter service conf to dev stack --- arpav_ppcv/schemas/coverages.py | 2 +- docker/compose.dev.yaml | 116 +++++++++++++------------------- 2 files changed, 49 insertions(+), 69 deletions(-) diff --git a/arpav_ppcv/schemas/coverages.py b/arpav_ppcv/schemas/coverages.py index b99bbe0e..b5e362c5 100644 --- a/arpav_ppcv/schemas/coverages.py +++ b/arpav_ppcv/schemas/coverages.py @@ -129,7 +129,7 @@ class CoverageConfiguration(sqlmodel.SQLModel, table=True): primary_key=True ) name: str = sqlmodel.Field(unique=True, index=True) - dataset_name: str + netcdf_main_dataset_name: str thredds_url_pattern: str unit: str = "" palette: str diff --git a/docker/compose.dev.yaml b/docker/compose.dev.yaml index ca19d5e1..a8261129 100644 --- a/docker/compose.dev.yaml +++ b/docker/compose.dev.yaml @@ -8,82 +8,62 @@ # dev, testing and debugging # - mounts code repository inside the relevant container as a bind volume +x-webapp-image: &webapp-image "ghcr.io/geobeyond/arpav-ppcv-backend/arpav-ppcv-backend:${CURRENT_GIT_BRANCH:-latest}" + +x-common-env: &common-env + ARPAV_PPCV__DEBUG: true + ARPAV_PPCV__BIND_HOST: 0.0.0.0 + ARPAV_PPCV__BIND_PORT: 5001 + ARPAV_PPCV__PUBLIC_URL: http://localhost:5001 + ARPAV_PPCV__DB_DSN: postgresql://arpav:arpavpassword@db:5432/arpav_ppcv + ARPAV_PPCV__TEST_DB_DSN: postgresql://arpavtest:arpavtestpassword@test-db:5432/arpav_ppcv_test + ARPAV_PPCV__SESSION_SECRET_KEY: some-key + ARPAV_PPCV__ADMIN_USER__USERNAME: admin + ARPAV_PPCV__ADMIN_USER__PASSWORD: 12345678 + ARPAV_PPCV__LOG_CONFIG_FILE: /home/appuser/app/dev-log-config.yml + ARPAV_PPCV__DJANGO_APP__DB_DSN: postgres://postgres:postgres@legacy-db:5432/postgres + ARPAV_PPCV__DJANGO_APP__THREDDS__PORT: 8081 + ARPAV_PPCV__DJANGO_APP__REDIS_DSN: redis://redis:6379 + ARPAV_PPCV__DJANGO_APP__SECRET_KEY: some-dev-key + ARPAV_PPCV__THREDDS_SERVER__BASE_URL: http://thredds:8080/thredds + +x-common-volumes: &common-volumes + - type: bind + source: $PWD + target: /home/appuser/app + - type: bind + source: $HOME/data/geobeyond/arpav-ppcv/datasets + target: /home/appuser/data/datasets + - type: bind + source: $HOME/data/geobeyond/arpav-ppcv/netcdf-uncertainty-example + target: /home/appuser/data/additional + services: webapp: - image: "ghcr.io/geobeyond/arpav-ppcv-backend/arpav-ppcv-backend:${CURRENT_GIT_BRANCH:-latest}" + image: *webapp-image environment: - ARPAV_PPCV__DEBUG: true - ARPAV_PPCV__BIND_HOST: 0.0.0.0 - ARPAV_PPCV__BIND_PORT: 5001 - ARPAV_PPCV__PUBLIC_URL: http://localhost:5001 - ARPAV_PPCV__DB_DSN: postgresql://arpav:arpavpassword@db:5432/arpav_ppcv - ARPAV_PPCV__TEST_DB_DSN: postgresql://arpavtest:arpavtestpassword@test-db:5432/arpav_ppcv_test - ARPAV_PPCV__SESSION_SECRET_KEY: some-key - ARPAV_PPCV__ADMIN_USER__USERNAME: admin - ARPAV_PPCV__ADMIN_USER__PASSWORD: 12345678 - ARPAV_PPCV__LOG_CONFIG_FILE: /home/appuser/app/dev-log-config.yml - ARPAV_PPCV__DJANGO_APP__DB_DSN: postgres://postgres:postgres@legacy-db:5432/postgres - ARPAV_PPCV__DJANGO_APP__THREDDS__PORT: 8081 - ARPAV_PPCV__DJANGO_APP__REDIS_DSN: redis://redis:6379 - ARPAV_PPCV__DJANGO_APP__SECRET_KEY: some-dev-key - ARPAV_PPCV__THREDDS_SERVER__BASE_URL: http://thredds:8080/thredds - ARPAV_PPCV__THREDDS_SERVER__DATASETS: > - { - "uncertainty_test_giovanni": { - "thredds_url_pattern": "tests/giovanni-sample/tas_avgagree_anom_tw2_rcp26_DJF_VFVGTAAn.nc", - "palette": "uncert-stippled/seq-YlOrRd", - "range": [1, 6] - }, - "uncertainty_test": { - "thredds_url_pattern": "tests/test-script-agree.nc", - "palette": "uncert-stippled/seq-YlOrRd", - "range": [1, 6] - }, - "tas_absolute": { - "thredds_url_pattern": "ensymbc/tas_avg_{scenario}_{year_period}_ts19762100_ls.nc", - "allowed_values": { - "scenario": [ - "rcp26", - "rcp45", - "rcp85" - ], - "year_period": [ - "winter", - "spring", - "summer", - "autumn" - ] - }, - "unit": "ºC", - "palette": "default/seq-YlOrRd", - "range": [-3, 32] - }, - "tas_anomaly": { - "thredds_url_pattern": "ensembletwbc/tas_avg_anom_{time_window}_{scenario}_{year_period}.nc", - "allowed_values": { - "time_window": ["tw1", "tw2"], - "scenario": ["rcp26"], - "year_period": ["annual"] - }, - "unit": "ºC", - "palette": "seq-YlOrRd", - "range": [0, 6] - } - } + *common-env ports: - target: 5001 published: 5001 volumes: - - type: bind - source: $PWD - target: /home/appuser/app - - type: bind - source: $HOME/data/geobeyond/arpav-ppcv/datasets - target: /home/appuser/data/datasets - - type: bind - source: $HOME/data/geobeyond/arpav-ppcv/netcdf-uncertainty-example - target: /home/appuser/data/additional + *common-volumes + + # jupyter: + # image: *webapp-image + # environment: + # *common-env + # ports: + # - target: 5001 + # published: 5001 + # volumes: + # *common-volumes + # entrypoint: ['/bin/bash', '-c'] + # command: + # - | + # poetry install --with jupyter + # poetry run jupyter legacy-db: environment: From 32b83f33cbb9a9c55adc0b76c1a5d4047c6bb0cb Mon Sep 17 00:00:00 2001 From: Ricardo Garcia Silva Date: Mon, 13 May 2024 20:02:29 +0100 Subject: [PATCH 04/11] Initial implementation of time series endpoint for coverages --- arpav_ppcv/database.py | 8 +- arpav_ppcv/main.py | 71 +- arpav_ppcv/migrations/env.py | 3 + arpav_ppcv/operations.py | 137 +- arpav_ppcv/schemas/coverages.py | 24 + arpav_ppcv/schemas/observations.py | 4 + arpav_ppcv/thredds/ncss.py | 18 +- arpav_ppcv/webapp/admin/schemas.py | 11 + arpav_ppcv/webapp/admin/views.py | 135 +- arpav_ppcv/webapp/api_v2/routers/coverages.py | 94 +- arpav_ppcv/webapp/api_v2/schemas/coverages.py | 11 + arpav_ppcv/webapp/dependencies.py | 4 + docker/compose.dev.yaml | 28 +- poetry.lock | 2005 ++++++++++++++++- pyproject.toml | 17 +- tests/test_operations.py | 16 + 16 files changed, 2385 insertions(+), 201 deletions(-) create mode 100644 tests/test_operations.py diff --git a/arpav_ppcv/database.py b/arpav_ppcv/database.py index 9e67a097..ebda37b7 100644 --- a/arpav_ppcv/database.py +++ b/arpav_ppcv/database.py @@ -815,11 +815,14 @@ def create_coverage_configuration( to_refresh = [] db_coverage_configuration = coverages.CoverageConfiguration( name=coverage_configuration_create.name, + netcdf_main_dataset_name=coverage_configuration_create.netcdf_main_dataset_name, thredds_url_pattern=coverage_configuration_create.thredds_url_pattern, unit=coverage_configuration_create.unit, palette=coverage_configuration_create.palette, color_scale_min=coverage_configuration_create.color_scale_min, color_scale_max=coverage_configuration_create.color_scale_max, + related_observation_variable=coverage_configuration_create.related_observation_variable, + observation_variable_aggregation_type=coverage_configuration_create.observation_variable_aggregation_type, ) session.add(db_coverage_configuration) to_refresh.append(db_coverage_configuration) @@ -872,7 +875,10 @@ def update_coverage_configuration( session.add(db_possible_value) to_refresh.append(db_possible_value) data_ = coverage_configuration_update.model_dump( - exclude={"possible_values"}, exclude_unset=True, exclude_none=True) + exclude={"possible_values"}, + exclude_unset=True, + exclude_none=True + ) for key, value in data_.items(): setattr(db_coverage_configuration, key, value) session.add(db_coverage_configuration) diff --git a/arpav_ppcv/main.py b/arpav_ppcv/main.py index 38e21e86..f833e918 100644 --- a/arpav_ppcv/main.py +++ b/arpav_ppcv/main.py @@ -15,7 +15,6 @@ import anyio import django import httpx -import sqlmodel import typer import yaml from django.conf import settings as django_settings @@ -23,27 +22,25 @@ from rich import print from rich.padding import Padding from rich.panel import Panel -from sqlalchemy.exc import IntegrityError from . import ( config, database, ) from .cliapp.app import app as cli_app +from .bootstrapper.cliapp import app as bootstrapper_app from .observations_harvester.cliapp import app as observations_harvester_app -from .schemas import observations as observations_models from .thredds import crawler from .webapp.legacy.django_settings import get_custom_django_settings app = typer.Typer() db_app = typer.Typer() dev_app = typer.Typer() -bootstrap_app = typer.Typer() app.add_typer(cli_app, name="app") app.add_typer(db_app, name="db") app.add_typer(dev_app, name="dev") app.add_typer(observations_harvester_app, name="observations-harvester") -app.add_typer(bootstrap_app, name="bootstrap") +app.add_typer(bootstrapper_app, name="bootstrap") @app.callback() @@ -89,10 +86,14 @@ def generate_migration(ctx: typer.Context, migration_message: str): @db_app.command(name="upgrade") -def upgrade_db(ctx: typer.Context) -> None: +def upgrade_db( + ctx: typer.Context, + revision_identifier: Optional[str] = None +) -> None: """Apply any pending migration files.""" print("Upgrading database...") - alembic.command.upgrade(ctx.obj["alembic_config"], "head") + revision_arg = "head" if revision_identifier is None else revision_identifier + alembic.command.upgrade(ctx.obj["alembic_config"], revision_arg) print("Done!") @@ -235,59 +236,3 @@ def import_thredds_datasets( wildcard_filter, force_download, ) - - -@bootstrap_app.command("observation-variables") -def bootstrap_observation_variables( - ctx: typer.Context, -): - """Create initial observation variables.""" - variables = [ - observations_models.VariableCreate( - name="TDd", - description="Mean temperature", - unit="ºC" - ), - observations_models.VariableCreate( - name="TXd", - description="Max temperature", - unit="ºC" - ), - observations_models.VariableCreate( - name="TNd", - description="Min temperature", - unit="ºC" - ), - observations_models.VariableCreate( - name="PRCPTOT", - description="Total precipitation", - unit="mm" - ), - observations_models.VariableCreate( - name="TR", - description="Tropical nights", - unit="mm" - ), - observations_models.VariableCreate( - name="SU30", - description="Hot days", - unit="mm" - ), - observations_models.VariableCreate( - name="FD", - description="Cold days", - unit="mm" - ), - ] - with sqlmodel.Session(ctx.obj["engine"]) as session: - for var_create in variables: - try: - db_variable = database.create_variable(session, var_create) - print(f"Created observation variable {db_variable.name!r}") - except IntegrityError as err: - print( - f"Could not create observation " - f"variable {var_create.name!r}: {err}" - ) - session.rollback() - print("Done!") diff --git a/arpav_ppcv/migrations/env.py b/arpav_ppcv/migrations/env.py index efb0a9ff..838172a9 100644 --- a/arpav_ppcv/migrations/env.py +++ b/arpav_ppcv/migrations/env.py @@ -1,5 +1,8 @@ from logging.config import fileConfig +# DO NOT REMOVE - this import is needed in order to enjoy proper enum support +import alembic_postgresql_enum # noqa + from sqlalchemy import create_engine from alembic import context diff --git a/arpav_ppcv/operations.py b/arpav_ppcv/operations.py index a960165c..28419077 100644 --- a/arpav_ppcv/operations.py +++ b/arpav_ppcv/operations.py @@ -1,16 +1,24 @@ import datetime as dt import functools +import io +from typing import Optional import httpx +import pandas as pd import pyproj import shapely import shapely.io import sqlmodel +from dateutil.parser import isoparse from geoalchemy2.shape import to_shape from pyproj.enums import TransformDirection from shapely.ops import transform from . import database +from .schemas import ( + coverages, + observations, +) from .config import ArpavPpcvSettings from .thredds import ncss @@ -19,56 +27,102 @@ def get_coverage_time_series( settings: ArpavPpcvSettings, session: sqlmodel.Session, http_client: httpx.Client, + coverage_configuration: coverages.CoverageConfiguration, coverage_identifier: str, - coordinates: str, # a wkt Point + point_geom: shapely.Point, temporal_range: str, include_coverage_data: bool = True, include_observation_data: bool = False, - coverage_data_smoothing: str | None = None, - observation_data_smoothing: str | None = None, + coverage_data_smoothing: coverages.CoverageDataSmoothingStrategy | None = None, + observation_data_smoothing: observations.ObservationDataSmoothingStrategy | None = None, include_coverage_uncertainty: bool = False, include_coverage_related_data: bool = False, -): - coverage_configuration_name = coverage_identifier.partition("-")[0] - coverage_configuration = database.get_coverage_configuration_by_name( - session, coverage_configuration_name) - if coverage_configuration is not None: - start, end = _parse_temporal_range(temporal_range) - point_geom = shapely.io.from_wkt(coordinates) - ncss_url = "/".join(( - settings.thredds_server.base_url, - settings.thredds_server.netcdf_subset_service_url_fragment, - coverage_configuration.get_thredds_url_fragment(coverage_identifier) - )) - coverage_data = ncss.query_dataset( - http_client, - thredds_ncss_url=ncss_url, - variable_name=None, - longitude=point_geom.x, - latitude=point_geom.y, - time_start=start, - time_end=end, - ) - point_buffer_geom = _get_spatial_buffer( - point_geom, settings.nearest_station_radius_meters) - nearby_stations = database.collect_all_stations( - session, polygon_intersection_filter=point_buffer_geom) - if len(nearby_stations) > 0: - sorted_stations = sorted( - nearby_stations, key=lambda s: to_shape(s.geom).distance(point_geom)) - # order nearby stations by distance and then iterate through them in order to - # try to get measurements for the relevant variable and temporal aggregation - for station in sorted_stations: +) -> dict[str, pd.DataFrame]: + start, end = _parse_temporal_range(temporal_range) + ncss_url = "/".join(( + settings.thredds_server.base_url, + settings.thredds_server.netcdf_subset_service_url_fragment, + coverage_configuration.get_thredds_url_fragment(coverage_identifier) + )) + raw_coverage_data = ncss.query_dataset( + http_client, + thredds_ncss_url=ncss_url, + variable_name=coverage_configuration.netcdf_main_dataset_name, + longitude=point_geom.x, + latitude=point_geom.y, + time_start=start, + time_end=end, + ) + measurements = {} + if raw_coverage_data is not None: + if include_coverage_data: + coverage_data = _process_coverage_data( + raw_coverage_data, + coverage_configuration, + coverage_data_smoothing, + start, + end + ) + measurements[coverage_configuration.name] = coverage_data + if include_observation_data: + point_buffer_geom = _get_spatial_buffer( + point_geom, settings.nearest_station_radius_meters) + nearby_stations = database.collect_all_stations( + session, polygon_intersection_filter=point_buffer_geom) + if len(nearby_stations) > 0: + sorted_stations = sorted( + nearby_stations, key=lambda s: to_shape(s.geom).distance(point_geom)) + # order nearby stations by distance and then iterate through them in order to + # try to get measurements for the relevant variable and temporal aggregation + for station in sorted_stations: + ... + else: ... - else: - station_data = [] else: - raise ValueError("Invalid coverage identifier") + raise RuntimeError("Could not retrieve coverage data") + return measurements + + +def _process_coverage_data( + raw_data: str, + coverage_configuration: coverages.CoverageConfiguration, + data_smoothing: Optional[coverages.CoverageDataSmoothingStrategy], + time_start: Optional[dt.datetime], + time_end: Optional[dt.datetime], +) -> pd.DataFrame: + # - filter out columns we don't care about + # - filter out values outside the temporal range + df = pd.read_csv(io.StringIO(raw_data), parse_dates=["time"]) + + # get name of the colum that holds the main variable + variable_name = coverage_configuration.netcdf_main_dataset_name + try: + col_name = [c for c in df.columns if c.startswith(f"{variable_name}[")][0] + except IndexError: + raise RuntimeError( + f"Could not extract main data series from dataframe " + f"with columns {df.columns}" + ) + else: + # keep only time and main variable - we don't care about other stuff + df = df[["time", col_name]] + df = df.rename(columns={col_name: variable_name}) + + # - filter out values outside the temporal range + df.set_index("time", inplace=True) + if time_start is not None: + df = df[time_start:] + if time_end is not None: + df = df[:time_end] + + if data_smoothing is not None: + ... + return df def _parse_temporal_range( raw_temporal_range: str) -> tuple[dt.datetime | None, dt.datetime | None]: - """Parse a temporal range string. + """Parse a temporal range string, converting time to UTC. The expected format for the input temporal range is described in the OGC API - EDR standard: @@ -82,17 +136,18 @@ def _parse_temporal_range( raw_start, raw_end = raw_temporal_range.partition("/")[::2] open_interval_pattern = ".." if raw_start != open_interval_pattern: - start = dt.datetime.fromisoformat(raw_start) + start = isoparse(raw_start).astimezone(dt.timezone.utc) else: start = None if raw_end != open_interval_pattern: - end = dt.datetime.fromisoformat(raw_end) + end = isoparse(raw_end).astimezone(dt.timezone.utc) else: end = None return start, end -def _get_spatial_buffer(point_geom: shapely.Point, distance_meters: int) -> shapely.Polygon: +def _get_spatial_buffer( + point_geom: shapely.Point, distance_meters: int) -> shapely.Polygon: """Buffer input point. This function expects the input point geometry to be in EPSG:4326 CRS and will diff --git a/arpav_ppcv/schemas/coverages.py b/arpav_ppcv/schemas/coverages.py index b5e362c5..d0677645 100644 --- a/arpav_ppcv/schemas/coverages.py +++ b/arpav_ppcv/schemas/coverages.py @@ -20,6 +20,10 @@ _NAME_PATTERN: Final[str] = r"^[a-z][a-z0-9_]+$" +class CoverageDataSmoothingStrategy(enum.Enum): + MOVING_AVERAGE_11_YEARS_PLUS_LOESS_SMOOTHING = "MOVING_AVERAGE_11_YEARS_PLUS_LOESS_SMOOTHING" + + class ObservationAggregationType(enum.Enum): MONTHLY = "MONTHLY" SEASONAL = "SEASONAL" @@ -169,6 +173,20 @@ def get_thredds_url_fragment(self, coverage_identifier: str) -> str: f"{{{param_name}}}", used_value.configuration_parameter_value.name) return rendered + def build_coverage_identifier( + self, parameters: list["ConfigurationParameterPossibleValue"]) -> str: + id_parts = ["{name}"] + for match_obj in re.finditer(r"(\{\w+\})", self.coverage_id_pattern): + param_name = match_obj.group(1)[1:-1] + for possible_param in parameters: + conf_param = possible_param.configuration_parameter_value.configuration_parameter + if conf_param.name == param_name: + id_parts.append(possible_param.configuration_parameter_value.name) + break + else: + raise ValueError(f"Invalid param_name {param_name!r}") + return "-".join(id_parts) + def retrieve_used_values( self, coverage_identifier: str @@ -214,12 +232,15 @@ class CoverageConfigurationCreate(sqlmodel.SQLModel): ) ) ] + netcdf_main_dataset_name: str thredds_url_pattern: str unit: str palette: str color_scale_min: float color_scale_max: float possible_values: list["ConfigurationParameterPossibleValueCreate"] + observation_variable_id: Optional[uuid.UUID] = None + observation_variable_aggregation_type: Optional[ObservationAggregationType] = None @pydantic.field_validator("thredds_url_pattern") @classmethod @@ -238,11 +259,14 @@ class CoverageConfigurationUpdate(sqlmodel.SQLModel): pattern=_NAME_PATTERN ) ] = None + netcdf_main_dataset_name: Optional[str] = None thredds_url_pattern: Optional[str] = None unit: Optional[str] = None palette: Optional[str] = None color_scale_min: Optional[float] = None color_scale_max: Optional[float] = None + observation_variable_id: Optional[uuid.UUID] = None + observation_variable_aggregation_type: Optional[ObservationAggregationType] = None possible_values: list["ConfigurationParameterPossibleValueUpdate"] @pydantic.field_validator("thredds_url_pattern") diff --git a/arpav_ppcv/schemas/observations.py b/arpav_ppcv/schemas/observations.py index ec94a600..ae9c9677 100644 --- a/arpav_ppcv/schemas/observations.py +++ b/arpav_ppcv/schemas/observations.py @@ -25,6 +25,10 @@ class Season(enum.Enum): AUTUMN = "AUTUMN" +class ObservationDataSmoothingStrategy(enum.Enum): + MOVING_AVERAGE_5_YEARS = "MOVING_AVERAGE_5_YEARS" + + class StationBase(sqlmodel.SQLModel): model_config = pydantic.ConfigDict(arbitrary_types_allowed=True) diff --git a/arpav_ppcv/thredds/ncss.py b/arpav_ppcv/thredds/ncss.py index b6586992..cd84e32a 100644 --- a/arpav_ppcv/thredds/ncss.py +++ b/arpav_ppcv/thredds/ncss.py @@ -6,13 +6,17 @@ """ import datetime as dt +import logging import xml.etree.ElementTree as etree +from typing import Optional import httpx import shapely from . import models +logger = logging.getLogger(__name__) + def get_dataset_description( http_client: httpx.Client, @@ -57,7 +61,8 @@ def query_dataset( latitude: float, time_start: dt.datetime | None = None, time_end: dt.datetime | None = None, -): +) -> Optional[str]: + """Query THREDDS for the specified variable.""" if time_start is None or time_end is None: temporal_parameters = { "time": "all", @@ -77,6 +82,11 @@ def query_dataset( **temporal_parameters, } ) - response.raise_for_status() - raw_data = response.text - return raw_data \ No newline at end of file + try: + response.raise_for_status() + except httpx.HTTPError: + logger.exception(msg="Could not retrieve data") + result = None + else: + result = response.text + return result diff --git a/arpav_ppcv/webapp/admin/schemas.py b/arpav_ppcv/webapp/admin/schemas.py index 59bb6412..38cd3e15 100644 --- a/arpav_ppcv/webapp/admin/schemas.py +++ b/arpav_ppcv/webapp/admin/schemas.py @@ -1,7 +1,10 @@ +from typing import Optional import uuid import sqlmodel +from ...schemas.coverages import ObservationAggregationType + class ConfigurationParameterValueRead(sqlmodel.SQLModel): id: uuid.UUID @@ -24,6 +27,7 @@ class ConfigurationParameterPossibleValueRead(sqlmodel.SQLModel): class CoverageConfigurationRead(sqlmodel.SQLModel): id: uuid.UUID name: str + netcdf_main_dataset_name: str coverage_id_pattern: str thredds_url_pattern: str unit: str @@ -31,3 +35,10 @@ class CoverageConfigurationRead(sqlmodel.SQLModel): color_scale_min: float color_scale_max: float possible_values: list[ConfigurationParameterPossibleValueRead] + observation_variable_aggregation_type: ObservationAggregationType + observation_variable: Optional["ObservationVariableRead"] + + +class ObservationVariableRead(sqlmodel.SQLModel): + id: uuid.UUID + name: str diff --git a/arpav_ppcv/webapp/admin/views.py b/arpav_ppcv/webapp/admin/views.py index ed6a363f..3067af8f 100644 --- a/arpav_ppcv/webapp/admin/views.py +++ b/arpav_ppcv/webapp/admin/views.py @@ -73,6 +73,24 @@ async def serialize_value( return self._get_label(value, request) +class RelatedObservationsVariableField(starlette_admin.EnumField): + + def _get_label( + self, + value: read_schemas.ObservationVariableRead, + request: Request + ) -> Any: + return value.name + + async def serialize_value( + self, + request: Request, + value: read_schemas.ObservationVariableRead, + action: RequestAction + ) -> Any: + return self._get_label(value, request) + + class ConfigurationParameterView(ModelView): identity = "configuration_parameters" name = "Configuration Parameter" @@ -254,6 +272,12 @@ def possible_values_choices_loader(request: Request) -> Sequence[tuple[str, str] return result +def related_observation_variable_choices_loader( + request: Request) -> Sequence[tuple[str, str]]: + all_obs_variables = database.collect_all_variables(request.state.session) + return [(v.name, v.name) for v in all_obs_variables] + + class CoverageConfigurationView(ModelView): identity = "coverage_configurations" name = "Coverage Configuration" @@ -263,12 +287,22 @@ class CoverageConfigurationView(ModelView): fields = ( UuidField("id"), starlette_admin.StringField("name"), + starlette_admin.StringField("netcdf_main_dataset_name"), starlette_admin.StringField("thredds_url_pattern"), starlette_admin.StringField("coverage_id_pattern", disabled=True), starlette_admin.StringField("unit"), starlette_admin.StringField("palette"), starlette_admin.FloatField("color_scale_min"), starlette_admin.FloatField("color_scale_max"), + RelatedObservationsVariableField( + "observation_variable", + help_text="Related observation variable", + choices_loader=related_observation_variable_choices_loader, + ), + starlette_admin.EnumField( + "observation_variable_aggregation_type", + enum=coverages.ObservationAggregationType + ), starlette_admin.ListField( field=PossibleConfigurationParameterValuesField( "possible_values", choices_loader=possible_values_choices_loader) @@ -277,12 +311,18 @@ class CoverageConfigurationView(ModelView): exclude_fields_from_list = ( "id", + "netcdf_main_dataset_name", "coverage_id_pattern", "possible_values", "unit", "palette", "color_scale_min", "color_scale_max", + "observation_variable", + "observation_variable_aggregation_type", + ) + exclude_fields_from_edit = ( + "coverage_id_pattern", ) async def get_pk_value(self, request: Request, obj: Any) -> Any: @@ -293,6 +333,31 @@ async def get_pk_value(self, request: Request, obj: Any) -> Any: result = await super().get_pk_value(request, obj) return str(result) + def _serialize_instance(self, instance: coverages.CoverageConfiguration): + obs_variable = instance.related_observation_variable + if obs_variable is not None: + observation_variable = read_schemas.ObservationVariableRead( + **obs_variable.model_dump()) + else: + observation_variable = None + return read_schemas.CoverageConfigurationRead( + **instance.model_dump( + exclude={"observation_variable_aggregation_type"} + ), + observation_variable_aggregation_type=( + instance.observation_variable_aggregation_type or + coverages.ObservationAggregationType.YEARLY + ), + observation_variable=observation_variable, + possible_values=[ + read_schemas.ConfigurationParameterPossibleValueRead( + configuration_parameter_value_id=pv.configuration_parameter_value_id, + configuration_parameter_value_name=pv.configuration_parameter_value.name) + for pv in instance.possible_values + ] + ) + + async def find_by_pk( self, request: Request, @@ -303,15 +368,7 @@ async def find_by_pk( request.state.session, pk ) - return read_schemas.CoverageConfigurationRead( - **db_cov_conf.model_dump(), - possible_values=[ - read_schemas.ConfigurationParameterPossibleValueRead( - configuration_parameter_value_id=pv.configuration_parameter_value_id, - configuration_parameter_value_name=pv.configuration_parameter_value.name) - for pv in db_cov_conf.possible_values - ] - ) + return self._serialize_instance(db_cov_conf) async def find_all( self, @@ -331,18 +388,7 @@ async def find_all( list_cov_confs, request.state.session) result = [] for db_cov_conf in db_cov_confs: - result.append( - read_schemas.CoverageConfigurationRead( - **db_cov_conf.model_dump(), - possible_values=[ - read_schemas.ConfigurationParameterPossibleValueRead( - configuration_parameter_value_id=pv.configuration_parameter_value.id, - configuration_parameter_value_name=pv.configuration_parameter_value.name, - ) - for pv in db_cov_conf.possible_values - ] - ) - ) + result.append(self._serialize_instance(db_cov_conf)) return result async def create(self, request: Request, data: Dict[str, Any]) -> Any: @@ -363,31 +409,25 @@ async def create(self, request: Request, data: Dict[str, Any]) -> Any: coverages.ConfigurationParameterPossibleValueCreate( configuration_parameter_value_id=conf_param_value.id) ) + related_obs_variable = database.get_variable_by_name( + session, data["observation_variable"]) cov_conf_create = coverages.CoverageConfigurationCreate( name=data["name"], + netcdf_main_dataset_name=data["netcdf_main_dataset_name"], thredds_url_pattern=data["thredds_url_pattern"], unit=data["unit"], palette=data["palette"], color_scale_min=data["color_scale_min"], color_scale_max=data["color_scale_max"], - possible_values=possible_values_create + possible_values=possible_values_create, + observation_variable_id=( + related_obs_variable.id if related_obs_variable else None), + observation_variable_aggregation_type=data.get( + "observation_variable_aggregation_type"), ) db_cov_conf = database.create_coverage_configuration( session, cov_conf_create) - - coverage_configuration_read = read_schemas.CoverageConfigurationRead( - **db_cov_conf.model_dump( - exclude={"possible_values"} - ), - possible_values=[ - read_schemas.ConfigurationParameterPossibleValueRead( - configuration_parameter_value_id=pv.configuration_parameter_value_id, - configuration_parameter_value_name=pv.configuration_parameter_value.name - ) - for pv in db_cov_conf.possible_values - ] - ) - return coverage_configuration_read + return self._serialize_instance(db_cov_conf) except Exception as e: return self.handle_exception(e) @@ -406,14 +446,21 @@ async def edit(self, request: Request, pk: Any, data: Dict[str, Any]) -> Any: coverages.ConfigurationParameterPossibleValueUpdate( configuration_parameter_value_id=conf_param_value.id) ) + related_obs_variable = database.get_variable_by_name( + session, data["observation_variable"]) cov_conv_update = coverages.CoverageConfigurationUpdate( name=data.get("name"), + netcdf_main_dataset_name=data.get("netcdf_main_dataset_name"), thredds_url_pattern=data.get("thredds_url_pattern"), unit=data.get("data"), palette=data.get("palette"), color_scale_min=data.get("color_scale_min"), color_scale_max=data.get("color_scale_max"), - possible_values=possible_values + possible_values=possible_values, + observation_variable_id=( + related_obs_variable.id if related_obs_variable else None), + observation_variable_aggregation_type=data.get( + "observation_variable_aggregation_type"), ) db_coverage_configuration = await anyio.to_thread.run_sync( database.get_coverage_configuration, @@ -426,18 +473,6 @@ async def edit(self, request: Request, pk: Any, data: Dict[str, Any]) -> Any: db_coverage_configuration, cov_conv_update ) - cov_conf_read = read_schemas.CoverageConfigurationRead( - **db_coverage_configuration.model_dump( - exclude={"possible_values"} - ), - possible_values=[ - read_schemas.ConfigurationParameterPossibleValueRead( - configuration_parameter_value_id=pv.configuration_parameter_value_id, - configuration_parameter_value_name=pv.configuration_parameter_value.name - ) - for pv in db_coverage_configuration.possible_values - ] - ) - return cov_conf_read + return self._serialize_instance(db_coverage_configuration) except Exception as e: self.handle_exception(e) diff --git a/arpav_ppcv/webapp/api_v2/routers/coverages.py b/arpav_ppcv/webapp/api_v2/routers/coverages.py index 2cb52cb1..23f2235b 100644 --- a/arpav_ppcv/webapp/api_v2/routers/coverages.py +++ b/arpav_ppcv/webapp/api_v2/routers/coverages.py @@ -4,6 +4,7 @@ import httpx import pydantic +import shapely.io from fastapi import ( APIRouter, Depends, @@ -14,11 +15,16 @@ ) from sqlmodel import Session -from .... import database +from .... import ( + database, + operations, +) from ....config import ArpavPpcvSettings from ....thredds import utils as thredds_utils +from ....schemas import coverages as base_coverages +from ....schemas import observations as base_observations from ... import dependencies -from ..schemas import coverages +from ..schemas import coverages as coverage_schemas logger = logging.getLogger(__name__) @@ -27,7 +33,7 @@ @router.get( "/coverage-configurations", - response_model=coverages.CoverageConfigurationList + response_model=coverage_schemas.CoverageConfigurationList ) async def list_coverage_configurations( request: Request, @@ -78,7 +84,7 @@ async def list_coverage_configurations( _, unfiltered_total = database.list_coverage_configurations( db_session, limit=1, offset=0, include_total=True ) - return coverages.CoverageConfigurationList.from_items( + return coverage_schemas.CoverageConfigurationList.from_items( coverage_configurations, request, limit=list_params.limit, @@ -90,7 +96,7 @@ async def list_coverage_configurations( @router.get( "/coverage-configurations/{coverage_configuration_id}", - response_model=coverages.CoverageConfigurationReadDetail, + response_model=coverage_schemas.CoverageConfigurationReadDetail, ) def get_coverage_configuration( request: Request, @@ -101,7 +107,7 @@ def get_coverage_configuration( db_session, coverage_configuration_id) allowed_coverage_identifiers = database.list_allowed_coverage_identifiers( db_session, coverage_configuration_id=db_coverage_configuration.id) - return coverages.CoverageConfigurationReadDetail.from_db_instance( + return coverage_schemas.CoverageConfigurationReadDetail.from_db_instance( db_coverage_configuration, allowed_coverage_identifiers, request) @@ -185,4 +191,78 @@ async def wms_endpoint( ) return response else: - raise HTTPException(status_code=400, detail="Invalid coverage_identifier") \ No newline at end of file + raise HTTPException(status_code=400, detail="Invalid coverage_identifier") + + +@router.get( + "/time-series/{coverage_identifier}", response_model=coverage_schemas.TimeSeries) +def get_time_series( + db_session: Annotated[Session, Depends(dependencies.get_db_session)], + settings: Annotated[ArpavPpcvSettings, Depends(dependencies.get_settings)], + http_client: Annotated[httpx.Client, Depends(dependencies.get_sync_http_client)], + coverage_identifier: str, + coords: str, + datetime: str, + include_coverage_data: bool = True, + include_observation_data: bool = False, + coverage_data_smoothing: bool = True, + observation_data_smoothing: bool = True, + include_coverage_uncertainty: bool = False, + include_coverage_related_data: bool = False, +): + coverage_configuration_name = coverage_identifier.partition("-")[0] + db_coverage_configuration = database.get_coverage_configuration_by_name( + db_session, coverage_configuration_name) + if db_coverage_configuration is not None: + cov_smoothing = ( + base_coverages.CoverageDataSmoothingStrategy.MOVING_AVERAGE_11_YEARS_PLUS_LOESS_SMOOTHING + if coverage_data_smoothing else None + ) + obs_smoothing = ( + base_observations.ObservationDataSmoothingStrategy.MOVING_AVERAGE_5_YEARS + if observation_data_smoothing else None + ) + geom = shapely.io.from_wkt(coords) + if geom.geom_type == "MultiPoint": + logger.warning( + f"Expected coords parameter to be a WKT Point but " + f"got {geom.geom_type!r} instead - Using the first point" + ) + point_geom = geom.geoms[0] + elif geom.geom_type == "Point": + point_geom = geom + else: + logger.warning( + f"Expected coords parameter to be a WKT Point but " + f"got {geom.geom_type!r} instead - Using the centroid instead" + ) + point_geom = geom.centroid + time_series = operations.get_coverage_time_series( + settings, + db_session, + http_client, + coverage_configuration=db_coverage_configuration, + coverage_identifier=coverage_identifier, + point_geom=point_geom, + temporal_range=datetime, + include_coverage_data=include_coverage_data, + include_observation_data=include_observation_data, + coverage_data_smoothing=cov_smoothing, + observation_data_smoothing=obs_smoothing, + include_coverage_uncertainty=include_coverage_uncertainty, + include_coverage_related_data=include_coverage_related_data, + ) + measurements = [] + for name, df in time_series.items(): + serialized_time_series = df.to_dict()[db_coverage_configuration.netcdf_main_dataset_name] + for timestamp, value in serialized_time_series.items(): + measurement = coverage_schemas.TimeSeriesItem( + value=value, + series=name, + datetime=timestamp, + ) + measurements.append(measurement) + return coverage_schemas.TimeSeries(values=measurements) + else: + raise HTTPException(status_code=400, detail="Invalid coverage_identifier") + diff --git a/arpav_ppcv/webapp/api_v2/schemas/coverages.py b/arpav_ppcv/webapp/api_v2/schemas/coverages.py index 47a82f7a..908d4e70 100644 --- a/arpav_ppcv/webapp/api_v2/schemas/coverages.py +++ b/arpav_ppcv/webapp/api_v2/schemas/coverages.py @@ -1,3 +1,4 @@ +import datetime as dt import uuid import pydantic @@ -92,3 +93,13 @@ class CoverageIdentifierList(WebResourceList): class ForecastModelScenarioList(WebResourceList): items: list[ForecastModelScenario] + + +class TimeSeriesItem(pydantic.BaseModel): + value: float + series: str + datetime: dt.datetime + + +class TimeSeries(pydantic.BaseModel): + values: list[TimeSeriesItem] diff --git a/arpav_ppcv/webapp/dependencies.py b/arpav_ppcv/webapp/dependencies.py index 5f9c1f69..161cf330 100644 --- a/arpav_ppcv/webapp/dependencies.py +++ b/arpav_ppcv/webapp/dependencies.py @@ -33,6 +33,10 @@ def get_http_client() -> httpx.AsyncClient: return httpx.AsyncClient() +def get_sync_http_client() -> httpx.Client: + return httpx.Client() + + class CommonListFilterParameters(pydantic.BaseModel): # noqa: D101 offset: Annotated[int, pydantic.Field(ge=0)] = 0 limit: Annotated[int, pydantic.Field(ge=0, le=100)] = 20 diff --git a/docker/compose.dev.yaml b/docker/compose.dev.yaml index a8261129..3319650c 100644 --- a/docker/compose.dev.yaml +++ b/docker/compose.dev.yaml @@ -50,20 +50,20 @@ services: volumes: *common-volumes - # jupyter: - # image: *webapp-image - # environment: - # *common-env - # ports: - # - target: 5001 - # published: 5001 - # volumes: - # *common-volumes - # entrypoint: ['/bin/bash', '-c'] - # command: - # - | - # poetry install --with jupyter - # poetry run jupyter + jupyter: + image: *webapp-image + environment: + *common-env + ports: + - target: 5002 + published: 5002 + volumes: + *common-volumes + entrypoint: ['/bin/bash', '-c'] + command: + - | + poetry install --with jupyter + poetry run jupyter lab --ip=0.0.0.0 --port=5002 --no-browser --LabApp.token= --LabApp.password= legacy-db: environment: diff --git a/poetry.lock b/poetry.lock index 2759727b..b3cc423b 100644 --- a/poetry.lock +++ b/poetry.lock @@ -19,6 +19,21 @@ typing-extensions = ">=4" [package.extras] tz = ["backports.zoneinfo"] +[[package]] +name = "alembic-postgresql-enum" +version = "1.2.0" +description = "Alembic autogenerate support for creation, alteration and deletion of enums" +optional = false +python-versions = "<4.0,>=3.7" +files = [ + {file = "alembic_postgresql_enum-1.2.0-py3-none-any.whl", hash = "sha256:bd156e882a10c680fc88ebad25cfe78ccf9f826dec89670f8aeb28e5359e502b"}, + {file = "alembic_postgresql_enum-1.2.0.tar.gz", hash = "sha256:971bd3a4c35ea38869bb5e263ea79e5b4a9c4a02f174a3dd7ddcb29d41260cba"}, +] + +[package.dependencies] +alembic = ">=1.7" +SQLAlchemy = ">=1.4" + [[package]] name = "amqp" version = "2.6.1" @@ -66,6 +81,93 @@ doc = ["Sphinx (>=7)", "packaging", "sphinx-autodoc-typehints (>=1.2.0)", "sphin test = ["anyio[trio]", "coverage[toml] (>=7)", "exceptiongroup (>=1.2.0)", "hypothesis (>=4.0)", "psutil (>=5.9)", "pytest (>=7.0)", "pytest-mock (>=3.6.1)", "trustme", "uvloop (>=0.17)"] trio = ["trio (>=0.23)"] +[[package]] +name = "appnope" +version = "0.1.4" +description = "Disable App Nap on macOS >= 10.9" +optional = false +python-versions = ">=3.6" +files = [ + {file = "appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c"}, + {file = "appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee"}, +] + +[[package]] +name = "argon2-cffi" +version = "23.1.0" +description = "Argon2 for Python" +optional = false +python-versions = ">=3.7" +files = [ + {file = "argon2_cffi-23.1.0-py3-none-any.whl", hash = "sha256:c670642b78ba29641818ab2e68bd4e6a78ba53b7eff7b4c3815ae16abf91c7ea"}, + {file = "argon2_cffi-23.1.0.tar.gz", hash = "sha256:879c3e79a2729ce768ebb7d36d4609e3a78a4ca2ec3a9f12286ca057e3d0db08"}, +] + +[package.dependencies] +argon2-cffi-bindings = "*" + +[package.extras] +dev = ["argon2-cffi[tests,typing]", "tox (>4)"] +docs = ["furo", "myst-parser", "sphinx", "sphinx-copybutton", "sphinx-notfound-page"] +tests = ["hypothesis", "pytest"] +typing = ["mypy"] + +[[package]] +name = "argon2-cffi-bindings" +version = "21.2.0" +description = "Low-level CFFI bindings for Argon2" +optional = false +python-versions = ">=3.6" +files = [ + {file = "argon2-cffi-bindings-21.2.0.tar.gz", hash = "sha256:bb89ceffa6c791807d1305ceb77dbfacc5aa499891d2c55661c6459651fc39e3"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ccb949252cb2ab3a08c02024acb77cfb179492d5701c7cbdbfd776124d4d2367"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9524464572e12979364b7d600abf96181d3541da11e23ddf565a32e70bd4dc0d"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b746dba803a79238e925d9046a63aa26bf86ab2a2fe74ce6b009a1c3f5c8f2ae"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:58ed19212051f49a523abb1dbe954337dc82d947fb6e5a0da60f7c8471a8476c"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:bd46088725ef7f58b5a1ef7ca06647ebaf0eb4baff7d1d0d177c6cc8744abd86"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_i686.whl", hash = "sha256:8cd69c07dd875537a824deec19f978e0f2078fdda07fd5c42ac29668dda5f40f"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:f1152ac548bd5b8bcecfb0b0371f082037e47128653df2e8ba6e914d384f3c3e"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-win32.whl", hash = "sha256:603ca0aba86b1349b147cab91ae970c63118a0f30444d4bc80355937c950c082"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-win_amd64.whl", hash = "sha256:b2ef1c30440dbbcba7a5dc3e319408b59676e2e039e2ae11a8775ecf482b192f"}, + {file = "argon2_cffi_bindings-21.2.0-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:e415e3f62c8d124ee16018e491a009937f8cf7ebf5eb430ffc5de21b900dad93"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:3e385d1c39c520c08b53d63300c3ecc28622f076f4c2b0e6d7e796e9f6502194"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2c3e3cc67fdb7d82c4718f19b4e7a87123caf8a93fde7e23cf66ac0337d3cb3f"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6a22ad9800121b71099d0fb0a65323810a15f2e292f2ba450810a7316e128ee5"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f9f8b450ed0547e3d473fdc8612083fd08dd2120d6ac8f73828df9b7d45bb351"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:93f9bf70084f97245ba10ee36575f0c3f1e7d7724d67d8e5b08e61787c320ed7"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:3b9ef65804859d335dc6b31582cad2c5166f0c3e7975f324d9ffaa34ee7e6583"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4966ef5848d820776f5f562a7d45fdd70c2f330c961d0d745b784034bd9f48d"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:20ef543a89dee4db46a1a6e206cd015360e5a75822f76df533845c3cbaf72670"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ed2937d286e2ad0cc79a7087d3c272832865f779430e0cc2b4f3718d3159b0cb"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:5e00316dabdaea0b2dd82d141cc66889ced0cdcbfa599e8b471cf22c620c329a"}, +] + +[package.dependencies] +cffi = ">=1.0.1" + +[package.extras] +dev = ["cogapp", "pre-commit", "pytest", "wheel"] +tests = ["pytest"] + +[[package]] +name = "arrow" +version = "1.3.0" +description = "Better dates & times for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "arrow-1.3.0-py3-none-any.whl", hash = "sha256:c728b120ebc00eb84e01882a6f5e7927a53960aa990ce7dd2b10f39005a67f80"}, + {file = "arrow-1.3.0.tar.gz", hash = "sha256:d4540617648cb5f895730f1ad8c82a65f2dad0166f57b75f3ca54759c4d67a85"}, +] + +[package.dependencies] +python-dateutil = ">=2.7.0" +types-python-dateutil = ">=2.8.10" + +[package.extras] +doc = ["doc8", "sphinx (>=7.0.0)", "sphinx-autobuild", "sphinx-autodoc-typehints", "sphinx_rtd_theme (>=1.3.0)"] +test = ["dateparser (==1.*)", "pre-commit", "pytest", "pytest-cov", "pytest-mock", "pytz (==2021.1)", "simplejson (==3.*)"] + [[package]] name = "asgiref" version = "3.7.2" @@ -83,6 +185,38 @@ typing-extensions = {version = ">=4", markers = "python_version < \"3.11\""} [package.extras] tests = ["mypy (>=0.800)", "pytest", "pytest-asyncio"] +[[package]] +name = "asttokens" +version = "2.4.1" +description = "Annotate AST trees with source code positions" +optional = false +python-versions = "*" +files = [ + {file = "asttokens-2.4.1-py2.py3-none-any.whl", hash = "sha256:051ed49c3dcae8913ea7cd08e46a606dba30b79993209636c4875bc1d637bc24"}, + {file = "asttokens-2.4.1.tar.gz", hash = "sha256:b03869718ba9a6eb027e134bfdf69f38a236d681c83c160d510768af11254ba0"}, +] + +[package.dependencies] +six = ">=1.12.0" + +[package.extras] +astroid = ["astroid (>=1,<2)", "astroid (>=2,<4)"] +test = ["astroid (>=1,<2)", "astroid (>=2,<4)", "pytest"] + +[[package]] +name = "async-lru" +version = "2.0.4" +description = "Simple LRU cache for asyncio" +optional = false +python-versions = ">=3.8" +files = [ + {file = "async-lru-2.0.4.tar.gz", hash = "sha256:b8a59a5df60805ff63220b2a0c5b5393da5521b113cd5465a44eb037d81a5627"}, + {file = "async_lru-2.0.4-py3-none-any.whl", hash = "sha256:ff02944ce3c288c5be660c42dbcca0742b32c3b279d6dceda655190240b99224"}, +] + +[package.dependencies] +typing-extensions = {version = ">=4.0.0", markers = "python_version < \"3.11\""} + [[package]] name = "async-timeout" version = "4.0.3" @@ -159,6 +293,20 @@ six = "*" [package.extras] visualize = ["Twisted (>=16.1.1)", "graphviz (>0.5.1)"] +[[package]] +name = "babel" +version = "2.15.0" +description = "Internationalization utilities" +optional = false +python-versions = ">=3.8" +files = [ + {file = "Babel-2.15.0-py3-none-any.whl", hash = "sha256:08706bdad8d0a3413266ab61bd6c34d0c28d6e1e7badf40a2cebe67644e2e1fb"}, + {file = "babel-2.15.0.tar.gz", hash = "sha256:8daf0e265d05768bc6c7a314cf1321e9a123afc328cc635c18622a2f30a04413"}, +] + +[package.extras] +dev = ["freezegun (>=1.0,<2.0)", "pytest (>=6.0)", "pytest-cov"] + [[package]] name = "backoff" version = "2.2.1" @@ -220,6 +368,24 @@ files = [ {file = "billiard-3.6.4.0.tar.gz", hash = "sha256:299de5a8da28a783d51b197d496bef4f1595dd023a93a4f59dde1886ae905547"}, ] +[[package]] +name = "bleach" +version = "6.1.0" +description = "An easy safelist-based HTML-sanitizing tool." +optional = false +python-versions = ">=3.8" +files = [ + {file = "bleach-6.1.0-py3-none-any.whl", hash = "sha256:3225f354cfc436b9789c66c4ee030194bee0568fbf9cbdad3bc8b5c26c5f12b6"}, + {file = "bleach-6.1.0.tar.gz", hash = "sha256:0a31f1837963c41d46bbf1331b8778e1308ea0791db03cc4e7357b97cf42a8fe"}, +] + +[package.dependencies] +six = ">=1.9.0" +webencodings = "*" + +[package.extras] +css = ["tinycss2 (>=1.1.0,<1.3)"] + [[package]] name = "cattrs" version = "23.2.3" @@ -391,14 +557,102 @@ Django = ">=2.2" tests = ["async-generator (>=1.10,<2.0)", "async-timeout (>=3.0,<4.0)", "coverage (>=4.5,<5.0)", "pytest (>=4.4,<5.0)", "pytest-asyncio (>=0.10,<1.0)", "pytest-django (>=3.4,<4.0)"] [[package]] -name = "chardet" -version = "3.0.4" -description = "Universal encoding detector for Python 2 and 3" +name = "charset-normalizer" +version = "3.3.2" +description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." optional = false -python-versions = "*" +python-versions = ">=3.7.0" files = [ - {file = "chardet-3.0.4-py2.py3-none-any.whl", hash = "sha256:fc323ffcaeaed0e0a02bf4d117757b98aed530d9ed4531e3e15460124c106691"}, - {file = "chardet-3.0.4.tar.gz", hash = "sha256:84ab92ed1c4d4f16916e05906b6b75a6c0fb5db821cc65e70cbd64a3e2a5eaae"}, + {file = "charset-normalizer-3.3.2.tar.gz", hash = "sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:25baf083bf6f6b341f4121c2f3c548875ee6f5339300e08be3f2b2ba1721cdd3"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:06435b539f889b1f6f4ac1758871aae42dc3a8c0e24ac9e60c2384973ad73027"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9063e24fdb1e498ab71cb7419e24622516c4a04476b17a2dab57e8baa30d6e03"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6897af51655e3691ff853668779c7bad41579facacf5fd7253b0133308cf000d"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1d3193f4a680c64b4b6a9115943538edb896edc190f0b222e73761716519268e"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd70574b12bb8a4d2aaa0094515df2463cb429d8536cfb6c7ce983246983e5a6"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8465322196c8b4d7ab6d1e049e4c5cb460d0394da4a27d23cc242fbf0034b6b5"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a9a8e9031d613fd2009c182b69c7b2c1ef8239a0efb1df3f7c8da66d5dd3d537"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:beb58fe5cdb101e3a055192ac291b7a21e3b7ef4f67fa1d74e331a7f2124341c"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:e06ed3eb3218bc64786f7db41917d4e686cc4856944f53d5bdf83a6884432e12"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:2e81c7b9c8979ce92ed306c249d46894776a909505d8f5a4ba55b14206e3222f"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:572c3763a264ba47b3cf708a44ce965d98555f618ca42c926a9c1616d8f34269"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fd1abc0d89e30cc4e02e4064dc67fcc51bd941eb395c502aac3ec19fab46b519"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-win32.whl", hash = "sha256:3d47fa203a7bd9c5b6cee4736ee84ca03b8ef23193c0d1ca99b5089f72645c73"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:10955842570876604d404661fbccbc9c7e684caf432c09c715ec38fbae45ae09"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:802fe99cca7457642125a8a88a084cef28ff0cf9407060f7b93dca5aa25480db"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:573f6eac48f4769d667c4442081b1794f52919e7edada77495aaed9236d13a96"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:549a3a73da901d5bc3ce8d24e0600d1fa85524c10287f6004fbab87672bf3e1e"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f27273b60488abe721a075bcca6d7f3964f9f6f067c8c4c605743023d7d3944f"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ceae2f17a9c33cb48e3263960dc5fc8005351ee19db217e9b1bb15d28c02574"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:65f6f63034100ead094b8744b3b97965785388f308a64cf8d7c34f2f2e5be0c4"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:753f10e867343b4511128c6ed8c82f7bec3bd026875576dfd88483c5c73b2fd8"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4a78b2b446bd7c934f5dcedc588903fb2f5eec172f3d29e52a9096a43722adfc"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e537484df0d8f426ce2afb2d0f8e1c3d0b114b83f8850e5f2fbea0e797bd82ae"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:eb6904c354526e758fda7167b33005998fb68c46fbc10e013ca97f21ca5c8887"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:deb6be0ac38ece9ba87dea880e438f25ca3eddfac8b002a2ec3d9183a454e8ae"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:4ab2fe47fae9e0f9dee8c04187ce5d09f48eabe611be8259444906793ab7cbce"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:80402cd6ee291dcb72644d6eac93785fe2c8b9cb30893c1af5b8fdd753b9d40f"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-win32.whl", hash = "sha256:7cd13a2e3ddeed6913a65e66e94b51d80a041145a026c27e6bb76c31a853c6ab"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:663946639d296df6a2bb2aa51b60a2454ca1cb29835324c640dafb5ff2131a77"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:0b2b64d2bb6d3fb9112bafa732def486049e63de9618b5843bcdd081d8144cd8"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:ddbb2551d7e0102e7252db79ba445cdab71b26640817ab1e3e3648dad515003b"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:55086ee1064215781fff39a1af09518bc9255b50d6333f2e4c74ca09fac6a8f6"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f4a014bc36d3c57402e2977dada34f9c12300af536839dc38c0beab8878f38a"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a10af20b82360ab00827f916a6058451b723b4e65030c5a18577c8b2de5b3389"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8d756e44e94489e49571086ef83b2bb8ce311e730092d2c34ca8f7d925cb20aa"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90d558489962fd4918143277a773316e56c72da56ec7aa3dc3dbbe20fdfed15b"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ac7ffc7ad6d040517be39eb591cac5ff87416c2537df6ba3cba3bae290c0fed"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:7ed9e526742851e8d5cc9e6cf41427dfc6068d4f5a3bb03659444b4cabf6bc26"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:8bdb58ff7ba23002a4c5808d608e4e6c687175724f54a5dade5fa8c67b604e4d"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:6b3251890fff30ee142c44144871185dbe13b11bab478a88887a639655be1068"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:b4a23f61ce87adf89be746c8a8974fe1c823c891d8f86eb218bb957c924bb143"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:efcb3f6676480691518c177e3b465bcddf57cea040302f9f4e6e191af91174d4"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-win32.whl", hash = "sha256:d965bba47ddeec8cd560687584e88cf699fd28f192ceb452d1d7ee807c5597b7"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:96b02a3dc4381e5494fad39be677abcb5e6634bf7b4fa83a6dd3112607547001"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:95f2a5796329323b8f0512e09dbb7a1860c46a39da62ecb2324f116fa8fdc85c"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c002b4ffc0be611f0d9da932eb0f704fe2602a9a949d1f738e4c34c75b0863d5"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a981a536974bbc7a512cf44ed14938cf01030a99e9b3a06dd59578882f06f985"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3287761bc4ee9e33561a7e058c72ac0938c4f57fe49a09eae428fd88aafe7bb6"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:42cb296636fcc8b0644486d15c12376cb9fa75443e00fb25de0b8602e64c1714"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0a55554a2fa0d408816b3b5cedf0045f4b8e1a6065aec45849de2d6f3f8e9786"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:c083af607d2515612056a31f0a8d9e0fcb5876b7bfc0abad3ecd275bc4ebc2d5"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:87d1351268731db79e0f8e745d92493ee2841c974128ef629dc518b937d9194c"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:bd8f7df7d12c2db9fab40bdd87a7c09b1530128315d047a086fa3ae3435cb3a8"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:c180f51afb394e165eafe4ac2936a14bee3eb10debc9d9e4db8958fe36afe711"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:8c622a5fe39a48f78944a87d4fb8a53ee07344641b0562c540d840748571b811"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-win32.whl", hash = "sha256:db364eca23f876da6f9e16c9da0df51aa4f104a972735574842618b8c6d999d4"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-win_amd64.whl", hash = "sha256:86216b5cee4b06df986d214f664305142d9c76df9b6512be2738aa72a2048f99"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:6463effa3186ea09411d50efc7d85360b38d5f09b870c48e4600f63af490e56a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6c4caeef8fa63d06bd437cd4bdcf3ffefe6738fb1b25951440d80dc7df8c03ac"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:37e55c8e51c236f95b033f6fb391d7d7970ba5fe7ff453dad675e88cf303377a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb69256e180cb6c8a894fee62b3afebae785babc1ee98b81cdf68bbca1987f33"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ae5f4161f18c61806f411a13b0310bea87f987c7d2ecdbdaad0e94eb2e404238"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b2b0a0c0517616b6869869f8c581d4eb2dd83a4d79e0ebcb7d373ef9956aeb0a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:45485e01ff4d3630ec0d9617310448a8702f70e9c01906b0d0118bdf9d124cf2"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eb00ed941194665c332bf8e078baf037d6c35d7c4f3102ea2d4f16ca94a26dc8"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:2127566c664442652f024c837091890cb1942c30937add288223dc895793f898"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:a50aebfa173e157099939b17f18600f72f84eed3049e743b68ad15bd69b6bf99"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:4d0d1650369165a14e14e1e47b372cfcb31d6ab44e6e33cb2d4e57265290044d"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:923c0c831b7cfcb071580d3f46c4baf50f174be571576556269530f4bbd79d04"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:06a81e93cd441c56a9b65d8e1d043daeb97a3d0856d177d5c90ba85acb3db087"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-win32.whl", hash = "sha256:6ef1d82a3af9d3eecdba2321dc1b3c238245d890843e040e41e470ffa64c3e25"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-win_amd64.whl", hash = "sha256:eb8821e09e916165e160797a6c17edda0679379a4be5c716c260e836e122f54b"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c235ebd9baae02f1b77bcea61bce332cb4331dc3617d254df3323aa01ab47bd4"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5b4c145409bef602a690e7cfad0a15a55c13320ff7a3ad7ca59c13bb8ba4d45d"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:68d1f8a9e9e37c1223b656399be5d6b448dea850bed7d0f87a8311f1ff3dabb0"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22afcb9f253dac0696b5a4be4a1c0f8762f8239e21b99680099abd9b2b1b2269"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e27ad930a842b4c5eb8ac0016b0a54f5aebbe679340c26101df33424142c143c"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1f79682fbe303db92bc2b1136016a38a42e835d932bab5b3b1bfcfbf0640e519"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b261ccdec7821281dade748d088bb6e9b69e6d15b30652b74cbbac25e280b796"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:122c7fa62b130ed55f8f285bfd56d5f4b4a5b503609d181f9ad85e55c89f4185"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:d0eccceffcb53201b5bfebb52600a5fb483a20b61da9dbc885f8b103cbe7598c"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:9f96df6923e21816da7e0ad3fd47dd8f94b2a5ce594e00677c0013018b813458"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:7f04c839ed0b6b98b1a7501a002144b76c18fb1c1850c8b98d458ac269e26ed2"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:34d1c8da1e78d2e001f363791c98a272bb734000fcef47a491c1e3b0505657a8"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ff8fa367d09b717b2a17a052544193ad76cd49979c805768879cb63d9ca50561"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-win32.whl", hash = "sha256:aed38f6e4fb3f5d6bf81bfa990a07806be9d83cf7bacef998ab1a9bd660a581f"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-win_amd64.whl", hash = "sha256:b01b88d45a6fcb69667cd6d2f7a9aeb4bf53760d7fc536bf679ec94fe9f3ff3d"}, + {file = "charset_normalizer-3.3.2-py3-none-any.whl", hash = "sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc"}, ] [[package]] @@ -426,6 +680,23 @@ files = [ {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, ] +[[package]] +name = "comm" +version = "0.2.2" +description = "Jupyter Python Comm implementation, for usage in ipykernel, xeus-python etc." +optional = false +python-versions = ">=3.8" +files = [ + {file = "comm-0.2.2-py3-none-any.whl", hash = "sha256:e6fb86cb70ff661ee8c9c14e7d36d6de3b4066f1441be4063df9c5009f0a64d3"}, + {file = "comm-0.2.2.tar.gz", hash = "sha256:3fd7a84065306e07bea1773df6eb8282de51ba82f77c72f9c85716ab11fe980e"}, +] + +[package.dependencies] +traitlets = ">=4" + +[package.extras] +test = ["pytest"] + [[package]] name = "constantly" version = "23.10.4" @@ -437,6 +708,69 @@ files = [ {file = "constantly-23.10.4.tar.gz", hash = "sha256:aa92b70a33e2ac0bb33cd745eb61776594dc48764b06c35e0efd050b7f1c7cbd"}, ] +[[package]] +name = "contourpy" +version = "1.2.1" +description = "Python library for calculating contours of 2D quadrilateral grids" +optional = false +python-versions = ">=3.9" +files = [ + {file = "contourpy-1.2.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bd7c23df857d488f418439686d3b10ae2fbf9bc256cd045b37a8c16575ea1040"}, + {file = "contourpy-1.2.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5b9eb0ca724a241683c9685a484da9d35c872fd42756574a7cfbf58af26677fd"}, + {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4c75507d0a55378240f781599c30e7776674dbaf883a46d1c90f37e563453480"}, + {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:11959f0ce4a6f7b76ec578576a0b61a28bdc0696194b6347ba3f1c53827178b9"}, + {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eb3315a8a236ee19b6df481fc5f997436e8ade24a9f03dfdc6bd490fea20c6da"}, + {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39f3ecaf76cd98e802f094e0d4fbc6dc9c45a8d0c4d185f0f6c2234e14e5f75b"}, + {file = "contourpy-1.2.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:94b34f32646ca0414237168d68a9157cb3889f06b096612afdd296003fdd32fd"}, + {file = "contourpy-1.2.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:457499c79fa84593f22454bbd27670227874cd2ff5d6c84e60575c8b50a69619"}, + {file = "contourpy-1.2.1-cp310-cp310-win32.whl", hash = "sha256:ac58bdee53cbeba2ecad824fa8159493f0bf3b8ea4e93feb06c9a465d6c87da8"}, + {file = "contourpy-1.2.1-cp310-cp310-win_amd64.whl", hash = "sha256:9cffe0f850e89d7c0012a1fb8730f75edd4320a0a731ed0c183904fe6ecfc3a9"}, + {file = "contourpy-1.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6022cecf8f44e36af10bd9118ca71f371078b4c168b6e0fab43d4a889985dbb5"}, + {file = "contourpy-1.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ef5adb9a3b1d0c645ff694f9bca7702ec2c70f4d734f9922ea34de02294fdf72"}, + {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6150ffa5c767bc6332df27157d95442c379b7dce3a38dff89c0f39b63275696f"}, + {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4c863140fafc615c14a4bf4efd0f4425c02230eb8ef02784c9a156461e62c965"}, + {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:00e5388f71c1a0610e6fe56b5c44ab7ba14165cdd6d695429c5cd94021e390b2"}, + {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d4492d82b3bc7fbb7e3610747b159869468079fe149ec5c4d771fa1f614a14df"}, + {file = "contourpy-1.2.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:49e70d111fee47284d9dd867c9bb9a7058a3c617274900780c43e38d90fe1205"}, + {file = "contourpy-1.2.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:b59c0ffceff8d4d3996a45f2bb6f4c207f94684a96bf3d9728dbb77428dd8cb8"}, + {file = "contourpy-1.2.1-cp311-cp311-win32.whl", hash = "sha256:7b4182299f251060996af5249c286bae9361fa8c6a9cda5efc29fe8bfd6062ec"}, + {file = "contourpy-1.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2855c8b0b55958265e8b5888d6a615ba02883b225f2227461aa9127c578a4922"}, + {file = "contourpy-1.2.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:62828cada4a2b850dbef89c81f5a33741898b305db244904de418cc957ff05dc"}, + {file = "contourpy-1.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:309be79c0a354afff9ff7da4aaed7c3257e77edf6c1b448a779329431ee79d7e"}, + {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2e785e0f2ef0d567099b9ff92cbfb958d71c2d5b9259981cd9bee81bd194c9a4"}, + {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1cac0a8f71a041aa587410424ad46dfa6a11f6149ceb219ce7dd48f6b02b87a7"}, + {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:af3f4485884750dddd9c25cb7e3915d83c2db92488b38ccb77dd594eac84c4a0"}, + {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ce6889abac9a42afd07a562c2d6d4b2b7134f83f18571d859b25624a331c90b"}, + {file = "contourpy-1.2.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:a1eea9aecf761c661d096d39ed9026574de8adb2ae1c5bd7b33558af884fb2ce"}, + {file = "contourpy-1.2.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:187fa1d4c6acc06adb0fae5544c59898ad781409e61a926ac7e84b8f276dcef4"}, + {file = "contourpy-1.2.1-cp312-cp312-win32.whl", hash = "sha256:c2528d60e398c7c4c799d56f907664673a807635b857df18f7ae64d3e6ce2d9f"}, + {file = "contourpy-1.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:1a07fc092a4088ee952ddae19a2b2a85757b923217b7eed584fdf25f53a6e7ce"}, + {file = "contourpy-1.2.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bb6834cbd983b19f06908b45bfc2dad6ac9479ae04abe923a275b5f48f1a186b"}, + {file = "contourpy-1.2.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1d59e739ab0e3520e62a26c60707cc3ab0365d2f8fecea74bfe4de72dc56388f"}, + {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bd3db01f59fdcbce5b22afad19e390260d6d0222f35a1023d9adc5690a889364"}, + {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a12a813949e5066148712a0626895c26b2578874e4cc63160bb007e6df3436fe"}, + {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fe0ccca550bb8e5abc22f530ec0466136379c01321fd94f30a22231e8a48d985"}, + {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e1d59258c3c67c865435d8fbeb35f8c59b8bef3d6f46c1f29f6123556af28445"}, + {file = "contourpy-1.2.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:f32c38afb74bd98ce26de7cc74a67b40afb7b05aae7b42924ea990d51e4dac02"}, + {file = "contourpy-1.2.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:d31a63bc6e6d87f77d71e1abbd7387ab817a66733734883d1fc0021ed9bfa083"}, + {file = "contourpy-1.2.1-cp39-cp39-win32.whl", hash = "sha256:ddcb8581510311e13421b1f544403c16e901c4e8f09083c881fab2be80ee31ba"}, + {file = "contourpy-1.2.1-cp39-cp39-win_amd64.whl", hash = "sha256:10a37ae557aabf2509c79715cd20b62e4c7c28b8cd62dd7d99e5ed3ce28c3fd9"}, + {file = "contourpy-1.2.1-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a31f94983fecbac95e58388210427d68cd30fe8a36927980fab9c20062645609"}, + {file = "contourpy-1.2.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ef2b055471c0eb466033760a521efb9d8a32b99ab907fc8358481a1dd29e3bd3"}, + {file = "contourpy-1.2.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:b33d2bc4f69caedcd0a275329eb2198f560b325605810895627be5d4b876bf7f"}, + {file = "contourpy-1.2.1.tar.gz", hash = "sha256:4d8908b3bee1c889e547867ca4cdc54e5ab6be6d3e078556814a22457f49423c"}, +] + +[package.dependencies] +numpy = ">=1.20" + +[package.extras] +bokeh = ["bokeh", "selenium"] +docs = ["furo", "sphinx (>=7.2)", "sphinx-copybutton"] +mypy = ["contourpy[bokeh,docs]", "docutils-stubs", "mypy (==1.8.0)", "types-Pillow"] +test = ["Pillow", "contourpy[test-no-images]", "matplotlib"] +test-no-images = ["pytest", "pytest-cov", "pytest-xdist", "wurlitzer"] + [[package]] name = "coverage" version = "7.4.1" @@ -558,6 +892,21 @@ ssh = ["bcrypt (>=3.1.5)"] test = ["certifi", "pretend", "pytest (>=6.2.0)", "pytest-benchmark", "pytest-cov", "pytest-xdist"] test-randomorder = ["pytest-randomly"] +[[package]] +name = "cycler" +version = "0.12.1" +description = "Composable style cycles" +optional = false +python-versions = ">=3.8" +files = [ + {file = "cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30"}, + {file = "cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c"}, +] + +[package.extras] +docs = ["ipython", "matplotlib", "numpydoc", "sphinx"] +tests = ["pytest", "pytest-cov", "pytest-xdist"] + [[package]] name = "dagger-io" version = "0.9.10" @@ -598,6 +947,59 @@ twisted = {version = ">=18.7", extras = ["tls"]} [package.extras] tests = ["hypothesis (==4.23)", "pytest (>=3.10,<4.0)", "pytest-asyncio (>=0.8,<1.0)"] +[[package]] +name = "debugpy" +version = "1.8.1" +description = "An implementation of the Debug Adapter Protocol for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "debugpy-1.8.1-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:3bda0f1e943d386cc7a0e71bfa59f4137909e2ed947fb3946c506e113000f741"}, + {file = "debugpy-1.8.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dda73bf69ea479c8577a0448f8c707691152e6c4de7f0c4dec5a4bc11dee516e"}, + {file = "debugpy-1.8.1-cp310-cp310-win32.whl", hash = "sha256:3a79c6f62adef994b2dbe9fc2cc9cc3864a23575b6e387339ab739873bea53d0"}, + {file = "debugpy-1.8.1-cp310-cp310-win_amd64.whl", hash = "sha256:7eb7bd2b56ea3bedb009616d9e2f64aab8fc7000d481faec3cd26c98a964bcdd"}, + {file = "debugpy-1.8.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:016a9fcfc2c6b57f939673c874310d8581d51a0fe0858e7fac4e240c5eb743cb"}, + {file = "debugpy-1.8.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd97ed11a4c7f6d042d320ce03d83b20c3fb40da892f994bc041bbc415d7a099"}, + {file = "debugpy-1.8.1-cp311-cp311-win32.whl", hash = "sha256:0de56aba8249c28a300bdb0672a9b94785074eb82eb672db66c8144fff673146"}, + {file = "debugpy-1.8.1-cp311-cp311-win_amd64.whl", hash = "sha256:1a9fe0829c2b854757b4fd0a338d93bc17249a3bf69ecf765c61d4c522bb92a8"}, + {file = "debugpy-1.8.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:3ebb70ba1a6524d19fa7bb122f44b74170c447d5746a503e36adc244a20ac539"}, + {file = "debugpy-1.8.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a2e658a9630f27534e63922ebf655a6ab60c370f4d2fc5c02a5b19baf4410ace"}, + {file = "debugpy-1.8.1-cp312-cp312-win32.whl", hash = "sha256:caad2846e21188797a1f17fc09c31b84c7c3c23baf2516fed5b40b378515bbf0"}, + {file = "debugpy-1.8.1-cp312-cp312-win_amd64.whl", hash = "sha256:edcc9f58ec0fd121a25bc950d4578df47428d72e1a0d66c07403b04eb93bcf98"}, + {file = "debugpy-1.8.1-cp38-cp38-macosx_11_0_x86_64.whl", hash = "sha256:7a3afa222f6fd3d9dfecd52729bc2e12c93e22a7491405a0ecbf9e1d32d45b39"}, + {file = "debugpy-1.8.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d915a18f0597ef685e88bb35e5d7ab968964b7befefe1aaea1eb5b2640b586c7"}, + {file = "debugpy-1.8.1-cp38-cp38-win32.whl", hash = "sha256:92116039b5500633cc8d44ecc187abe2dfa9b90f7a82bbf81d079fcdd506bae9"}, + {file = "debugpy-1.8.1-cp38-cp38-win_amd64.whl", hash = "sha256:e38beb7992b5afd9d5244e96ad5fa9135e94993b0c551ceebf3fe1a5d9beb234"}, + {file = "debugpy-1.8.1-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:bfb20cb57486c8e4793d41996652e5a6a885b4d9175dd369045dad59eaacea42"}, + {file = "debugpy-1.8.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efd3fdd3f67a7e576dd869c184c5dd71d9aaa36ded271939da352880c012e703"}, + {file = "debugpy-1.8.1-cp39-cp39-win32.whl", hash = "sha256:58911e8521ca0c785ac7a0539f1e77e0ce2df753f786188f382229278b4cdf23"}, + {file = "debugpy-1.8.1-cp39-cp39-win_amd64.whl", hash = "sha256:6df9aa9599eb05ca179fb0b810282255202a66835c6efb1d112d21ecb830ddd3"}, + {file = "debugpy-1.8.1-py2.py3-none-any.whl", hash = "sha256:28acbe2241222b87e255260c76741e1fbf04fdc3b6d094fcf57b6c6f75ce1242"}, + {file = "debugpy-1.8.1.zip", hash = "sha256:f696d6be15be87aef621917585f9bb94b1dc9e8aced570db1b8a6fc14e8f9b42"}, +] + +[[package]] +name = "decorator" +version = "5.1.1" +description = "Decorators for Humans" +optional = false +python-versions = ">=3.5" +files = [ + {file = "decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186"}, + {file = "decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330"}, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +description = "XML bomb protection for Python stdlib modules" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +files = [ + {file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"}, + {file = "defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"}, +] + [[package]] name = "django" version = "3.0.6" @@ -816,6 +1218,20 @@ files = [ [package.extras] test = ["pytest (>=6)"] +[[package]] +name = "executing" +version = "2.0.1" +description = "Get the currently executing AST node of a frame, and other information" +optional = false +python-versions = ">=3.5" +files = [ + {file = "executing-2.0.1-py2.py3-none-any.whl", hash = "sha256:eac49ca94516ccc753f9fb5ce82603156e590b27525a8bc32cce8ae302eb61bc"}, + {file = "executing-2.0.1.tar.gz", hash = "sha256:35afe2ce3affba8ee97f2d69927fa823b08b472b7b994e36a52a964b93d16147"}, +] + +[package.extras] +tests = ["asttokens (>=2.1.0)", "coverage", "coverage-enable-subprocess", "ipython", "littleutils", "pytest", "rich"] + [[package]] name = "fastapi" version = "0.110.0" @@ -835,6 +1251,96 @@ typing-extensions = ">=4.8.0" [package.extras] all = ["email-validator (>=2.0.0)", "httpx (>=0.23.0)", "itsdangerous (>=1.1.0)", "jinja2 (>=2.11.2)", "orjson (>=3.2.1)", "pydantic-extra-types (>=2.0.0)", "pydantic-settings (>=2.0.0)", "python-multipart (>=0.0.7)", "pyyaml (>=5.3.1)", "ujson (>=4.0.1,!=4.0.2,!=4.1.0,!=4.2.0,!=4.3.0,!=5.0.0,!=5.1.0)", "uvicorn[standard] (>=0.12.0)"] +[[package]] +name = "fastjsonschema" +version = "2.19.1" +description = "Fastest Python implementation of JSON schema" +optional = false +python-versions = "*" +files = [ + {file = "fastjsonschema-2.19.1-py3-none-any.whl", hash = "sha256:3672b47bc94178c9f23dbb654bf47440155d4db9df5f7bc47643315f9c405cd0"}, + {file = "fastjsonschema-2.19.1.tar.gz", hash = "sha256:e3126a94bdc4623d3de4485f8d468a12f02a67921315ddc87836d6e456dc789d"}, +] + +[package.extras] +devel = ["colorama", "json-spec", "jsonschema", "pylint", "pytest", "pytest-benchmark", "pytest-cache", "validictory"] + +[[package]] +name = "fonttools" +version = "4.51.0" +description = "Tools to manipulate font files" +optional = false +python-versions = ">=3.8" +files = [ + {file = "fonttools-4.51.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:84d7751f4468dd8cdd03ddada18b8b0857a5beec80bce9f435742abc9a851a74"}, + {file = "fonttools-4.51.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8b4850fa2ef2cfbc1d1f689bc159ef0f45d8d83298c1425838095bf53ef46308"}, + {file = "fonttools-4.51.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b5b48a1121117047d82695d276c2af2ee3a24ffe0f502ed581acc2673ecf1037"}, + {file = "fonttools-4.51.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:180194c7fe60c989bb627d7ed5011f2bef1c4d36ecf3ec64daec8302f1ae0716"}, + {file = "fonttools-4.51.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:96a48e137c36be55e68845fc4284533bda2980f8d6f835e26bca79d7e2006438"}, + {file = "fonttools-4.51.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:806e7912c32a657fa39d2d6eb1d3012d35f841387c8fc6cf349ed70b7c340039"}, + {file = "fonttools-4.51.0-cp310-cp310-win32.whl", hash = "sha256:32b17504696f605e9e960647c5f64b35704782a502cc26a37b800b4d69ff3c77"}, + {file = "fonttools-4.51.0-cp310-cp310-win_amd64.whl", hash = "sha256:c7e91abdfae1b5c9e3a543f48ce96013f9a08c6c9668f1e6be0beabf0a569c1b"}, + {file = "fonttools-4.51.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a8feca65bab31479d795b0d16c9a9852902e3a3c0630678efb0b2b7941ea9c74"}, + {file = "fonttools-4.51.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8ac27f436e8af7779f0bb4d5425aa3535270494d3bc5459ed27de3f03151e4c2"}, + {file = "fonttools-4.51.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0e19bd9e9964a09cd2433a4b100ca7f34e34731e0758e13ba9a1ed6e5468cc0f"}, + {file = "fonttools-4.51.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b2b92381f37b39ba2fc98c3a45a9d6383bfc9916a87d66ccb6553f7bdd129097"}, + {file = "fonttools-4.51.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:5f6bc991d1610f5c3bbe997b0233cbc234b8e82fa99fc0b2932dc1ca5e5afec0"}, + {file = "fonttools-4.51.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9696fe9f3f0c32e9a321d5268208a7cc9205a52f99b89479d1b035ed54c923f1"}, + {file = "fonttools-4.51.0-cp311-cp311-win32.whl", hash = "sha256:3bee3f3bd9fa1d5ee616ccfd13b27ca605c2b4270e45715bd2883e9504735034"}, + {file = "fonttools-4.51.0-cp311-cp311-win_amd64.whl", hash = "sha256:0f08c901d3866a8905363619e3741c33f0a83a680d92a9f0e575985c2634fcc1"}, + {file = "fonttools-4.51.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:4060acc2bfa2d8e98117828a238889f13b6f69d59f4f2d5857eece5277b829ba"}, + {file = "fonttools-4.51.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:1250e818b5f8a679ad79660855528120a8f0288f8f30ec88b83db51515411fcc"}, + {file = "fonttools-4.51.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76f1777d8b3386479ffb4a282e74318e730014d86ce60f016908d9801af9ca2a"}, + {file = "fonttools-4.51.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8b5ad456813d93b9c4b7ee55302208db2b45324315129d85275c01f5cb7e61a2"}, + {file = "fonttools-4.51.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:68b3fb7775a923be73e739f92f7e8a72725fd333eab24834041365d2278c3671"}, + {file = "fonttools-4.51.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8e2f1a4499e3b5ee82c19b5ee57f0294673125c65b0a1ff3764ea1f9db2f9ef5"}, + {file = "fonttools-4.51.0-cp312-cp312-win32.whl", hash = "sha256:278e50f6b003c6aed19bae2242b364e575bcb16304b53f2b64f6551b9c000e15"}, + {file = "fonttools-4.51.0-cp312-cp312-win_amd64.whl", hash = "sha256:b3c61423f22165541b9403ee39874dcae84cd57a9078b82e1dce8cb06b07fa2e"}, + {file = "fonttools-4.51.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:1621ee57da887c17312acc4b0e7ac30d3a4fb0fec6174b2e3754a74c26bbed1e"}, + {file = "fonttools-4.51.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:e9d9298be7a05bb4801f558522adbe2feea1b0b103d5294ebf24a92dd49b78e5"}, + {file = "fonttools-4.51.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ee1af4be1c5afe4c96ca23badd368d8dc75f611887fb0c0dac9f71ee5d6f110e"}, + {file = "fonttools-4.51.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c18b49adc721a7d0b8dfe7c3130c89b8704baf599fb396396d07d4aa69b824a1"}, + {file = "fonttools-4.51.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:de7c29bdbdd35811f14493ffd2534b88f0ce1b9065316433b22d63ca1cd21f14"}, + {file = "fonttools-4.51.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:cadf4e12a608ef1d13e039864f484c8a968840afa0258b0b843a0556497ea9ed"}, + {file = "fonttools-4.51.0-cp38-cp38-win32.whl", hash = "sha256:aefa011207ed36cd280babfaa8510b8176f1a77261833e895a9d96e57e44802f"}, + {file = "fonttools-4.51.0-cp38-cp38-win_amd64.whl", hash = "sha256:865a58b6e60b0938874af0968cd0553bcd88e0b2cb6e588727117bd099eef836"}, + {file = "fonttools-4.51.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:60a3409c9112aec02d5fb546f557bca6efa773dcb32ac147c6baf5f742e6258b"}, + {file = "fonttools-4.51.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f7e89853d8bea103c8e3514b9f9dc86b5b4120afb4583b57eb10dfa5afbe0936"}, + {file = "fonttools-4.51.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:56fc244f2585d6c00b9bcc59e6593e646cf095a96fe68d62cd4da53dd1287b55"}, + {file = "fonttools-4.51.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0d145976194a5242fdd22df18a1b451481a88071feadf251221af110ca8f00ce"}, + {file = "fonttools-4.51.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:c5b8cab0c137ca229433570151b5c1fc6af212680b58b15abd797dcdd9dd5051"}, + {file = "fonttools-4.51.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:54dcf21a2f2d06ded676e3c3f9f74b2bafded3a8ff12f0983160b13e9f2fb4a7"}, + {file = "fonttools-4.51.0-cp39-cp39-win32.whl", hash = "sha256:0118ef998a0699a96c7b28457f15546815015a2710a1b23a7bf6c1be60c01636"}, + {file = "fonttools-4.51.0-cp39-cp39-win_amd64.whl", hash = "sha256:599bdb75e220241cedc6faebfafedd7670335d2e29620d207dd0378a4e9ccc5a"}, + {file = "fonttools-4.51.0-py3-none-any.whl", hash = "sha256:15c94eeef6b095831067f72c825eb0e2d48bb4cea0647c1b05c981ecba2bf39f"}, + {file = "fonttools-4.51.0.tar.gz", hash = "sha256:dc0673361331566d7a663d7ce0f6fdcbfbdc1f59c6e3ed1165ad7202ca183c68"}, +] + +[package.extras] +all = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "fs (>=2.2.0,<3)", "lxml (>=4.0)", "lz4 (>=1.7.4.2)", "matplotlib", "munkres", "pycairo", "scipy", "skia-pathops (>=0.5.0)", "sympy", "uharfbuzz (>=0.23.0)", "unicodedata2 (>=15.1.0)", "xattr", "zopfli (>=0.1.4)"] +graphite = ["lz4 (>=1.7.4.2)"] +interpolatable = ["munkres", "pycairo", "scipy"] +lxml = ["lxml (>=4.0)"] +pathops = ["skia-pathops (>=0.5.0)"] +plot = ["matplotlib"] +repacker = ["uharfbuzz (>=0.23.0)"] +symfont = ["sympy"] +type1 = ["xattr"] +ufo = ["fs (>=2.2.0,<3)"] +unicode = ["unicodedata2 (>=15.1.0)"] +woff = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "zopfli (>=0.1.4)"] + +[[package]] +name = "fqdn" +version = "1.5.1" +description = "Validates fully-qualified domain names against RFC 1123, so that they are acceptable to modern bowsers" +optional = false +python-versions = ">=2.7, !=3.0, !=3.1, !=3.2, !=3.3, !=3.4, <4" +files = [ + {file = "fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014"}, + {file = "fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f"}, +] + [[package]] name = "geoalchemy2" version = "0.14.7" @@ -1138,6 +1644,146 @@ files = [ {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, ] +[[package]] +name = "ipykernel" +version = "6.29.4" +description = "IPython Kernel for Jupyter" +optional = false +python-versions = ">=3.8" +files = [ + {file = "ipykernel-6.29.4-py3-none-any.whl", hash = "sha256:1181e653d95c6808039c509ef8e67c4126b3b3af7781496c7cbfb5ed938a27da"}, + {file = "ipykernel-6.29.4.tar.gz", hash = "sha256:3d44070060f9475ac2092b760123fadf105d2e2493c24848b6691a7c4f42af5c"}, +] + +[package.dependencies] +appnope = {version = "*", markers = "platform_system == \"Darwin\""} +comm = ">=0.1.1" +debugpy = ">=1.6.5" +ipython = ">=7.23.1" +jupyter-client = ">=6.1.12" +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +matplotlib-inline = ">=0.1" +nest-asyncio = "*" +packaging = "*" +psutil = "*" +pyzmq = ">=24" +tornado = ">=6.1" +traitlets = ">=5.4.0" + +[package.extras] +cov = ["coverage[toml]", "curio", "matplotlib", "pytest-cov", "trio"] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "trio"] +pyqt5 = ["pyqt5"] +pyside6 = ["pyside6"] +test = ["flaky", "ipyparallel", "pre-commit", "pytest (>=7.0)", "pytest-asyncio (>=0.23.5)", "pytest-cov", "pytest-timeout"] + +[[package]] +name = "ipympl" +version = "0.9.4" +description = "Matplotlib Jupyter Extension" +optional = false +python-versions = ">=3.9" +files = [ + {file = "ipympl-0.9.4-py3-none-any.whl", hash = "sha256:5b0c08c6f4f6ea655ba58239363457c10fb921557f5038c1a46db4457d6d6b0e"}, + {file = "ipympl-0.9.4.tar.gz", hash = "sha256:cfb53c5b4fcbcee6d18f095eecfc6c6c474303d5b744e72cc66e7a2804708907"}, +] + +[package.dependencies] +ipython = "<9" +ipython-genutils = "*" +ipywidgets = ">=7.6.0,<9" +matplotlib = ">=3.4.0,<4" +numpy = "*" +pillow = "*" +traitlets = "<6" + +[package.extras] +docs = ["myst-nb", "sphinx (>=1.5)", "sphinx-book-theme", "sphinx-copybutton", "sphinx-thebe", "sphinx-togglebutton"] + +[[package]] +name = "ipython" +version = "8.24.0" +description = "IPython: Productive Interactive Computing" +optional = false +python-versions = ">=3.10" +files = [ + {file = "ipython-8.24.0-py3-none-any.whl", hash = "sha256:d7bf2f6c4314984e3e02393213bab8703cf163ede39672ce5918c51fe253a2a3"}, + {file = "ipython-8.24.0.tar.gz", hash = "sha256:010db3f8a728a578bb641fdd06c063b9fb8e96a9464c63aec6310fbcb5e80501"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "sys_platform == \"win32\""} +decorator = "*" +exceptiongroup = {version = "*", markers = "python_version < \"3.11\""} +jedi = ">=0.16" +matplotlib-inline = "*" +pexpect = {version = ">4.3", markers = "sys_platform != \"win32\" and sys_platform != \"emscripten\""} +prompt-toolkit = ">=3.0.41,<3.1.0" +pygments = ">=2.4.0" +stack-data = "*" +traitlets = ">=5.13.0" +typing-extensions = {version = ">=4.6", markers = "python_version < \"3.12\""} + +[package.extras] +all = ["ipython[black,doc,kernel,matplotlib,nbconvert,nbformat,notebook,parallel,qtconsole]", "ipython[test,test-extra]"] +black = ["black"] +doc = ["docrepr", "exceptiongroup", "ipykernel", "ipython[test]", "matplotlib", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "sphinxcontrib-jquery", "stack-data", "typing-extensions"] +kernel = ["ipykernel"] +matplotlib = ["matplotlib"] +nbconvert = ["nbconvert"] +nbformat = ["nbformat"] +notebook = ["ipywidgets", "notebook"] +parallel = ["ipyparallel"] +qtconsole = ["qtconsole"] +test = ["pickleshare", "pytest", "pytest-asyncio (<0.22)", "testpath"] +test-extra = ["curio", "ipython[test]", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.23)", "pandas", "trio"] + +[[package]] +name = "ipython-genutils" +version = "0.2.0" +description = "Vestigial utilities from IPython" +optional = false +python-versions = "*" +files = [ + {file = "ipython_genutils-0.2.0-py2.py3-none-any.whl", hash = "sha256:72dd37233799e619666c9f639a9da83c34013a73e8bbc79a7a6348d93c61fab8"}, + {file = "ipython_genutils-0.2.0.tar.gz", hash = "sha256:eb2e116e75ecef9d4d228fdc66af54269afa26ab4463042e33785b887c628ba8"}, +] + +[[package]] +name = "ipywidgets" +version = "8.1.2" +description = "Jupyter interactive widgets" +optional = false +python-versions = ">=3.7" +files = [ + {file = "ipywidgets-8.1.2-py3-none-any.whl", hash = "sha256:bbe43850d79fb5e906b14801d6c01402857996864d1e5b6fa62dd2ee35559f60"}, + {file = "ipywidgets-8.1.2.tar.gz", hash = "sha256:d0b9b41e49bae926a866e613a39b0f0097745d2b9f1f3dd406641b4a57ec42c9"}, +] + +[package.dependencies] +comm = ">=0.1.3" +ipython = ">=6.1.0" +jupyterlab-widgets = ">=3.0.10,<3.1.0" +traitlets = ">=4.3.1" +widgetsnbextension = ">=4.0.10,<4.1.0" + +[package.extras] +test = ["ipykernel", "jsonschema", "pytest (>=3.6.0)", "pytest-cov", "pytz"] + +[[package]] +name = "isoduration" +version = "20.11.0" +description = "Operations with ISO 8601 durations" +optional = false +python-versions = ">=3.7" +files = [ + {file = "isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042"}, + {file = "isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9"}, +] + +[package.dependencies] +arrow = ">=0.15.0" + [[package]] name = "itsdangerous" version = "2.2.0" @@ -1149,6 +1795,25 @@ files = [ {file = "itsdangerous-2.2.0.tar.gz", hash = "sha256:e0050c0b7da1eea53ffaf149c0cfbb5c6e2e2b69c4bef22c81fa6eb73e5f6173"}, ] +[[package]] +name = "jedi" +version = "0.19.1" +description = "An autocompletion tool for Python that can be used for text editors." +optional = false +python-versions = ">=3.6" +files = [ + {file = "jedi-0.19.1-py2.py3-none-any.whl", hash = "sha256:e983c654fe5c02867aef4cdfce5a2fbb4a50adc0af145f70504238f18ef5e7e0"}, + {file = "jedi-0.19.1.tar.gz", hash = "sha256:cf0496f3651bc65d7174ac1b7d043eff454892c708a87d1b683e57b569927ffd"}, +] + +[package.dependencies] +parso = ">=0.8.3,<0.9.0" + +[package.extras] +docs = ["Jinja2 (==2.11.3)", "MarkupSafe (==1.1.1)", "Pygments (==2.8.1)", "alabaster (==0.7.12)", "babel (==2.9.1)", "chardet (==4.0.0)", "commonmark (==0.8.1)", "docutils (==0.17.1)", "future (==0.18.2)", "idna (==2.10)", "imagesize (==1.2.0)", "mock (==1.0.1)", "packaging (==20.9)", "pyparsing (==2.4.7)", "pytz (==2021.1)", "readthedocs-sphinx-ext (==2.1.4)", "recommonmark (==0.5.0)", "requests (==2.25.1)", "six (==1.15.0)", "snowballstemmer (==2.1.0)", "sphinx (==1.8.5)", "sphinx-rtd-theme (==0.4.3)", "sphinxcontrib-serializinghtml (==1.1.4)", "sphinxcontrib-websupport (==1.2.4)", "urllib3 (==1.26.4)"] +qa = ["flake8 (==5.0.4)", "mypy (==0.971)", "types-setuptools (==67.2.0.1)"] +testing = ["Django", "attrs", "colorama", "docopt", "pytest (<7.0.0)"] + [[package]] name = "jinja2" version = "3.1.4" @@ -1166,6 +1831,400 @@ MarkupSafe = ">=2.0" [package.extras] i18n = ["Babel (>=2.7)"] +[[package]] +name = "json5" +version = "0.9.25" +description = "A Python implementation of the JSON5 data format." +optional = false +python-versions = ">=3.8" +files = [ + {file = "json5-0.9.25-py3-none-any.whl", hash = "sha256:34ed7d834b1341a86987ed52f3f76cd8ee184394906b6e22a1e0deb9ab294e8f"}, + {file = "json5-0.9.25.tar.gz", hash = "sha256:548e41b9be043f9426776f05df8635a00fe06104ea51ed24b67f908856e151ae"}, +] + +[[package]] +name = "jsonpointer" +version = "2.4" +description = "Identify specific nodes in a JSON document (RFC 6901)" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*" +files = [ + {file = "jsonpointer-2.4-py2.py3-none-any.whl", hash = "sha256:15d51bba20eea3165644553647711d150376234112651b4f1811022aecad7d7a"}, + {file = "jsonpointer-2.4.tar.gz", hash = "sha256:585cee82b70211fa9e6043b7bb89db6e1aa49524340dde8ad6b63206ea689d88"}, +] + +[[package]] +name = "jsonschema" +version = "4.22.0" +description = "An implementation of JSON Schema validation for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jsonschema-4.22.0-py3-none-any.whl", hash = "sha256:ff4cfd6b1367a40e7bc6411caec72effadd3db0bbe5017de188f2d6108335802"}, + {file = "jsonschema-4.22.0.tar.gz", hash = "sha256:5b22d434a45935119af990552c862e5d6d564e8f6601206b305a61fdf661a2b7"}, +] + +[package.dependencies] +attrs = ">=22.2.0" +fqdn = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +idna = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +isoduration = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +jsonpointer = {version = ">1.13", optional = true, markers = "extra == \"format-nongpl\""} +jsonschema-specifications = ">=2023.03.6" +referencing = ">=0.28.4" +rfc3339-validator = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +rfc3986-validator = {version = ">0.1.0", optional = true, markers = "extra == \"format-nongpl\""} +rpds-py = ">=0.7.1" +uri-template = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +webcolors = {version = ">=1.11", optional = true, markers = "extra == \"format-nongpl\""} + +[package.extras] +format = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3987", "uri-template", "webcolors (>=1.11)"] +format-nongpl = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3986-validator (>0.1.0)", "uri-template", "webcolors (>=1.11)"] + +[[package]] +name = "jsonschema-specifications" +version = "2023.12.1" +description = "The JSON Schema meta-schemas and vocabularies, exposed as a Registry" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jsonschema_specifications-2023.12.1-py3-none-any.whl", hash = "sha256:87e4fdf3a94858b8a2ba2778d9ba57d8a9cafca7c7489c46ba0d30a8bc6a9c3c"}, + {file = "jsonschema_specifications-2023.12.1.tar.gz", hash = "sha256:48a76787b3e70f5ed53f1160d2b81f586e4ca6d1548c5de7085d1682674764cc"}, +] + +[package.dependencies] +referencing = ">=0.31.0" + +[[package]] +name = "jupyter-client" +version = "8.6.1" +description = "Jupyter protocol implementation and client libraries" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_client-8.6.1-py3-none-any.whl", hash = "sha256:3b7bd22f058434e3b9a7ea4b1500ed47de2713872288c0d511d19926f99b459f"}, + {file = "jupyter_client-8.6.1.tar.gz", hash = "sha256:e842515e2bab8e19186d89fdfea7abd15e39dd581f94e399f00e2af5a1652d3f"}, +] + +[package.dependencies] +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +python-dateutil = ">=2.8.2" +pyzmq = ">=23.0" +tornado = ">=6.2" +traitlets = ">=5.3" + +[package.extras] +docs = ["ipykernel", "myst-parser", "pydata-sphinx-theme", "sphinx (>=4)", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"] +test = ["coverage", "ipykernel (>=6.14)", "mypy", "paramiko", "pre-commit", "pytest", "pytest-cov", "pytest-jupyter[client] (>=0.4.1)", "pytest-timeout"] + +[[package]] +name = "jupyter-core" +version = "5.7.2" +description = "Jupyter core package. A base package on which Jupyter projects rely." +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_core-5.7.2-py3-none-any.whl", hash = "sha256:4f7315d2f6b4bcf2e3e7cb6e46772eba760ae459cd1f59d29eb57b0a01bd7409"}, + {file = "jupyter_core-5.7.2.tar.gz", hash = "sha256:aa5f8d32bbf6b431ac830496da7392035d6f61b4f54872f15c4bd2a9c3f536d9"}, +] + +[package.dependencies] +platformdirs = ">=2.5" +pywin32 = {version = ">=300", markers = "sys_platform == \"win32\" and platform_python_implementation != \"PyPy\""} +traitlets = ">=5.3" + +[package.extras] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "traitlets"] +test = ["ipykernel", "pre-commit", "pytest (<8)", "pytest-cov", "pytest-timeout"] + +[[package]] +name = "jupyter-events" +version = "0.10.0" +description = "Jupyter Event System library" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_events-0.10.0-py3-none-any.whl", hash = "sha256:4b72130875e59d57716d327ea70d3ebc3af1944d3717e5a498b8a06c6c159960"}, + {file = "jupyter_events-0.10.0.tar.gz", hash = "sha256:670b8229d3cc882ec782144ed22e0d29e1c2d639263f92ca8383e66682845e22"}, +] + +[package.dependencies] +jsonschema = {version = ">=4.18.0", extras = ["format-nongpl"]} +python-json-logger = ">=2.0.4" +pyyaml = ">=5.3" +referencing = "*" +rfc3339-validator = "*" +rfc3986-validator = ">=0.1.1" +traitlets = ">=5.3" + +[package.extras] +cli = ["click", "rich"] +docs = ["jupyterlite-sphinx", "myst-parser", "pydata-sphinx-theme", "sphinxcontrib-spelling"] +test = ["click", "pre-commit", "pytest (>=7.0)", "pytest-asyncio (>=0.19.0)", "pytest-console-scripts", "rich"] + +[[package]] +name = "jupyter-lsp" +version = "2.2.5" +description = "Multi-Language Server WebSocket proxy for Jupyter Notebook/Lab server" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter-lsp-2.2.5.tar.gz", hash = "sha256:793147a05ad446f809fd53ef1cd19a9f5256fd0a2d6b7ce943a982cb4f545001"}, + {file = "jupyter_lsp-2.2.5-py3-none-any.whl", hash = "sha256:45fbddbd505f3fbfb0b6cb2f1bc5e15e83ab7c79cd6e89416b248cb3c00c11da"}, +] + +[package.dependencies] +jupyter-server = ">=1.1.2" + +[[package]] +name = "jupyter-server" +version = "2.14.0" +description = "The backend—i.e. core services, APIs, and REST endpoints—to Jupyter web applications." +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_server-2.14.0-py3-none-any.whl", hash = "sha256:fb6be52c713e80e004fac34b35a0990d6d36ba06fd0a2b2ed82b899143a64210"}, + {file = "jupyter_server-2.14.0.tar.gz", hash = "sha256:659154cea512083434fd7c93b7fe0897af7a2fd0b9dd4749282b42eaac4ae677"}, +] + +[package.dependencies] +anyio = ">=3.1.0" +argon2-cffi = ">=21.1" +jinja2 = ">=3.0.3" +jupyter-client = ">=7.4.4" +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +jupyter-events = ">=0.9.0" +jupyter-server-terminals = ">=0.4.4" +nbconvert = ">=6.4.4" +nbformat = ">=5.3.0" +overrides = ">=5.0" +packaging = ">=22.0" +prometheus-client = ">=0.9" +pywinpty = {version = ">=2.0.1", markers = "os_name == \"nt\""} +pyzmq = ">=24" +send2trash = ">=1.8.2" +terminado = ">=0.8.3" +tornado = ">=6.2.0" +traitlets = ">=5.6.0" +websocket-client = ">=1.7" + +[package.extras] +docs = ["ipykernel", "jinja2", "jupyter-client", "jupyter-server", "myst-parser", "nbformat", "prometheus-client", "pydata-sphinx-theme", "send2trash", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-openapi (>=0.8.0)", "sphinxcontrib-spelling", "sphinxemoji", "tornado", "typing-extensions"] +test = ["flaky", "ipykernel", "pre-commit", "pytest (>=7.0,<9)", "pytest-console-scripts", "pytest-jupyter[server] (>=0.7)", "pytest-timeout", "requests"] + +[[package]] +name = "jupyter-server-terminals" +version = "0.5.3" +description = "A Jupyter Server Extension Providing Terminals." +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_server_terminals-0.5.3-py3-none-any.whl", hash = "sha256:41ee0d7dc0ebf2809c668e0fc726dfaf258fcd3e769568996ca731b6194ae9aa"}, + {file = "jupyter_server_terminals-0.5.3.tar.gz", hash = "sha256:5ae0295167220e9ace0edcfdb212afd2b01ee8d179fe6f23c899590e9b8a5269"}, +] + +[package.dependencies] +pywinpty = {version = ">=2.0.3", markers = "os_name == \"nt\""} +terminado = ">=0.8.3" + +[package.extras] +docs = ["jinja2", "jupyter-server", "mistune (<4.0)", "myst-parser", "nbformat", "packaging", "pydata-sphinx-theme", "sphinxcontrib-github-alt", "sphinxcontrib-openapi", "sphinxcontrib-spelling", "sphinxemoji", "tornado"] +test = ["jupyter-server (>=2.0.0)", "pytest (>=7.0)", "pytest-jupyter[server] (>=0.5.3)", "pytest-timeout"] + +[[package]] +name = "jupyterlab" +version = "4.2.0" +description = "JupyterLab computational environment" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyterlab-4.2.0-py3-none-any.whl", hash = "sha256:0dfe9278e25a145362289c555d9beb505697d269c10e99909766af7c440ad3cc"}, + {file = "jupyterlab-4.2.0.tar.gz", hash = "sha256:356e9205a6a2ab689c47c8fe4919dba6c076e376d03f26baadc05748c2435dd5"}, +] + +[package.dependencies] +async-lru = ">=1.0.0" +httpx = ">=0.25.0" +ipykernel = ">=6.5.0" +jinja2 = ">=3.0.3" +jupyter-core = "*" +jupyter-lsp = ">=2.0.0" +jupyter-server = ">=2.4.0,<3" +jupyterlab-server = ">=2.27.1,<3" +notebook-shim = ">=0.2" +packaging = "*" +tomli = {version = ">=1.2.2", markers = "python_version < \"3.11\""} +tornado = ">=6.2.0" +traitlets = "*" + +[package.extras] +dev = ["build", "bump2version", "coverage", "hatch", "pre-commit", "pytest-cov", "ruff (==0.3.5)"] +docs = ["jsx-lexer", "myst-parser", "pydata-sphinx-theme (>=0.13.0)", "pytest", "pytest-check-links", "pytest-jupyter", "sphinx (>=1.8,<7.3.0)", "sphinx-copybutton"] +docs-screenshots = ["altair (==5.3.0)", "ipython (==8.16.1)", "ipywidgets (==8.1.2)", "jupyterlab-geojson (==3.4.0)", "jupyterlab-language-pack-zh-cn (==4.1.post2)", "matplotlib (==3.8.3)", "nbconvert (>=7.0.0)", "pandas (==2.2.1)", "scipy (==1.12.0)", "vega-datasets (==0.9.0)"] +test = ["coverage", "pytest (>=7.0)", "pytest-check-links (>=0.7)", "pytest-console-scripts", "pytest-cov", "pytest-jupyter (>=0.5.3)", "pytest-timeout", "pytest-tornasync", "requests", "requests-cache", "virtualenv"] +upgrade-extension = ["copier (>=8,<10)", "jinja2-time (<0.3)", "pydantic (<2.0)", "pyyaml-include (<2.0)", "tomli-w (<2.0)"] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +description = "Pygments theme using JupyterLab CSS variables" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780"}, + {file = "jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d"}, +] + +[[package]] +name = "jupyterlab-server" +version = "2.27.1" +description = "A set of server components for JupyterLab and JupyterLab like applications." +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyterlab_server-2.27.1-py3-none-any.whl", hash = "sha256:f5e26156e5258b24d532c84e7c74cc212e203bff93eb856f81c24c16daeecc75"}, + {file = "jupyterlab_server-2.27.1.tar.gz", hash = "sha256:097b5ac709b676c7284ac9c5e373f11930a561f52cd5a86e4fc7e5a9c8a8631d"}, +] + +[package.dependencies] +babel = ">=2.10" +jinja2 = ">=3.0.3" +json5 = ">=0.9.0" +jsonschema = ">=4.18.0" +jupyter-server = ">=1.21,<3" +packaging = ">=21.3" +requests = ">=2.31" + +[package.extras] +docs = ["autodoc-traits", "jinja2 (<3.2.0)", "mistune (<4)", "myst-parser", "pydata-sphinx-theme", "sphinx", "sphinx-copybutton", "sphinxcontrib-openapi (>0.8)"] +openapi = ["openapi-core (>=0.18.0,<0.19.0)", "ruamel-yaml"] +test = ["hatch", "ipykernel", "openapi-core (>=0.18.0,<0.19.0)", "openapi-spec-validator (>=0.6.0,<0.8.0)", "pytest (>=7.0,<8)", "pytest-console-scripts", "pytest-cov", "pytest-jupyter[server] (>=0.6.2)", "pytest-timeout", "requests-mock", "ruamel-yaml", "sphinxcontrib-spelling", "strict-rfc3339", "werkzeug"] + +[[package]] +name = "jupyterlab-widgets" +version = "3.0.10" +description = "Jupyter interactive widgets for JupyterLab" +optional = false +python-versions = ">=3.7" +files = [ + {file = "jupyterlab_widgets-3.0.10-py3-none-any.whl", hash = "sha256:dd61f3ae7a5a7f80299e14585ce6cf3d6925a96c9103c978eda293197730cb64"}, + {file = "jupyterlab_widgets-3.0.10.tar.gz", hash = "sha256:04f2ac04976727e4f9d0fa91cdc2f1ab860f965e504c29dbd6a65c882c9d04c0"}, +] + +[[package]] +name = "kiwisolver" +version = "1.4.5" +description = "A fast implementation of the Cassowary constraint solver" +optional = false +python-versions = ">=3.7" +files = [ + {file = "kiwisolver-1.4.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:05703cf211d585109fcd72207a31bb170a0f22144d68298dc5e61b3c946518af"}, + {file = "kiwisolver-1.4.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:146d14bebb7f1dc4d5fbf74f8a6cb15ac42baadee8912eb84ac0b3b2a3dc6ac3"}, + {file = "kiwisolver-1.4.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6ef7afcd2d281494c0a9101d5c571970708ad911d028137cd558f02b851c08b4"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:9eaa8b117dc8337728e834b9c6e2611f10c79e38f65157c4c38e9400286f5cb1"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ec20916e7b4cbfb1f12380e46486ec4bcbaa91a9c448b97023fde0d5bbf9e4ff"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:39b42c68602539407884cf70d6a480a469b93b81b7701378ba5e2328660c847a"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aa12042de0171fad672b6c59df69106d20d5596e4f87b5e8f76df757a7c399aa"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2a40773c71d7ccdd3798f6489aaac9eee213d566850a9533f8d26332d626b82c"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:19df6e621f6d8b4b9c4d45f40a66839294ff2bb235e64d2178f7522d9170ac5b"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:83d78376d0d4fd884e2c114d0621624b73d2aba4e2788182d286309ebdeed770"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:e391b1f0a8a5a10ab3b9bb6afcfd74f2175f24f8975fb87ecae700d1503cdee0"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:852542f9481f4a62dbb5dd99e8ab7aedfeb8fb6342349a181d4036877410f525"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:59edc41b24031bc25108e210c0def6f6c2191210492a972d585a06ff246bb79b"}, + {file = "kiwisolver-1.4.5-cp310-cp310-win32.whl", hash = "sha256:a6aa6315319a052b4ee378aa171959c898a6183f15c1e541821c5c59beaa0238"}, + {file = "kiwisolver-1.4.5-cp310-cp310-win_amd64.whl", hash = "sha256:d0ef46024e6a3d79c01ff13801cb19d0cad7fd859b15037aec74315540acc276"}, + {file = "kiwisolver-1.4.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:11863aa14a51fd6ec28688d76f1735f8f69ab1fabf388851a595d0721af042f5"}, + {file = "kiwisolver-1.4.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8ab3919a9997ab7ef2fbbed0cc99bb28d3c13e6d4b1ad36e97e482558a91be90"}, + {file = "kiwisolver-1.4.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fcc700eadbbccbf6bc1bcb9dbe0786b4b1cb91ca0dcda336eef5c2beed37b797"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dfdd7c0b105af050eb3d64997809dc21da247cf44e63dc73ff0fd20b96be55a9"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76c6a5964640638cdeaa0c359382e5703e9293030fe730018ca06bc2010c4437"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bbea0db94288e29afcc4c28afbf3a7ccaf2d7e027489c449cf7e8f83c6346eb9"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ceec1a6bc6cab1d6ff5d06592a91a692f90ec7505d6463a88a52cc0eb58545da"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:040c1aebeda72197ef477a906782b5ab0d387642e93bda547336b8957c61022e"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:f91de7223d4c7b793867797bacd1ee53bfe7359bd70d27b7b58a04efbb9436c8"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:faae4860798c31530dd184046a900e652c95513796ef51a12bc086710c2eec4d"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:b0157420efcb803e71d1b28e2c287518b8808b7cf1ab8af36718fd0a2c453eb0"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:06f54715b7737c2fecdbf140d1afb11a33d59508a47bf11bb38ecf21dc9ab79f"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fdb7adb641a0d13bdcd4ef48e062363d8a9ad4a182ac7647ec88f695e719ae9f"}, + {file = "kiwisolver-1.4.5-cp311-cp311-win32.whl", hash = "sha256:bb86433b1cfe686da83ce32a9d3a8dd308e85c76b60896d58f082136f10bffac"}, + {file = "kiwisolver-1.4.5-cp311-cp311-win_amd64.whl", hash = "sha256:6c08e1312a9cf1074d17b17728d3dfce2a5125b2d791527f33ffbe805200a355"}, + {file = "kiwisolver-1.4.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:32d5cf40c4f7c7b3ca500f8985eb3fb3a7dfc023215e876f207956b5ea26632a"}, + {file = "kiwisolver-1.4.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f846c260f483d1fd217fe5ed7c173fb109efa6b1fc8381c8b7552c5781756192"}, + {file = "kiwisolver-1.4.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5ff5cf3571589b6d13bfbfd6bcd7a3f659e42f96b5fd1c4830c4cf21d4f5ef45"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7269d9e5f1084a653d575c7ec012ff57f0c042258bf5db0954bf551c158466e7"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da802a19d6e15dffe4b0c24b38b3af68e6c1a68e6e1d8f30148c83864f3881db"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3aba7311af82e335dd1e36ffff68aaca609ca6290c2cb6d821a39aa075d8e3ff"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:763773d53f07244148ccac5b084da5adb90bfaee39c197554f01b286cf869228"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2270953c0d8cdab5d422bee7d2007f043473f9d2999631c86a223c9db56cbd16"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d099e745a512f7e3bbe7249ca835f4d357c586d78d79ae8f1dcd4d8adeb9bda9"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:74db36e14a7d1ce0986fa104f7d5637aea5c82ca6326ed0ec5694280942d1162"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:7e5bab140c309cb3a6ce373a9e71eb7e4873c70c2dda01df6820474f9889d6d4"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:0f114aa76dc1b8f636d077979c0ac22e7cd8f3493abbab152f20eb8d3cda71f3"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:88a2df29d4724b9237fc0c6eaf2a1adae0cdc0b3e9f4d8e7dc54b16812d2d81a"}, + {file = "kiwisolver-1.4.5-cp312-cp312-win32.whl", hash = "sha256:72d40b33e834371fd330fb1472ca19d9b8327acb79a5821d4008391db8e29f20"}, + {file = "kiwisolver-1.4.5-cp312-cp312-win_amd64.whl", hash = "sha256:2c5674c4e74d939b9d91dda0fae10597ac7521768fec9e399c70a1f27e2ea2d9"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:3a2b053a0ab7a3960c98725cfb0bf5b48ba82f64ec95fe06f1d06c99b552e130"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3cd32d6c13807e5c66a7cbb79f90b553642f296ae4518a60d8d76243b0ad2898"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:59ec7b7c7e1a61061850d53aaf8e93db63dce0c936db1fda2658b70e4a1be709"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:da4cfb373035def307905d05041c1d06d8936452fe89d464743ae7fb8371078b"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2400873bccc260b6ae184b2b8a4fec0e4082d30648eadb7c3d9a13405d861e89"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:1b04139c4236a0f3aff534479b58f6f849a8b351e1314826c2d230849ed48985"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:4e66e81a5779b65ac21764c295087de82235597a2293d18d943f8e9e32746265"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:7931d8f1f67c4be9ba1dd9c451fb0eeca1a25b89e4d3f89e828fe12a519b782a"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:b3f7e75f3015df442238cca659f8baa5f42ce2a8582727981cbfa15fee0ee205"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:bbf1d63eef84b2e8c89011b7f2235b1e0bf7dacc11cac9431fc6468e99ac77fb"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:4c380469bd3f970ef677bf2bcba2b6b0b4d5c75e7a020fb863ef75084efad66f"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-win32.whl", hash = "sha256:9408acf3270c4b6baad483865191e3e582b638b1654a007c62e3efe96f09a9a3"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-win_amd64.whl", hash = "sha256:5b94529f9b2591b7af5f3e0e730a4e0a41ea174af35a4fd067775f9bdfeee01a"}, + {file = "kiwisolver-1.4.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:11c7de8f692fc99816e8ac50d1d1aef4f75126eefc33ac79aac02c099fd3db71"}, + {file = "kiwisolver-1.4.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:53abb58632235cd154176ced1ae8f0d29a6657aa1aa9decf50b899b755bc2b93"}, + {file = "kiwisolver-1.4.5-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:88b9f257ca61b838b6f8094a62418421f87ac2a1069f7e896c36a7d86b5d4c29"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3195782b26fc03aa9c6913d5bad5aeb864bdc372924c093b0f1cebad603dd712"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fc579bf0f502e54926519451b920e875f433aceb4624a3646b3252b5caa9e0b6"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5a580c91d686376f0f7c295357595c5a026e6cbc3d77b7c36e290201e7c11ecb"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cfe6ab8da05c01ba6fbea630377b5da2cd9bcbc6338510116b01c1bc939a2c18"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:d2e5a98f0ec99beb3c10e13b387f8db39106d53993f498b295f0c914328b1333"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:a51a263952b1429e429ff236d2f5a21c5125437861baeed77f5e1cc2d2c7c6da"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:3edd2fa14e68c9be82c5b16689e8d63d89fe927e56debd6e1dbce7a26a17f81b"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:74d1b44c6cfc897df648cc9fdaa09bc3e7679926e6f96df05775d4fb3946571c"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:76d9289ed3f7501012e05abb8358bbb129149dbd173f1f57a1bf1c22d19ab7cc"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:92dea1ffe3714fa8eb6a314d2b3c773208d865a0e0d35e713ec54eea08a66250"}, + {file = "kiwisolver-1.4.5-cp38-cp38-win32.whl", hash = "sha256:5c90ae8c8d32e472be041e76f9d2f2dbff4d0b0be8bd4041770eddb18cf49a4e"}, + {file = "kiwisolver-1.4.5-cp38-cp38-win_amd64.whl", hash = "sha256:c7940c1dc63eb37a67721b10d703247552416f719c4188c54e04334321351ced"}, + {file = "kiwisolver-1.4.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:9407b6a5f0d675e8a827ad8742e1d6b49d9c1a1da5d952a67d50ef5f4170b18d"}, + {file = "kiwisolver-1.4.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:15568384086b6df3c65353820a4473575dbad192e35010f622c6ce3eebd57af9"}, + {file = "kiwisolver-1.4.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0dc9db8e79f0036e8173c466d21ef18e1befc02de8bf8aa8dc0813a6dc8a7046"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:cdc8a402aaee9a798b50d8b827d7ecf75edc5fb35ea0f91f213ff927c15f4ff0"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:6c3bd3cde54cafb87d74d8db50b909705c62b17c2099b8f2e25b461882e544ff"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:955e8513d07a283056b1396e9a57ceddbd272d9252c14f154d450d227606eb54"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:346f5343b9e3f00b8db8ba359350eb124b98c99efd0b408728ac6ebf38173958"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b9098e0049e88c6a24ff64545cdfc50807818ba6c1b739cae221bbbcbc58aad3"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:00bd361b903dc4bbf4eb165f24d1acbee754fce22ded24c3d56eec268658a5cf"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:7b8b454bac16428b22560d0a1cf0a09875339cab69df61d7805bf48919415901"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:f1d072c2eb0ad60d4c183f3fb44ac6f73fb7a8f16a2694a91f988275cbf352f9"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:31a82d498054cac9f6d0b53d02bb85811185bcb477d4b60144f915f3b3126342"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:6512cb89e334e4700febbffaaa52761b65b4f5a3cf33f960213d5656cea36a77"}, + {file = "kiwisolver-1.4.5-cp39-cp39-win32.whl", hash = "sha256:9db8ea4c388fdb0f780fe91346fd438657ea602d58348753d9fb265ce1bca67f"}, + {file = "kiwisolver-1.4.5-cp39-cp39-win_amd64.whl", hash = "sha256:59415f46a37f7f2efeec758353dd2eae1b07640d8ca0f0c42548ec4125492635"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:5c7b3b3a728dc6faf3fc372ef24f21d1e3cee2ac3e9596691d746e5a536de920"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:620ced262a86244e2be10a676b646f29c34537d0d9cc8eb26c08f53d98013390"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:378a214a1e3bbf5ac4a8708304318b4f890da88c9e6a07699c4ae7174c09a68d"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aaf7be1207676ac608a50cd08f102f6742dbfc70e8d60c4db1c6897f62f71523"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:ba55dce0a9b8ff59495ddd050a0225d58bd0983d09f87cfe2b6aec4f2c1234e4"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:fd32ea360bcbb92d28933fc05ed09bffcb1704ba3fc7942e81db0fd4f81a7892"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:5e7139af55d1688f8b960ee9ad5adafc4ac17c1c473fe07133ac092310d76544"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dced8146011d2bc2e883f9bd68618b8247387f4bbec46d7392b3c3b032640126"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9bf3325c47b11b2e51bca0824ea217c7cd84491d8ac4eefd1e409705ef092bd"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:5794cf59533bc3f1b1c821f7206a3617999db9fbefc345360aafe2e067514929"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:e368f200bbc2e4f905b8e71eb38b3c04333bddaa6a2464a6355487b02bb7fb09"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e5d706eba36b4c4d5bc6c6377bb6568098765e990cfc21ee16d13963fab7b3e7"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:85267bd1aa8880a9c88a8cb71e18d3d64d2751a790e6ca6c27b8ccc724bcd5ad"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:210ef2c3a1f03272649aff1ef992df2e724748918c4bc2d5a90352849eb40bea"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:11d011a7574eb3b82bcc9c1a1d35c1d7075677fdd15de527d91b46bd35e935ee"}, + {file = "kiwisolver-1.4.5.tar.gz", hash = "sha256:e57e563a57fb22a142da34f38acc2fc1a5c864bc29ca1517a88abc963e60d6ec"}, +] + [[package]] name = "kombu" version = "4.6.11" @@ -1401,6 +2460,68 @@ files = [ {file = "MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b"}, ] +[[package]] +name = "matplotlib" +version = "3.8.4" +description = "Python plotting package" +optional = false +python-versions = ">=3.9" +files = [ + {file = "matplotlib-3.8.4-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:abc9d838f93583650c35eca41cfcec65b2e7cb50fd486da6f0c49b5e1ed23014"}, + {file = "matplotlib-3.8.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f65c9f002d281a6e904976007b2d46a1ee2bcea3a68a8c12dda24709ddc9106"}, + {file = "matplotlib-3.8.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce1edd9f5383b504dbc26eeea404ed0a00656c526638129028b758fd43fc5f10"}, + {file = "matplotlib-3.8.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ecd79298550cba13a43c340581a3ec9c707bd895a6a061a78fa2524660482fc0"}, + {file = "matplotlib-3.8.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:90df07db7b599fe7035d2f74ab7e438b656528c68ba6bb59b7dc46af39ee48ef"}, + {file = "matplotlib-3.8.4-cp310-cp310-win_amd64.whl", hash = "sha256:ac24233e8f2939ac4fd2919eed1e9c0871eac8057666070e94cbf0b33dd9c338"}, + {file = "matplotlib-3.8.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:72f9322712e4562e792b2961971891b9fbbb0e525011e09ea0d1f416c4645661"}, + {file = "matplotlib-3.8.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:232ce322bfd020a434caaffbd9a95333f7c2491e59cfc014041d95e38ab90d1c"}, + {file = "matplotlib-3.8.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6addbd5b488aedb7f9bc19f91cd87ea476206f45d7116fcfe3d31416702a82fa"}, + {file = "matplotlib-3.8.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc4ccdc64e3039fc303defd119658148f2349239871db72cd74e2eeaa9b80b71"}, + {file = "matplotlib-3.8.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:b7a2a253d3b36d90c8993b4620183b55665a429da8357a4f621e78cd48b2b30b"}, + {file = "matplotlib-3.8.4-cp311-cp311-win_amd64.whl", hash = "sha256:8080d5081a86e690d7688ffa542532e87f224c38a6ed71f8fbed34dd1d9fedae"}, + {file = "matplotlib-3.8.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:6485ac1f2e84676cff22e693eaa4fbed50ef5dc37173ce1f023daef4687df616"}, + {file = "matplotlib-3.8.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c89ee9314ef48c72fe92ce55c4e95f2f39d70208f9f1d9db4e64079420d8d732"}, + {file = "matplotlib-3.8.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50bac6e4d77e4262c4340d7a985c30912054745ec99756ce213bfbc3cb3808eb"}, + {file = "matplotlib-3.8.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f51c4c869d4b60d769f7b4406eec39596648d9d70246428745a681c327a8ad30"}, + {file = "matplotlib-3.8.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:b12ba985837e4899b762b81f5b2845bd1a28f4fdd1a126d9ace64e9c4eb2fb25"}, + {file = "matplotlib-3.8.4-cp312-cp312-win_amd64.whl", hash = "sha256:7a6769f58ce51791b4cb8b4d7642489df347697cd3e23d88266aaaee93b41d9a"}, + {file = "matplotlib-3.8.4-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:843cbde2f0946dadd8c5c11c6d91847abd18ec76859dc319362a0964493f0ba6"}, + {file = "matplotlib-3.8.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1c13f041a7178f9780fb61cc3a2b10423d5e125480e4be51beaf62b172413b67"}, + {file = "matplotlib-3.8.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb44f53af0a62dc80bba4443d9b27f2fde6acfdac281d95bc872dc148a6509cc"}, + {file = "matplotlib-3.8.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:606e3b90897554c989b1e38a258c626d46c873523de432b1462f295db13de6f9"}, + {file = "matplotlib-3.8.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:9bb0189011785ea794ee827b68777db3ca3f93f3e339ea4d920315a0e5a78d54"}, + {file = "matplotlib-3.8.4-cp39-cp39-win_amd64.whl", hash = "sha256:6209e5c9aaccc056e63b547a8152661324404dd92340a6e479b3a7f24b42a5d0"}, + {file = "matplotlib-3.8.4-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c7064120a59ce6f64103c9cefba8ffe6fba87f2c61d67c401186423c9a20fd35"}, + {file = "matplotlib-3.8.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0e47eda4eb2614300fc7bb4657fced3e83d6334d03da2173b09e447418d499f"}, + {file = "matplotlib-3.8.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:493e9f6aa5819156b58fce42b296ea31969f2aab71c5b680b4ea7a3cb5c07d94"}, + {file = "matplotlib-3.8.4.tar.gz", hash = "sha256:8aac397d5e9ec158960e31c381c5ffc52ddd52bd9a47717e2a694038167dffea"}, +] + +[package.dependencies] +contourpy = ">=1.0.1" +cycler = ">=0.10" +fonttools = ">=4.22.0" +kiwisolver = ">=1.3.1" +numpy = ">=1.21" +packaging = ">=20.0" +pillow = ">=8" +pyparsing = ">=2.3.1" +python-dateutil = ">=2.7" + +[[package]] +name = "matplotlib-inline" +version = "0.1.7" +description = "Inline Matplotlib backend for Jupyter" +optional = false +python-versions = ">=3.8" +files = [ + {file = "matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca"}, + {file = "matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90"}, +] + +[package.dependencies] +traitlets = "*" + [[package]] name = "mdurl" version = "0.1.2" @@ -1412,6 +2533,17 @@ files = [ {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"}, ] +[[package]] +name = "mistune" +version = "3.0.2" +description = "A sane and fast Markdown parser with useful plugins and renderers" +optional = false +python-versions = ">=3.7" +files = [ + {file = "mistune-3.0.2-py3-none-any.whl", hash = "sha256:71481854c30fdbc938963d3605b72501f5c10a9320ecd412c121c163a1c7d205"}, + {file = "mistune-3.0.2.tar.gz", hash = "sha256:fc7f93ded930c92394ef2cb6f04a8aabab4117a91449e72dcc8dfa646a508be8"}, +] + [[package]] name = "multidict" version = "6.0.5" @@ -1511,6 +2643,114 @@ files = [ {file = "multidict-6.0.5.tar.gz", hash = "sha256:f7e301075edaf50500f0b341543c41194d8df3ae5caf4702f2095f3ca73dd8da"}, ] +[[package]] +name = "nbclient" +version = "0.10.0" +description = "A client library for executing notebooks. Formerly nbconvert's ExecutePreprocessor." +optional = false +python-versions = ">=3.8.0" +files = [ + {file = "nbclient-0.10.0-py3-none-any.whl", hash = "sha256:f13e3529332a1f1f81d82a53210322476a168bb7090a0289c795fe9cc11c9d3f"}, + {file = "nbclient-0.10.0.tar.gz", hash = "sha256:4b3f1b7dba531e498449c4db4f53da339c91d449dc11e9af3a43b4eb5c5abb09"}, +] + +[package.dependencies] +jupyter-client = ">=6.1.12" +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +nbformat = ">=5.1" +traitlets = ">=5.4" + +[package.extras] +dev = ["pre-commit"] +docs = ["autodoc-traits", "mock", "moto", "myst-parser", "nbclient[test]", "sphinx (>=1.7)", "sphinx-book-theme", "sphinxcontrib-spelling"] +test = ["flaky", "ipykernel (>=6.19.3)", "ipython", "ipywidgets", "nbconvert (>=7.0.0)", "pytest (>=7.0,<8)", "pytest-asyncio", "pytest-cov (>=4.0)", "testpath", "xmltodict"] + +[[package]] +name = "nbconvert" +version = "7.16.4" +description = "Converting Jupyter Notebooks (.ipynb files) to other formats. Output formats include asciidoc, html, latex, markdown, pdf, py, rst, script. nbconvert can be used both as a Python library (`import nbconvert`) or as a command line tool (invoked as `jupyter nbconvert ...`)." +optional = false +python-versions = ">=3.8" +files = [ + {file = "nbconvert-7.16.4-py3-none-any.whl", hash = "sha256:05873c620fe520b6322bf8a5ad562692343fe3452abda5765c7a34b7d1aa3eb3"}, + {file = "nbconvert-7.16.4.tar.gz", hash = "sha256:86ca91ba266b0a448dc96fa6c5b9d98affabde2867b363258703536807f9f7f4"}, +] + +[package.dependencies] +beautifulsoup4 = "*" +bleach = "!=5.0.0" +defusedxml = "*" +jinja2 = ">=3.0" +jupyter-core = ">=4.7" +jupyterlab-pygments = "*" +markupsafe = ">=2.0" +mistune = ">=2.0.3,<4" +nbclient = ">=0.5.0" +nbformat = ">=5.7" +packaging = "*" +pandocfilters = ">=1.4.1" +pygments = ">=2.4.1" +tinycss2 = "*" +traitlets = ">=5.1" + +[package.extras] +all = ["flaky", "ipykernel", "ipython", "ipywidgets (>=7.5)", "myst-parser", "nbsphinx (>=0.2.12)", "playwright", "pydata-sphinx-theme", "pyqtwebengine (>=5.15)", "pytest (>=7)", "sphinx (==5.0.2)", "sphinxcontrib-spelling", "tornado (>=6.1)"] +docs = ["ipykernel", "ipython", "myst-parser", "nbsphinx (>=0.2.12)", "pydata-sphinx-theme", "sphinx (==5.0.2)", "sphinxcontrib-spelling"] +qtpdf = ["pyqtwebengine (>=5.15)"] +qtpng = ["pyqtwebengine (>=5.15)"] +serve = ["tornado (>=6.1)"] +test = ["flaky", "ipykernel", "ipywidgets (>=7.5)", "pytest (>=7)"] +webpdf = ["playwright"] + +[[package]] +name = "nbformat" +version = "5.10.4" +description = "The Jupyter Notebook format" +optional = false +python-versions = ">=3.8" +files = [ + {file = "nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b"}, + {file = "nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a"}, +] + +[package.dependencies] +fastjsonschema = ">=2.15" +jsonschema = ">=2.6" +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +traitlets = ">=5.1" + +[package.extras] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"] +test = ["pep440", "pre-commit", "pytest", "testpath"] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +description = "Patch asyncio to allow nested event loops" +optional = false +python-versions = ">=3.5" +files = [ + {file = "nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c"}, + {file = "nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe"}, +] + +[[package]] +name = "notebook-shim" +version = "0.2.4" +description = "A shim layer for notebook traits and config" +optional = false +python-versions = ">=3.7" +files = [ + {file = "notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef"}, + {file = "notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb"}, +] + +[package.dependencies] +jupyter-server = ">=1.8,<3" + +[package.extras] +test = ["pytest", "pytest-console-scripts", "pytest-jupyter", "pytest-tornasync"] + [[package]] name = "numpy" version = "1.26.4" @@ -1572,6 +2812,17 @@ rsa = ["cryptography (>=3.0.0)"] signals = ["blinker (>=1.4.0)"] signedtoken = ["cryptography (>=3.0.0)", "pyjwt (>=2.0.0,<3)"] +[[package]] +name = "overrides" +version = "7.7.0" +description = "A decorator to automatically detect mismatch when overriding a method." +optional = false +python-versions = ">=3.6" +files = [ + {file = "overrides-7.7.0-py3-none-any.whl", hash = "sha256:c7ed9d062f78b8e4c1a7b70bd8796b35ead4d9f510227ef9c5dc7626c60d7e49"}, + {file = "overrides-7.7.0.tar.gz", hash = "sha256:55158fa3d93b98cc75299b1e67078ad9003ca27945c76162c1c0766d6f91820a"}, +] + [[package]] name = "packaging" version = "23.2" @@ -1627,6 +2878,132 @@ pytz = ">=2020.1" [package.extras] test = ["hypothesis (>=5.5.3)", "pytest (>=6.0)", "pytest-xdist (>=1.31)"] +[[package]] +name = "pandocfilters" +version = "1.5.1" +description = "Utilities for writing pandoc filters in python" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +files = [ + {file = "pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc"}, + {file = "pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e"}, +] + +[[package]] +name = "parso" +version = "0.8.4" +description = "A Python Parser" +optional = false +python-versions = ">=3.6" +files = [ + {file = "parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18"}, + {file = "parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d"}, +] + +[package.extras] +qa = ["flake8 (==5.0.4)", "mypy (==0.971)", "types-setuptools (==67.2.0.1)"] +testing = ["docopt", "pytest"] + +[[package]] +name = "pexpect" +version = "4.9.0" +description = "Pexpect allows easy control of interactive console applications." +optional = false +python-versions = "*" +files = [ + {file = "pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523"}, + {file = "pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f"}, +] + +[package.dependencies] +ptyprocess = ">=0.5" + +[[package]] +name = "pillow" +version = "10.3.0" +description = "Python Imaging Library (Fork)" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pillow-10.3.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:90b9e29824800e90c84e4022dd5cc16eb2d9605ee13f05d47641eb183cd73d45"}, + {file = "pillow-10.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a2c405445c79c3f5a124573a051062300936b0281fee57637e706453e452746c"}, + {file = "pillow-10.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78618cdbccaa74d3f88d0ad6cb8ac3007f1a6fa5c6f19af64b55ca170bfa1edf"}, + {file = "pillow-10.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:261ddb7ca91fcf71757979534fb4c128448b5b4c55cb6152d280312062f69599"}, + {file = "pillow-10.3.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:ce49c67f4ea0609933d01c0731b34b8695a7a748d6c8d186f95e7d085d2fe475"}, + {file = "pillow-10.3.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:b14f16f94cbc61215115b9b1236f9c18403c15dd3c52cf629072afa9d54c1cbf"}, + {file = "pillow-10.3.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:d33891be6df59d93df4d846640f0e46f1a807339f09e79a8040bc887bdcd7ed3"}, + {file = "pillow-10.3.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b50811d664d392f02f7761621303eba9d1b056fb1868c8cdf4231279645c25f5"}, + {file = "pillow-10.3.0-cp310-cp310-win32.whl", hash = "sha256:ca2870d5d10d8726a27396d3ca4cf7976cec0f3cb706debe88e3a5bd4610f7d2"}, + {file = "pillow-10.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:f0d0591a0aeaefdaf9a5e545e7485f89910c977087e7de2b6c388aec32011e9f"}, + {file = "pillow-10.3.0-cp310-cp310-win_arm64.whl", hash = "sha256:ccce24b7ad89adb5a1e34a6ba96ac2530046763912806ad4c247356a8f33a67b"}, + {file = "pillow-10.3.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:5f77cf66e96ae734717d341c145c5949c63180842a545c47a0ce7ae52ca83795"}, + {file = "pillow-10.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e4b878386c4bf293578b48fc570b84ecfe477d3b77ba39a6e87150af77f40c57"}, + {file = "pillow-10.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fdcbb4068117dfd9ce0138d068ac512843c52295ed996ae6dd1faf537b6dbc27"}, + {file = "pillow-10.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9797a6c8fe16f25749b371c02e2ade0efb51155e767a971c61734b1bf6293994"}, + {file = "pillow-10.3.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:9e91179a242bbc99be65e139e30690e081fe6cb91a8e77faf4c409653de39451"}, + {file = "pillow-10.3.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:1b87bd9d81d179bd8ab871603bd80d8645729939f90b71e62914e816a76fc6bd"}, + {file = "pillow-10.3.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:81d09caa7b27ef4e61cb7d8fbf1714f5aec1c6b6c5270ee53504981e6e9121ad"}, + {file = "pillow-10.3.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:048ad577748b9fa4a99a0548c64f2cb8d672d5bf2e643a739ac8faff1164238c"}, + {file = "pillow-10.3.0-cp311-cp311-win32.whl", hash = "sha256:7161ec49ef0800947dc5570f86568a7bb36fa97dd09e9827dc02b718c5643f09"}, + {file = "pillow-10.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:8eb0908e954d093b02a543dc963984d6e99ad2b5e36503d8a0aaf040505f747d"}, + {file = "pillow-10.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:4e6f7d1c414191c1199f8996d3f2282b9ebea0945693fb67392c75a3a320941f"}, + {file = "pillow-10.3.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:e46f38133e5a060d46bd630faa4d9fa0202377495df1f068a8299fd78c84de84"}, + {file = "pillow-10.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:50b8eae8f7334ec826d6eeffaeeb00e36b5e24aa0b9df322c247539714c6df19"}, + {file = "pillow-10.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9d3bea1c75f8c53ee4d505c3e67d8c158ad4df0d83170605b50b64025917f338"}, + {file = "pillow-10.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:19aeb96d43902f0a783946a0a87dbdad5c84c936025b8419da0a0cd7724356b1"}, + {file = "pillow-10.3.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:74d28c17412d9caa1066f7a31df8403ec23d5268ba46cd0ad2c50fb82ae40462"}, + {file = "pillow-10.3.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:ff61bfd9253c3915e6d41c651d5f962da23eda633cf02262990094a18a55371a"}, + {file = "pillow-10.3.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d886f5d353333b4771d21267c7ecc75b710f1a73d72d03ca06df49b09015a9ef"}, + {file = "pillow-10.3.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4b5ec25d8b17217d635f8935dbc1b9aa5907962fae29dff220f2659487891cd3"}, + {file = "pillow-10.3.0-cp312-cp312-win32.whl", hash = "sha256:51243f1ed5161b9945011a7360e997729776f6e5d7005ba0c6879267d4c5139d"}, + {file = "pillow-10.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:412444afb8c4c7a6cc11a47dade32982439925537e483be7c0ae0cf96c4f6a0b"}, + {file = "pillow-10.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:798232c92e7665fe82ac085f9d8e8ca98826f8e27859d9a96b41d519ecd2e49a"}, + {file = "pillow-10.3.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:4eaa22f0d22b1a7e93ff0a596d57fdede2e550aecffb5a1ef1106aaece48e96b"}, + {file = "pillow-10.3.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:cd5e14fbf22a87321b24c88669aad3a51ec052eb145315b3da3b7e3cc105b9a2"}, + {file = "pillow-10.3.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1530e8f3a4b965eb6a7785cf17a426c779333eb62c9a7d1bbcf3ffd5bf77a4aa"}, + {file = "pillow-10.3.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5d512aafa1d32efa014fa041d38868fda85028e3f930a96f85d49c7d8ddc0383"}, + {file = "pillow-10.3.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:339894035d0ede518b16073bdc2feef4c991ee991a29774b33e515f1d308e08d"}, + {file = "pillow-10.3.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:aa7e402ce11f0885305bfb6afb3434b3cd8f53b563ac065452d9d5654c7b86fd"}, + {file = "pillow-10.3.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:0ea2a783a2bdf2a561808fe4a7a12e9aa3799b701ba305de596bc48b8bdfce9d"}, + {file = "pillow-10.3.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:c78e1b00a87ce43bb37642c0812315b411e856a905d58d597750eb79802aaaa3"}, + {file = "pillow-10.3.0-cp38-cp38-win32.whl", hash = "sha256:72d622d262e463dfb7595202d229f5f3ab4b852289a1cd09650362db23b9eb0b"}, + {file = "pillow-10.3.0-cp38-cp38-win_amd64.whl", hash = "sha256:2034f6759a722da3a3dbd91a81148cf884e91d1b747992ca288ab88c1de15999"}, + {file = "pillow-10.3.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:2ed854e716a89b1afcedea551cd85f2eb2a807613752ab997b9974aaa0d56936"}, + {file = "pillow-10.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:dc1a390a82755a8c26c9964d457d4c9cbec5405896cba94cf51f36ea0d855002"}, + {file = "pillow-10.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4203efca580f0dd6f882ca211f923168548f7ba334c189e9eab1178ab840bf60"}, + {file = "pillow-10.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3102045a10945173d38336f6e71a8dc71bcaeed55c3123ad4af82c52807b9375"}, + {file = "pillow-10.3.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:6fb1b30043271ec92dc65f6d9f0b7a830c210b8a96423074b15c7bc999975f57"}, + {file = "pillow-10.3.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:1dfc94946bc60ea375cc39cff0b8da6c7e5f8fcdc1d946beb8da5c216156ddd8"}, + {file = "pillow-10.3.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b09b86b27a064c9624d0a6c54da01c1beaf5b6cadfa609cf63789b1d08a797b9"}, + {file = "pillow-10.3.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:d3b2348a78bc939b4fed6552abfd2e7988e0f81443ef3911a4b8498ca084f6eb"}, + {file = "pillow-10.3.0-cp39-cp39-win32.whl", hash = "sha256:45ebc7b45406febf07fef35d856f0293a92e7417ae7933207e90bf9090b70572"}, + {file = "pillow-10.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:0ba26351b137ca4e0db0342d5d00d2e355eb29372c05afd544ebf47c0956ffeb"}, + {file = "pillow-10.3.0-cp39-cp39-win_arm64.whl", hash = "sha256:50fd3f6b26e3441ae07b7c979309638b72abc1a25da31a81a7fbd9495713ef4f"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-macosx_10_10_x86_64.whl", hash = "sha256:6b02471b72526ab8a18c39cb7967b72d194ec53c1fd0a70b050565a0f366d355"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:8ab74c06ffdab957d7670c2a5a6e1a70181cd10b727cd788c4dd9005b6a8acd9"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:048eeade4c33fdf7e08da40ef402e748df113fd0b4584e32c4af74fe78baaeb2"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e2ec1e921fd07c7cda7962bad283acc2f2a9ccc1b971ee4b216b75fad6f0463"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:4c8e73e99da7db1b4cad7f8d682cf6abad7844da39834c288fbfa394a47bbced"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:16563993329b79513f59142a6b02055e10514c1a8e86dca8b48a893e33cf91e3"}, + {file = "pillow-10.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:dd78700f5788ae180b5ee8902c6aea5a5726bac7c364b202b4b3e3ba2d293170"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:aff76a55a8aa8364d25400a210a65ff59d0168e0b4285ba6bf2bd83cf675ba32"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:b7bc2176354defba3edc2b9a777744462da2f8e921fbaf61e52acb95bafa9828"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:793b4e24db2e8742ca6423d3fde8396db336698c55cd34b660663ee9e45ed37f"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d93480005693d247f8346bc8ee28c72a2191bdf1f6b5db469c096c0c867ac015"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:c83341b89884e2b2e55886e8fbbf37c3fa5efd6c8907124aeb72f285ae5696e5"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:1a1d1915db1a4fdb2754b9de292642a39a7fb28f1736699527bb649484fb966a"}, + {file = "pillow-10.3.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a0eaa93d054751ee9964afa21c06247779b90440ca41d184aeb5d410f20ff591"}, + {file = "pillow-10.3.0.tar.gz", hash = "sha256:9d2455fbf44c914840c793e89aa82d0e1763a14253a000743719ae5946814b2d"}, +] + +[package.extras] +docs = ["furo", "olefile", "sphinx (>=2.4)", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-removed-in", "sphinxext-opengraph"] +fpx = ["olefile"] +mic = ["olefile"] +tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "packaging", "pyroma", "pytest", "pytest-cov", "pytest-timeout"] +typing = ["typing-extensions"] +xmp = ["defusedxml"] + [[package]] name = "platformdirs" version = "4.2.0" @@ -1657,6 +3034,62 @@ files = [ dev = ["pre-commit", "tox"] testing = ["pytest", "pytest-benchmark"] +[[package]] +name = "prometheus-client" +version = "0.20.0" +description = "Python client for the Prometheus monitoring system." +optional = false +python-versions = ">=3.8" +files = [ + {file = "prometheus_client-0.20.0-py3-none-any.whl", hash = "sha256:cde524a85bce83ca359cc837f28b8c0db5cac7aa653a588fd7e84ba061c329e7"}, + {file = "prometheus_client-0.20.0.tar.gz", hash = "sha256:287629d00b147a32dcb2be0b9df905da599b2d82f80377083ec8463309a4bb89"}, +] + +[package.extras] +twisted = ["twisted"] + +[[package]] +name = "prompt-toolkit" +version = "3.0.43" +description = "Library for building powerful interactive command lines in Python" +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "prompt_toolkit-3.0.43-py3-none-any.whl", hash = "sha256:a11a29cb3bf0a28a387fe5122cdb649816a957cd9261dcedf8c9f1fef33eacf6"}, + {file = "prompt_toolkit-3.0.43.tar.gz", hash = "sha256:3527b7af26106cbc65a040bcc84839a3566ec1b051bb0bfe953631e704b0ff7d"}, +] + +[package.dependencies] +wcwidth = "*" + +[[package]] +name = "psutil" +version = "5.9.8" +description = "Cross-platform lib for process and system monitoring in Python." +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*" +files = [ + {file = "psutil-5.9.8-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:26bd09967ae00920df88e0352a91cff1a78f8d69b3ecabbfe733610c0af486c8"}, + {file = "psutil-5.9.8-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:05806de88103b25903dff19bb6692bd2e714ccf9e668d050d144012055cbca73"}, + {file = "psutil-5.9.8-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:611052c4bc70432ec770d5d54f64206aa7203a101ec273a0cd82418c86503bb7"}, + {file = "psutil-5.9.8-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:50187900d73c1381ba1454cf40308c2bf6f34268518b3f36a9b663ca87e65e36"}, + {file = "psutil-5.9.8-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:02615ed8c5ea222323408ceba16c60e99c3f91639b07da6373fb7e6539abc56d"}, + {file = "psutil-5.9.8-cp27-none-win32.whl", hash = "sha256:36f435891adb138ed3c9e58c6af3e2e6ca9ac2f365efe1f9cfef2794e6c93b4e"}, + {file = "psutil-5.9.8-cp27-none-win_amd64.whl", hash = "sha256:bd1184ceb3f87651a67b2708d4c3338e9b10c5df903f2e3776b62303b26cb631"}, + {file = "psutil-5.9.8-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:aee678c8720623dc456fa20659af736241f575d79429a0e5e9cf88ae0605cc81"}, + {file = "psutil-5.9.8-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8cb6403ce6d8e047495a701dc7c5bd788add903f8986d523e3e20b98b733e421"}, + {file = "psutil-5.9.8-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d06016f7f8625a1825ba3732081d77c94589dca78b7a3fc072194851e88461a4"}, + {file = "psutil-5.9.8-cp36-cp36m-win32.whl", hash = "sha256:7d79560ad97af658a0f6adfef8b834b53f64746d45b403f225b85c5c2c140eee"}, + {file = "psutil-5.9.8-cp36-cp36m-win_amd64.whl", hash = "sha256:27cc40c3493bb10de1be4b3f07cae4c010ce715290a5be22b98493509c6299e2"}, + {file = "psutil-5.9.8-cp37-abi3-win32.whl", hash = "sha256:bc56c2a1b0d15aa3eaa5a60c9f3f8e3e565303b465dbf57a1b730e7a2b9844e0"}, + {file = "psutil-5.9.8-cp37-abi3-win_amd64.whl", hash = "sha256:8db4c1b57507eef143a15a6884ca10f7c73876cdf5d51e713151c1236a0e68cf"}, + {file = "psutil-5.9.8-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:d16bbddf0693323b8c6123dd804100241da461e41d6e332fb0ba6058f630f8c8"}, + {file = "psutil-5.9.8.tar.gz", hash = "sha256:6be126e3225486dff286a8fb9a06246a5253f4c7c53b475ea5f5ac934e64194c"}, +] + +[package.extras] +test = ["enum34", "ipaddress", "mock", "pywin32", "wmi"] + [[package]] name = "psycopg2-binary" version = "2.8.5" @@ -1696,6 +3129,31 @@ files = [ {file = "psycopg2_binary-2.8.5-cp38-cp38-win_amd64.whl", hash = "sha256:fa466306fcf6b39b8a61d003123d442b23707d635a5cb05ac4e1b62cc79105cd"}, ] +[[package]] +name = "ptyprocess" +version = "0.7.0" +description = "Run a subprocess in a pseudo terminal" +optional = false +python-versions = "*" +files = [ + {file = "ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35"}, + {file = "ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220"}, +] + +[[package]] +name = "pure-eval" +version = "0.2.2" +description = "Safely evaluate AST nodes without side effects" +optional = false +python-versions = "*" +files = [ + {file = "pure_eval-0.2.2-py3-none-any.whl", hash = "sha256:01eaab343580944bc56080ebe0a674b39ec44a945e6d09ba7db3cb8cec289350"}, + {file = "pure_eval-0.2.2.tar.gz", hash = "sha256:2b45320af6dfaa1750f543d714b6d1c520a1688dec6fd24d339063ce0aaa9ac3"}, +] + +[package.extras] +tests = ["pytest"] + [[package]] name = "pyasn1" version = "0.5.1" @@ -1924,6 +3382,20 @@ cryptography = ">=41.0.5,<43" docs = ["sphinx (!=5.2.0,!=5.2.0.post0,!=7.2.5)", "sphinx-rtd-theme"] test = ["flaky", "pretend", "pytest (>=3.0.1)"] +[[package]] +name = "pyparsing" +version = "3.1.2" +description = "pyparsing module - Classes and methods to define and execute parsing grammars" +optional = false +python-versions = ">=3.6.8" +files = [ + {file = "pyparsing-3.1.2-py3-none-any.whl", hash = "sha256:f9db75911801ed778fe61bb643079ff86601aca99fcae6345aa67292038fb742"}, + {file = "pyparsing-3.1.2.tar.gz", hash = "sha256:a1bac0ce561155ecc3ed78ca94d3c9378656ad4c94c1270de543f621420f94ad"}, +] + +[package.extras] +diagrams = ["jinja2", "railroad-diagrams"] + [[package]] name = "pyproj" version = "3.6.1" @@ -2059,13 +3531,13 @@ cron-schedule = ["croniter"] [[package]] name = "python-dateutil" -version = "2.8.1" +version = "2.9.0.post0" description = "Extensions to the standard Python datetime module" optional = false python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" files = [ - {file = "python-dateutil-2.8.1.tar.gz", hash = "sha256:73ebfe9dbf22e832286dafa60473e4cd239f8592f699aa5adaf10050e6e1823c"}, - {file = "python_dateutil-2.8.1-py2.py3-none-any.whl", hash = "sha256:75bb3f31ea686f1197762692a9ee6a7550b59fc6ca3a1f4b5d7e32fb98e2da2a"}, + {file = "python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3"}, + {file = "python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427"}, ] [package.dependencies] @@ -2085,6 +3557,17 @@ files = [ [package.extras] cli = ["click (>=5.0)"] +[[package]] +name = "python-json-logger" +version = "2.0.7" +description = "A python library adding a json log formatter" +optional = false +python-versions = ">=3.6" +files = [ + {file = "python-json-logger-2.0.7.tar.gz", hash = "sha256:23e7ec02d34237c5aa1e29a070193a4ea87583bb4e7f8fd06d3de8264c4b2e1c"}, + {file = "python_json_logger-2.0.7-py3-none-any.whl", hash = "sha256:f380b826a991ebbe3de4d897aeec42760035ac760345e57b812938dc8b35e2bd"}, +] + [[package]] name = "python-multipart" version = "0.0.9" @@ -2110,6 +3593,44 @@ files = [ {file = "pytz-2020.1.tar.gz", hash = "sha256:c35965d010ce31b23eeb663ed3cc8c906275d6be1a34393a1d73a41febf4a048"}, ] +[[package]] +name = "pywin32" +version = "306" +description = "Python for Window Extensions" +optional = false +python-versions = "*" +files = [ + {file = "pywin32-306-cp310-cp310-win32.whl", hash = "sha256:06d3420a5155ba65f0b72f2699b5bacf3109f36acbe8923765c22938a69dfc8d"}, + {file = "pywin32-306-cp310-cp310-win_amd64.whl", hash = "sha256:84f4471dbca1887ea3803d8848a1616429ac94a4a8d05f4bc9c5dcfd42ca99c8"}, + {file = "pywin32-306-cp311-cp311-win32.whl", hash = "sha256:e65028133d15b64d2ed8f06dd9fbc268352478d4f9289e69c190ecd6818b6407"}, + {file = "pywin32-306-cp311-cp311-win_amd64.whl", hash = "sha256:a7639f51c184c0272e93f244eb24dafca9b1855707d94c192d4a0b4c01e1100e"}, + {file = "pywin32-306-cp311-cp311-win_arm64.whl", hash = "sha256:70dba0c913d19f942a2db25217d9a1b726c278f483a919f1abfed79c9cf64d3a"}, + {file = "pywin32-306-cp312-cp312-win32.whl", hash = "sha256:383229d515657f4e3ed1343da8be101000562bf514591ff383ae940cad65458b"}, + {file = "pywin32-306-cp312-cp312-win_amd64.whl", hash = "sha256:37257794c1ad39ee9be652da0462dc2e394c8159dfd913a8a4e8eb6fd346da0e"}, + {file = "pywin32-306-cp312-cp312-win_arm64.whl", hash = "sha256:5821ec52f6d321aa59e2db7e0a35b997de60c201943557d108af9d4ae1ec7040"}, + {file = "pywin32-306-cp37-cp37m-win32.whl", hash = "sha256:1c73ea9a0d2283d889001998059f5eaaba3b6238f767c9cf2833b13e6a685f65"}, + {file = "pywin32-306-cp37-cp37m-win_amd64.whl", hash = "sha256:72c5f621542d7bdd4fdb716227be0dd3f8565c11b280be6315b06ace35487d36"}, + {file = "pywin32-306-cp38-cp38-win32.whl", hash = "sha256:e4c092e2589b5cf0d365849e73e02c391c1349958c5ac3e9d5ccb9a28e017b3a"}, + {file = "pywin32-306-cp38-cp38-win_amd64.whl", hash = "sha256:e8ac1ae3601bee6ca9f7cb4b5363bf1c0badb935ef243c4733ff9a393b1690c0"}, + {file = "pywin32-306-cp39-cp39-win32.whl", hash = "sha256:e25fd5b485b55ac9c057f67d94bc203f3f6595078d1fb3b458c9c28b7153a802"}, + {file = "pywin32-306-cp39-cp39-win_amd64.whl", hash = "sha256:39b61c15272833b5c329a2989999dcae836b1eed650252ab1b7bfbe1d59f30f4"}, +] + +[[package]] +name = "pywinpty" +version = "2.0.13" +description = "Pseudo terminal support for Windows from Python." +optional = false +python-versions = ">=3.8" +files = [ + {file = "pywinpty-2.0.13-cp310-none-win_amd64.whl", hash = "sha256:697bff211fb5a6508fee2dc6ff174ce03f34a9a233df9d8b5fe9c8ce4d5eaf56"}, + {file = "pywinpty-2.0.13-cp311-none-win_amd64.whl", hash = "sha256:b96fb14698db1284db84ca38c79f15b4cfdc3172065b5137383910567591fa99"}, + {file = "pywinpty-2.0.13-cp312-none-win_amd64.whl", hash = "sha256:2fd876b82ca750bb1333236ce98488c1be96b08f4f7647cfdf4129dfad83c2d4"}, + {file = "pywinpty-2.0.13-cp38-none-win_amd64.whl", hash = "sha256:61d420c2116c0212808d31625611b51caf621fe67f8a6377e2e8b617ea1c1f7d"}, + {file = "pywinpty-2.0.13-cp39-none-win_amd64.whl", hash = "sha256:71cb613a9ee24174730ac7ae439fd179ca34ccb8c5349e8d7b72ab5dea2c6f4b"}, + {file = "pywinpty-2.0.13.tar.gz", hash = "sha256:c34e32351a3313ddd0d7da23d27f835c860d32fe4ac814d372a3ea9594f41dde"}, +] + [[package]] name = "pyyaml" version = "6.0.1" @@ -2170,6 +3691,106 @@ files = [ {file = "PyYAML-6.0.1.tar.gz", hash = "sha256:bfdf460b1736c775f2ba9f6a92bca30bc2095067b8a9d77876d1fad6cc3b4a43"}, ] +[[package]] +name = "pyzmq" +version = "26.0.3" +description = "Python bindings for 0MQ" +optional = false +python-versions = ">=3.7" +files = [ + {file = "pyzmq-26.0.3-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:44dd6fc3034f1eaa72ece33588867df9e006a7303725a12d64c3dff92330f625"}, + {file = "pyzmq-26.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:acb704195a71ac5ea5ecf2811c9ee19ecdc62b91878528302dd0be1b9451cc90"}, + {file = "pyzmq-26.0.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5dbb9c997932473a27afa93954bb77a9f9b786b4ccf718d903f35da3232317de"}, + {file = "pyzmq-26.0.3-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6bcb34f869d431799c3ee7d516554797f7760cb2198ecaa89c3f176f72d062be"}, + {file = "pyzmq-26.0.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:38ece17ec5f20d7d9b442e5174ae9f020365d01ba7c112205a4d59cf19dc38ee"}, + {file = "pyzmq-26.0.3-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:ba6e5e6588e49139a0979d03a7deb9c734bde647b9a8808f26acf9c547cab1bf"}, + {file = "pyzmq-26.0.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:3bf8b000a4e2967e6dfdd8656cd0757d18c7e5ce3d16339e550bd462f4857e59"}, + {file = "pyzmq-26.0.3-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:2136f64fbb86451dbbf70223635a468272dd20075f988a102bf8a3f194a411dc"}, + {file = "pyzmq-26.0.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:e8918973fbd34e7814f59143c5f600ecd38b8038161239fd1a3d33d5817a38b8"}, + {file = "pyzmq-26.0.3-cp310-cp310-win32.whl", hash = "sha256:0aaf982e68a7ac284377d051c742610220fd06d330dcd4c4dbb4cdd77c22a537"}, + {file = "pyzmq-26.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:f1a9b7d00fdf60b4039f4455afd031fe85ee8305b019334b72dcf73c567edc47"}, + {file = "pyzmq-26.0.3-cp310-cp310-win_arm64.whl", hash = "sha256:80b12f25d805a919d53efc0a5ad7c0c0326f13b4eae981a5d7b7cc343318ebb7"}, + {file = "pyzmq-26.0.3-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:a72a84570f84c374b4c287183debc776dc319d3e8ce6b6a0041ce2e400de3f32"}, + {file = "pyzmq-26.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:7ca684ee649b55fd8f378127ac8462fb6c85f251c2fb027eb3c887e8ee347bcd"}, + {file = "pyzmq-26.0.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e222562dc0f38571c8b1ffdae9d7adb866363134299264a1958d077800b193b7"}, + {file = "pyzmq-26.0.3-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f17cde1db0754c35a91ac00b22b25c11da6eec5746431d6e5092f0cd31a3fea9"}, + {file = "pyzmq-26.0.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b7c0c0b3244bb2275abe255d4a30c050d541c6cb18b870975553f1fb6f37527"}, + {file = "pyzmq-26.0.3-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:ac97a21de3712afe6a6c071abfad40a6224fd14fa6ff0ff8d0c6e6cd4e2f807a"}, + {file = "pyzmq-26.0.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:88b88282e55fa39dd556d7fc04160bcf39dea015f78e0cecec8ff4f06c1fc2b5"}, + {file = "pyzmq-26.0.3-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:72b67f966b57dbd18dcc7efbc1c7fc9f5f983e572db1877081f075004614fcdd"}, + {file = "pyzmq-26.0.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:f4b6cecbbf3b7380f3b61de3a7b93cb721125dc125c854c14ddc91225ba52f83"}, + {file = "pyzmq-26.0.3-cp311-cp311-win32.whl", hash = "sha256:eed56b6a39216d31ff8cd2f1d048b5bf1700e4b32a01b14379c3b6dde9ce3aa3"}, + {file = "pyzmq-26.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:3191d312c73e3cfd0f0afdf51df8405aafeb0bad71e7ed8f68b24b63c4f36500"}, + {file = "pyzmq-26.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:b6907da3017ef55139cf0e417c5123a84c7332520e73a6902ff1f79046cd3b94"}, + {file = "pyzmq-26.0.3-cp312-cp312-macosx_10_15_universal2.whl", hash = "sha256:068ca17214038ae986d68f4a7021f97e187ed278ab6dccb79f837d765a54d753"}, + {file = "pyzmq-26.0.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:7821d44fe07335bea256b9f1f41474a642ca55fa671dfd9f00af8d68a920c2d4"}, + {file = "pyzmq-26.0.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eeb438a26d87c123bb318e5f2b3d86a36060b01f22fbdffd8cf247d52f7c9a2b"}, + {file = "pyzmq-26.0.3-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:69ea9d6d9baa25a4dc9cef5e2b77b8537827b122214f210dd925132e34ae9b12"}, + {file = "pyzmq-26.0.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7daa3e1369355766dea11f1d8ef829905c3b9da886ea3152788dc25ee6079e02"}, + {file = "pyzmq-26.0.3-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:6ca7a9a06b52d0e38ccf6bca1aeff7be178917893f3883f37b75589d42c4ac20"}, + {file = "pyzmq-26.0.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:1b7d0e124948daa4d9686d421ef5087c0516bc6179fdcf8828b8444f8e461a77"}, + {file = "pyzmq-26.0.3-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:e746524418b70f38550f2190eeee834db8850088c834d4c8406fbb9bc1ae10b2"}, + {file = "pyzmq-26.0.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:6b3146f9ae6af82c47a5282ac8803523d381b3b21caeae0327ed2f7ecb718798"}, + {file = "pyzmq-26.0.3-cp312-cp312-win32.whl", hash = "sha256:2b291d1230845871c00c8462c50565a9cd6026fe1228e77ca934470bb7d70ea0"}, + {file = "pyzmq-26.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:926838a535c2c1ea21c903f909a9a54e675c2126728c21381a94ddf37c3cbddf"}, + {file = "pyzmq-26.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:5bf6c237f8c681dfb91b17f8435b2735951f0d1fad10cc5dfd96db110243370b"}, + {file = "pyzmq-26.0.3-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:0c0991f5a96a8e620f7691e61178cd8f457b49e17b7d9cfa2067e2a0a89fc1d5"}, + {file = "pyzmq-26.0.3-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:dbf012d8fcb9f2cf0643b65df3b355fdd74fc0035d70bb5c845e9e30a3a4654b"}, + {file = "pyzmq-26.0.3-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:01fbfbeb8249a68d257f601deb50c70c929dc2dfe683b754659569e502fbd3aa"}, + {file = "pyzmq-26.0.3-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c8eb19abe87029c18f226d42b8a2c9efdd139d08f8bf6e085dd9075446db450"}, + {file = "pyzmq-26.0.3-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:5344b896e79800af86ad643408ca9aa303a017f6ebff8cee5a3163c1e9aec987"}, + {file = "pyzmq-26.0.3-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:204e0f176fd1d067671157d049466869b3ae1fc51e354708b0dc41cf94e23a3a"}, + {file = "pyzmq-26.0.3-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:a42db008d58530efa3b881eeee4991146de0b790e095f7ae43ba5cc612decbc5"}, + {file = "pyzmq-26.0.3-cp37-cp37m-win32.whl", hash = "sha256:8d7a498671ca87e32b54cb47c82a92b40130a26c5197d392720a1bce1b3c77cf"}, + {file = "pyzmq-26.0.3-cp37-cp37m-win_amd64.whl", hash = "sha256:3b4032a96410bdc760061b14ed6a33613ffb7f702181ba999df5d16fb96ba16a"}, + {file = "pyzmq-26.0.3-cp38-cp38-macosx_10_15_universal2.whl", hash = "sha256:2cc4e280098c1b192c42a849de8de2c8e0f3a84086a76ec5b07bfee29bda7d18"}, + {file = "pyzmq-26.0.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:5bde86a2ed3ce587fa2b207424ce15b9a83a9fa14422dcc1c5356a13aed3df9d"}, + {file = "pyzmq-26.0.3-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:34106f68e20e6ff253c9f596ea50397dbd8699828d55e8fa18bd4323d8d966e6"}, + {file = "pyzmq-26.0.3-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ebbbd0e728af5db9b04e56389e2299a57ea8b9dd15c9759153ee2455b32be6ad"}, + {file = "pyzmq-26.0.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f6b1d1c631e5940cac5a0b22c5379c86e8df6a4ec277c7a856b714021ab6cfad"}, + {file = "pyzmq-26.0.3-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:e891ce81edd463b3b4c3b885c5603c00141151dd9c6936d98a680c8c72fe5c67"}, + {file = "pyzmq-26.0.3-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:9b273ecfbc590a1b98f014ae41e5cf723932f3b53ba9367cfb676f838038b32c"}, + {file = "pyzmq-26.0.3-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:b32bff85fb02a75ea0b68f21e2412255b5731f3f389ed9aecc13a6752f58ac97"}, + {file = "pyzmq-26.0.3-cp38-cp38-win32.whl", hash = "sha256:f6c21c00478a7bea93caaaef9e7629145d4153b15a8653e8bb4609d4bc70dbfc"}, + {file = "pyzmq-26.0.3-cp38-cp38-win_amd64.whl", hash = "sha256:3401613148d93ef0fd9aabdbddb212de3db7a4475367f49f590c837355343972"}, + {file = "pyzmq-26.0.3-cp39-cp39-macosx_10_15_universal2.whl", hash = "sha256:2ed8357f4c6e0daa4f3baf31832df8a33334e0fe5b020a61bc8b345a3db7a606"}, + {file = "pyzmq-26.0.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:c1c8f2a2ca45292084c75bb6d3a25545cff0ed931ed228d3a1810ae3758f975f"}, + {file = "pyzmq-26.0.3-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:b63731993cdddcc8e087c64e9cf003f909262b359110070183d7f3025d1c56b5"}, + {file = "pyzmq-26.0.3-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:b3cd31f859b662ac5d7f4226ec7d8bd60384fa037fc02aee6ff0b53ba29a3ba8"}, + {file = "pyzmq-26.0.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:115f8359402fa527cf47708d6f8a0f8234f0e9ca0cab7c18c9c189c194dbf620"}, + {file = "pyzmq-26.0.3-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:715bdf952b9533ba13dfcf1f431a8f49e63cecc31d91d007bc1deb914f47d0e4"}, + {file = "pyzmq-26.0.3-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:e1258c639e00bf5e8a522fec6c3eaa3e30cf1c23a2f21a586be7e04d50c9acab"}, + {file = "pyzmq-26.0.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:15c59e780be8f30a60816a9adab900c12a58d79c1ac742b4a8df044ab2a6d920"}, + {file = "pyzmq-26.0.3-cp39-cp39-win32.whl", hash = "sha256:d0cdde3c78d8ab5b46595054e5def32a755fc028685add5ddc7403e9f6de9879"}, + {file = "pyzmq-26.0.3-cp39-cp39-win_amd64.whl", hash = "sha256:ce828058d482ef860746bf532822842e0ff484e27f540ef5c813d516dd8896d2"}, + {file = "pyzmq-26.0.3-cp39-cp39-win_arm64.whl", hash = "sha256:788f15721c64109cf720791714dc14afd0f449d63f3a5487724f024345067381"}, + {file = "pyzmq-26.0.3-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:2c18645ef6294d99b256806e34653e86236eb266278c8ec8112622b61db255de"}, + {file = "pyzmq-26.0.3-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7e6bc96ebe49604df3ec2c6389cc3876cabe475e6bfc84ced1bf4e630662cb35"}, + {file = "pyzmq-26.0.3-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:971e8990c5cc4ddcff26e149398fc7b0f6a042306e82500f5e8db3b10ce69f84"}, + {file = "pyzmq-26.0.3-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d8416c23161abd94cc7da80c734ad7c9f5dbebdadfdaa77dad78244457448223"}, + {file = "pyzmq-26.0.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:082a2988364b60bb5de809373098361cf1dbb239623e39e46cb18bc035ed9c0c"}, + {file = "pyzmq-26.0.3-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:d57dfbf9737763b3a60d26e6800e02e04284926329aee8fb01049635e957fe81"}, + {file = "pyzmq-26.0.3-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:77a85dca4c2430ac04dc2a2185c2deb3858a34fe7f403d0a946fa56970cf60a1"}, + {file = "pyzmq-26.0.3-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:4c82a6d952a1d555bf4be42b6532927d2a5686dd3c3e280e5f63225ab47ac1f5"}, + {file = "pyzmq-26.0.3-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4496b1282c70c442809fc1b151977c3d967bfb33e4e17cedbf226d97de18f709"}, + {file = "pyzmq-26.0.3-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:e4946d6bdb7ba972dfda282f9127e5756d4f299028b1566d1245fa0d438847e6"}, + {file = "pyzmq-26.0.3-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:03c0ae165e700364b266876d712acb1ac02693acd920afa67da2ebb91a0b3c09"}, + {file = "pyzmq-26.0.3-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:3e3070e680f79887d60feeda051a58d0ac36622e1759f305a41059eff62c6da7"}, + {file = "pyzmq-26.0.3-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:6ca08b840fe95d1c2bd9ab92dac5685f949fc6f9ae820ec16193e5ddf603c3b2"}, + {file = "pyzmq-26.0.3-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e76654e9dbfb835b3518f9938e565c7806976c07b37c33526b574cc1a1050480"}, + {file = "pyzmq-26.0.3-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:871587bdadd1075b112e697173e946a07d722459d20716ceb3d1bd6c64bd08ce"}, + {file = "pyzmq-26.0.3-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:d0a2d1bd63a4ad79483049b26514e70fa618ce6115220da9efdff63688808b17"}, + {file = "pyzmq-26.0.3-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0270b49b6847f0d106d64b5086e9ad5dc8a902413b5dbbb15d12b60f9c1747a4"}, + {file = "pyzmq-26.0.3-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:703c60b9910488d3d0954ca585c34f541e506a091a41930e663a098d3b794c67"}, + {file = "pyzmq-26.0.3-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:74423631b6be371edfbf7eabb02ab995c2563fee60a80a30829176842e71722a"}, + {file = "pyzmq-26.0.3-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:4adfbb5451196842a88fda3612e2c0414134874bffb1c2ce83ab4242ec9e027d"}, + {file = "pyzmq-26.0.3-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:3516119f4f9b8671083a70b6afaa0a070f5683e431ab3dc26e9215620d7ca1ad"}, + {file = "pyzmq-26.0.3.tar.gz", hash = "sha256:dba7d9f2e047dfa2bca3b01f4f84aa5246725203d6284e3790f2ca15fba6b40a"}, +] + +[package.dependencies] +cffi = {version = "*", markers = "implementation_name == \"pypy\""} + [[package]] name = "redis" version = "5.0.1" @@ -2188,26 +3809,66 @@ async-timeout = {version = ">=4.0.2", markers = "python_full_version <= \"3.11.2 hiredis = ["hiredis (>=1.0.0)"] ocsp = ["cryptography (>=36.0.1)", "pyopenssl (==20.0.1)", "requests (>=2.26.0)"] +[[package]] +name = "referencing" +version = "0.35.1" +description = "JSON Referencing + Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "referencing-0.35.1-py3-none-any.whl", hash = "sha256:eda6d3234d62814d1c64e305c1331c9a3a6132da475ab6382eaa997b21ee75de"}, + {file = "referencing-0.35.1.tar.gz", hash = "sha256:25b42124a6c8b632a425174f24087783efb348a6f1e0008e63cd4466fedf703c"}, +] + +[package.dependencies] +attrs = ">=22.2.0" +rpds-py = ">=0.7.0" + [[package]] name = "requests" -version = "2.23.0" +version = "2.31.0" description = "Python HTTP for Humans." optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +python-versions = ">=3.7" files = [ - {file = "requests-2.23.0-py2.py3-none-any.whl", hash = "sha256:43999036bfa82904b6af1d99e4882b560e5e2c68e5c4b0aa03b655f3d7d73fee"}, - {file = "requests-2.23.0.tar.gz", hash = "sha256:b3f43d496c6daba4493e7c431722aeb7dbc6288f52a6e04e7b6023b0247817e6"}, + {file = "requests-2.31.0-py3-none-any.whl", hash = "sha256:58cd2187c01e70e6e26505bca751777aa9f2ee0b7f4300988b709f44e013003f"}, + {file = "requests-2.31.0.tar.gz", hash = "sha256:942c5a758f98d790eaed1a29cb6eefc7ffb0d1cf7af05c3d2791656dbd6ad1e1"}, ] [package.dependencies] certifi = ">=2017.4.17" -chardet = ">=3.0.2,<4" -idna = ">=2.5,<3" -urllib3 = ">=1.21.1,<1.25.0 || >1.25.0,<1.25.1 || >1.25.1,<1.26" +charset-normalizer = ">=2,<4" +idna = ">=2.5,<4" +urllib3 = ">=1.21.1,<3" [package.extras] -security = ["cryptography (>=1.3.4)", "pyOpenSSL (>=0.14)"] -socks = ["PySocks (>=1.5.6,!=1.5.7)", "win-inet-pton"] +socks = ["PySocks (>=1.5.6,!=1.5.7)"] +use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"] + +[[package]] +name = "rfc3339-validator" +version = "0.1.4" +description = "A pure python RFC3339 validator" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +files = [ + {file = "rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa"}, + {file = "rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b"}, +] + +[package.dependencies] +six = "*" + +[[package]] +name = "rfc3986-validator" +version = "0.1.1" +description = "Pure python rfc3986 validator" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +files = [ + {file = "rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9"}, + {file = "rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055"}, +] [[package]] name = "rich" @@ -2227,6 +3888,114 @@ pygments = ">=2.13.0,<3.0.0" [package.extras] jupyter = ["ipywidgets (>=7.5.1,<9)"] +[[package]] +name = "rpds-py" +version = "0.18.1" +description = "Python bindings to Rust's persistent data structures (rpds)" +optional = false +python-versions = ">=3.8" +files = [ + {file = "rpds_py-0.18.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:d31dea506d718693b6b2cffc0648a8929bdc51c70a311b2770f09611caa10d53"}, + {file = "rpds_py-0.18.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:732672fbc449bab754e0b15356c077cc31566df874964d4801ab14f71951ea80"}, + {file = "rpds_py-0.18.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4a98a1f0552b5f227a3d6422dbd61bc6f30db170939bd87ed14f3c339aa6c7c9"}, + {file = "rpds_py-0.18.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7f1944ce16401aad1e3f7d312247b3d5de7981f634dc9dfe90da72b87d37887d"}, + {file = "rpds_py-0.18.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:38e14fb4e370885c4ecd734f093a2225ee52dc384b86fa55fe3f74638b2cfb09"}, + {file = "rpds_py-0.18.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:08d74b184f9ab6289b87b19fe6a6d1a97fbfea84b8a3e745e87a5de3029bf944"}, + {file = "rpds_py-0.18.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d70129cef4a8d979caa37e7fe957202e7eee8ea02c5e16455bc9808a59c6b2f0"}, + {file = "rpds_py-0.18.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ce0bb20e3a11bd04461324a6a798af34d503f8d6f1aa3d2aa8901ceaf039176d"}, + {file = "rpds_py-0.18.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:81c5196a790032e0fc2464c0b4ab95f8610f96f1f2fa3d4deacce6a79852da60"}, + {file = "rpds_py-0.18.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:f3027be483868c99b4985fda802a57a67fdf30c5d9a50338d9db646d590198da"}, + {file = "rpds_py-0.18.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:d44607f98caa2961bab4fa3c4309724b185b464cdc3ba6f3d7340bac3ec97cc1"}, + {file = "rpds_py-0.18.1-cp310-none-win32.whl", hash = "sha256:c273e795e7a0f1fddd46e1e3cb8be15634c29ae8ff31c196debb620e1edb9333"}, + {file = "rpds_py-0.18.1-cp310-none-win_amd64.whl", hash = "sha256:8352f48d511de5f973e4f2f9412736d7dea76c69faa6d36bcf885b50c758ab9a"}, + {file = "rpds_py-0.18.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:6b5ff7e1d63a8281654b5e2896d7f08799378e594f09cf3674e832ecaf396ce8"}, + {file = "rpds_py-0.18.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8927638a4d4137a289e41d0fd631551e89fa346d6dbcfc31ad627557d03ceb6d"}, + {file = "rpds_py-0.18.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:154bf5c93d79558b44e5b50cc354aa0459e518e83677791e6adb0b039b7aa6a7"}, + {file = "rpds_py-0.18.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:07f2139741e5deb2c5154a7b9629bc5aa48c766b643c1a6750d16f865a82c5fc"}, + {file = "rpds_py-0.18.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8c7672e9fba7425f79019db9945b16e308ed8bc89348c23d955c8c0540da0a07"}, + {file = "rpds_py-0.18.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:489bdfe1abd0406eba6b3bb4fdc87c7fa40f1031de073d0cfb744634cc8fa261"}, + {file = "rpds_py-0.18.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3c20f05e8e3d4fc76875fc9cb8cf24b90a63f5a1b4c5b9273f0e8225e169b100"}, + {file = "rpds_py-0.18.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:967342e045564cef76dfcf1edb700b1e20838d83b1aa02ab313e6a497cf923b8"}, + {file = "rpds_py-0.18.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2cc7c1a47f3a63282ab0f422d90ddac4aa3034e39fc66a559ab93041e6505da7"}, + {file = "rpds_py-0.18.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f7afbfee1157e0f9376c00bb232e80a60e59ed716e3211a80cb8506550671e6e"}, + {file = "rpds_py-0.18.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9e6934d70dc50f9f8ea47081ceafdec09245fd9f6032669c3b45705dea096b88"}, + {file = "rpds_py-0.18.1-cp311-none-win32.whl", hash = "sha256:c69882964516dc143083d3795cb508e806b09fc3800fd0d4cddc1df6c36e76bb"}, + {file = "rpds_py-0.18.1-cp311-none-win_amd64.whl", hash = "sha256:70a838f7754483bcdc830444952fd89645569e7452e3226de4a613a4c1793fb2"}, + {file = "rpds_py-0.18.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3dd3cd86e1db5aadd334e011eba4e29d37a104b403e8ca24dcd6703c68ca55b3"}, + {file = "rpds_py-0.18.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:05f3d615099bd9b13ecf2fc9cf2d839ad3f20239c678f461c753e93755d629ee"}, + {file = "rpds_py-0.18.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:35b2b771b13eee8729a5049c976197ff58a27a3829c018a04341bcf1ae409b2b"}, + {file = "rpds_py-0.18.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ee17cd26b97d537af8f33635ef38be873073d516fd425e80559f4585a7b90c43"}, + {file = "rpds_py-0.18.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b646bf655b135ccf4522ed43d6902af37d3f5dbcf0da66c769a2b3938b9d8184"}, + {file = "rpds_py-0.18.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:19ba472b9606c36716062c023afa2484d1e4220548751bda14f725a7de17b4f6"}, + {file = "rpds_py-0.18.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6e30ac5e329098903262dc5bdd7e2086e0256aa762cc8b744f9e7bf2a427d3f8"}, + {file = "rpds_py-0.18.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d58ad6317d188c43750cb76e9deacf6051d0f884d87dc6518e0280438648a9ac"}, + {file = "rpds_py-0.18.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e1735502458621921cee039c47318cb90b51d532c2766593be6207eec53e5c4c"}, + {file = "rpds_py-0.18.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:f5bab211605d91db0e2995a17b5c6ee5edec1270e46223e513eaa20da20076ac"}, + {file = "rpds_py-0.18.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2fc24a329a717f9e2448f8cd1f960f9dac4e45b6224d60734edeb67499bab03a"}, + {file = "rpds_py-0.18.1-cp312-none-win32.whl", hash = "sha256:1805d5901779662d599d0e2e4159d8a82c0b05faa86ef9222bf974572286b2b6"}, + {file = "rpds_py-0.18.1-cp312-none-win_amd64.whl", hash = "sha256:720edcb916df872d80f80a1cc5ea9058300b97721efda8651efcd938a9c70a72"}, + {file = "rpds_py-0.18.1-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:c827576e2fa017a081346dce87d532a5310241648eb3700af9a571a6e9fc7e74"}, + {file = "rpds_py-0.18.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:aa3679e751408d75a0b4d8d26d6647b6d9326f5e35c00a7ccd82b78ef64f65f8"}, + {file = "rpds_py-0.18.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0abeee75434e2ee2d142d650d1e54ac1f8b01e6e6abdde8ffd6eeac6e9c38e20"}, + {file = "rpds_py-0.18.1-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed402d6153c5d519a0faf1bb69898e97fb31613b49da27a84a13935ea9164dfc"}, + {file = "rpds_py-0.18.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:338dee44b0cef8b70fd2ef54b4e09bb1b97fc6c3a58fea5db6cc083fd9fc2724"}, + {file = "rpds_py-0.18.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7750569d9526199c5b97e5a9f8d96a13300950d910cf04a861d96f4273d5b104"}, + {file = "rpds_py-0.18.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:607345bd5912aacc0c5a63d45a1f73fef29e697884f7e861094e443187c02be5"}, + {file = "rpds_py-0.18.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:207c82978115baa1fd8d706d720b4a4d2b0913df1c78c85ba73fe6c5804505f0"}, + {file = "rpds_py-0.18.1-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:6d1e42d2735d437e7e80bab4d78eb2e459af48c0a46e686ea35f690b93db792d"}, + {file = "rpds_py-0.18.1-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:5463c47c08630007dc0fe99fb480ea4f34a89712410592380425a9b4e1611d8e"}, + {file = "rpds_py-0.18.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:06d218939e1bf2ca50e6b0ec700ffe755e5216a8230ab3e87c059ebb4ea06afc"}, + {file = "rpds_py-0.18.1-cp38-none-win32.whl", hash = "sha256:312fe69b4fe1ffbe76520a7676b1e5ac06ddf7826d764cc10265c3b53f96dbe9"}, + {file = "rpds_py-0.18.1-cp38-none-win_amd64.whl", hash = "sha256:9437ca26784120a279f3137ee080b0e717012c42921eb07861b412340f85bae2"}, + {file = "rpds_py-0.18.1-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:19e515b78c3fc1039dd7da0a33c28c3154458f947f4dc198d3c72db2b6b5dc93"}, + {file = "rpds_py-0.18.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a7b28c5b066bca9a4eb4e2f2663012debe680f097979d880657f00e1c30875a0"}, + {file = "rpds_py-0.18.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:673fdbbf668dd958eff750e500495ef3f611e2ecc209464f661bc82e9838991e"}, + {file = "rpds_py-0.18.1-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d960de62227635d2e61068f42a6cb6aae91a7fe00fca0e3aeed17667c8a34611"}, + {file = "rpds_py-0.18.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:352a88dc7892f1da66b6027af06a2e7e5d53fe05924cc2cfc56495b586a10b72"}, + {file = "rpds_py-0.18.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e0ee01ad8260184db21468a6e1c37afa0529acc12c3a697ee498d3c2c4dcaf3"}, + {file = "rpds_py-0.18.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4c39ad2f512b4041343ea3c7894339e4ca7839ac38ca83d68a832fc8b3748ab"}, + {file = "rpds_py-0.18.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:aaa71ee43a703c321906813bb252f69524f02aa05bf4eec85f0c41d5d62d0f4c"}, + {file = "rpds_py-0.18.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:6cd8098517c64a85e790657e7b1e509b9fe07487fd358e19431cb120f7d96338"}, + {file = "rpds_py-0.18.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:4adec039b8e2928983f885c53b7cc4cda8965b62b6596501a0308d2703f8af1b"}, + {file = "rpds_py-0.18.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:32b7daaa3e9389db3695964ce8e566e3413b0c43e3394c05e4b243a4cd7bef26"}, + {file = "rpds_py-0.18.1-cp39-none-win32.whl", hash = "sha256:2625f03b105328729f9450c8badda34d5243231eef6535f80064d57035738360"}, + {file = "rpds_py-0.18.1-cp39-none-win_amd64.whl", hash = "sha256:bf18932d0003c8c4d51a39f244231986ab23ee057d235a12b2684ea26a353590"}, + {file = "rpds_py-0.18.1-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:cbfbea39ba64f5e53ae2915de36f130588bba71245b418060ec3330ebf85678e"}, + {file = "rpds_py-0.18.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:a3d456ff2a6a4d2adcdf3c1c960a36f4fd2fec6e3b4902a42a384d17cf4e7a65"}, + {file = "rpds_py-0.18.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7700936ef9d006b7ef605dc53aa364da2de5a3aa65516a1f3ce73bf82ecfc7ae"}, + {file = "rpds_py-0.18.1-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:51584acc5916212e1bf45edd17f3a6b05fe0cbb40482d25e619f824dccb679de"}, + {file = "rpds_py-0.18.1-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:942695a206a58d2575033ff1e42b12b2aece98d6003c6bc739fbf33d1773b12f"}, + {file = "rpds_py-0.18.1-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b906b5f58892813e5ba5c6056d6a5ad08f358ba49f046d910ad992196ea61397"}, + {file = "rpds_py-0.18.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f6f8e3fecca256fefc91bb6765a693d96692459d7d4c644660a9fff32e517843"}, + {file = "rpds_py-0.18.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7732770412bab81c5a9f6d20aeb60ae943a9b36dcd990d876a773526468e7163"}, + {file = "rpds_py-0.18.1-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:bd1105b50ede37461c1d51b9698c4f4be6e13e69a908ab7751e3807985fc0346"}, + {file = "rpds_py-0.18.1-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:618916f5535784960f3ecf8111581f4ad31d347c3de66d02e728de460a46303c"}, + {file = "rpds_py-0.18.1-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:17c6d2155e2423f7e79e3bb18151c686d40db42d8645e7977442170c360194d4"}, + {file = "rpds_py-0.18.1-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:6c4c4c3f878df21faf5fac86eda32671c27889e13570645a9eea0a1abdd50922"}, + {file = "rpds_py-0.18.1-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:fab6ce90574645a0d6c58890e9bcaac8d94dff54fb51c69e5522a7358b80ab64"}, + {file = "rpds_py-0.18.1-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:531796fb842b53f2695e94dc338929e9f9dbf473b64710c28af5a160b2a8927d"}, + {file = "rpds_py-0.18.1-pp38-pypy38_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:740884bc62a5e2bbb31e584f5d23b32320fd75d79f916f15a788d527a5e83644"}, + {file = "rpds_py-0.18.1-pp38-pypy38_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:998125738de0158f088aef3cb264a34251908dd2e5d9966774fdab7402edfab7"}, + {file = "rpds_py-0.18.1-pp38-pypy38_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e2be6e9dd4111d5b31ba3b74d17da54a8319d8168890fbaea4b9e5c3de630ae5"}, + {file = "rpds_py-0.18.1-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d0cee71bc618cd93716f3c1bf56653740d2d13ddbd47673efa8bf41435a60daa"}, + {file = "rpds_py-0.18.1-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2c3caec4ec5cd1d18e5dd6ae5194d24ed12785212a90b37f5f7f06b8bedd7139"}, + {file = "rpds_py-0.18.1-pp38-pypy38_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:27bba383e8c5231cd559affe169ca0b96ec78d39909ffd817f28b166d7ddd4d8"}, + {file = "rpds_py-0.18.1-pp38-pypy38_pp73-musllinux_1_2_i686.whl", hash = "sha256:a888e8bdb45916234b99da2d859566f1e8a1d2275a801bb8e4a9644e3c7e7909"}, + {file = "rpds_py-0.18.1-pp38-pypy38_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:6031b25fb1b06327b43d841f33842b383beba399884f8228a6bb3df3088485ff"}, + {file = "rpds_py-0.18.1-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:48c2faaa8adfacefcbfdb5f2e2e7bdad081e5ace8d182e5f4ade971f128e6bb3"}, + {file = "rpds_py-0.18.1-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:d85164315bd68c0806768dc6bb0429c6f95c354f87485ee3593c4f6b14def2bd"}, + {file = "rpds_py-0.18.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6afd80f6c79893cfc0574956f78a0add8c76e3696f2d6a15bca2c66c415cf2d4"}, + {file = "rpds_py-0.18.1-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fa242ac1ff583e4ec7771141606aafc92b361cd90a05c30d93e343a0c2d82a89"}, + {file = "rpds_py-0.18.1-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d21be4770ff4e08698e1e8e0bce06edb6ea0626e7c8f560bc08222880aca6a6f"}, + {file = "rpds_py-0.18.1-pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5c45a639e93a0c5d4b788b2613bd637468edd62f8f95ebc6fcc303d58ab3f0a8"}, + {file = "rpds_py-0.18.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:910e71711d1055b2768181efa0a17537b2622afeb0424116619817007f8a2b10"}, + {file = "rpds_py-0.18.1-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b9bb1f182a97880f6078283b3505a707057c42bf55d8fca604f70dedfdc0772a"}, + {file = "rpds_py-0.18.1-pp39-pypy39_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:1d54f74f40b1f7aaa595a02ff42ef38ca654b1469bef7d52867da474243cc633"}, + {file = "rpds_py-0.18.1-pp39-pypy39_pp73-musllinux_1_2_i686.whl", hash = "sha256:8d2e182c9ee01135e11e9676e9a62dfad791a7a467738f06726872374a83db49"}, + {file = "rpds_py-0.18.1-pp39-pypy39_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:636a15acc588f70fda1661234761f9ed9ad79ebed3f2125d44be0862708b666e"}, + {file = "rpds_py-0.18.1.tar.gz", hash = "sha256:dc48b479d540770c811fbd1eb9ba2bb66951863e448efec2e2c102625328e92f"}, +] + [[package]] name = "ruff" version = "0.2.2" @@ -2253,6 +4022,22 @@ files = [ {file = "ruff-0.2.2.tar.gz", hash = "sha256:e62ed7f36b3068a30ba39193a14274cd706bc486fad521276458022f7bccb31d"}, ] +[[package]] +name = "send2trash" +version = "1.8.3" +description = "Send file to trash natively under Mac OS X, Windows and Linux" +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +files = [ + {file = "Send2Trash-1.8.3-py3-none-any.whl", hash = "sha256:0c31227e0bd08961c7665474a3d1ef7193929fedda4233843689baa056be46c9"}, + {file = "Send2Trash-1.8.3.tar.gz", hash = "sha256:b18e7a3966d99871aefeb00cfbcfdced55ce4871194810fc71f4aa484b953abf"}, +] + +[package.extras] +nativelib = ["pyobjc-framework-Cocoa", "pywin32"] +objc = ["pyobjc-framework-Cocoa"] +win32 = ["pywin32"] + [[package]] name = "service-identity" version = "24.1.0" @@ -2512,6 +4297,25 @@ dev = ["build", "flake8"] doc = ["sphinx"] test = ["pytest", "pytest-cov"] +[[package]] +name = "stack-data" +version = "0.6.3" +description = "Extract data from python stack frames and tracebacks for informative displays" +optional = false +python-versions = "*" +files = [ + {file = "stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695"}, + {file = "stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9"}, +] + +[package.dependencies] +asttokens = ">=2.1.0" +executing = ">=1.2.0" +pure-eval = "*" + +[package.extras] +tests = ["cython", "littleutils", "pygments", "pytest", "typeguard"] + [[package]] name = "starlette" version = "0.36.3" @@ -2552,6 +4356,27 @@ doc = ["mkdocs (>=1.4.2,<2.0.0)", "mkdocs-material (>=9.0.0,<10.0.0)", "mkdocs-s i18n = ["babel (>=2.13.0)"] test = ["aiomysql (>=0.1.1,<0.3.0)", "aiosqlite (>=0.17.0,<0.20.0)", "arrow (>=1.2.3,<1.4.0)", "asyncpg (>=0.27.0,<0.30.0)", "backports-zoneinfo", "black (==24.1.1)", "colour (>=0.1.5,<0.2.0)", "fasteners (==0.19)", "httpx (>=0.23.3,<0.27.0)", "itsdangerous (>=2.1.2,<2.2.0)", "mongoengine (>=0.25.0,<0.28.0)", "mypy (==1.8.0)", "odmantic (>=0.9.0,<0.10.0)", "passlib (>=1.7.4,<1.8.0)", "phonenumbers (>=8.13.3,<8.14.0)", "pillow (>=9.4.0,<9.6.0)", "psycopg2-binary (>=2.9.5,<3.0.0)", "pydantic[email] (>=1.10.2,<2.6.0)", "pymysql[rsa] (>=1.0.2,<1.2.0)", "pytest (>=7.2.0,<7.5.0)", "pytest-asyncio (>=0.20.2,<0.24.0)", "ruff (==0.1.15)", "sqlalchemy-file (>=0.5.0,<0.7.0)", "sqlalchemy-utils (>=0.40.0,<0.42.0)", "sqlmodel (>=0.0.11,<0.15.0)", "tinydb (>=4.7.0,<4.9.0)"] +[[package]] +name = "terminado" +version = "0.18.1" +description = "Tornado websocket backend for the Xterm.js Javascript terminal emulator library." +optional = false +python-versions = ">=3.8" +files = [ + {file = "terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0"}, + {file = "terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e"}, +] + +[package.dependencies] +ptyprocess = {version = "*", markers = "os_name != \"nt\""} +pywinpty = {version = ">=1.1.0", markers = "os_name == \"nt\""} +tornado = ">=6.1.0" + +[package.extras] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"] +test = ["pre-commit", "pytest (>=7.0)", "pytest-timeout"] +typing = ["mypy (>=1.6,<2.0)", "traitlets (>=5.11.1)"] + [[package]] name = "threddsclient" version = "0.4.2" @@ -2567,6 +4392,24 @@ beautifulsoup4 = "*" lxml = "*" requests = "*" +[[package]] +name = "tinycss2" +version = "1.3.0" +description = "A tiny CSS parser" +optional = false +python-versions = ">=3.8" +files = [ + {file = "tinycss2-1.3.0-py3-none-any.whl", hash = "sha256:54a8dbdffb334d536851be0226030e9505965bb2f30f21a4a82c55fb2a80fae7"}, + {file = "tinycss2-1.3.0.tar.gz", hash = "sha256:152f9acabd296a8375fbca5b84c961ff95971fcfc32e79550c8df8e29118c54d"}, +] + +[package.dependencies] +webencodings = ">=0.4" + +[package.extras] +doc = ["sphinx", "sphinx_rtd_theme"] +test = ["pytest", "ruff"] + [[package]] name = "tomli" version = "2.0.1" @@ -2578,6 +4421,41 @@ files = [ {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"}, ] +[[package]] +name = "tornado" +version = "6.4" +description = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed." +optional = false +python-versions = ">= 3.8" +files = [ + {file = "tornado-6.4-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:02ccefc7d8211e5a7f9e8bc3f9e5b0ad6262ba2fbb683a6443ecc804e5224ce0"}, + {file = "tornado-6.4-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:27787de946a9cffd63ce5814c33f734c627a87072ec7eed71f7fc4417bb16263"}, + {file = "tornado-6.4-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f7894c581ecdcf91666a0912f18ce5e757213999e183ebfc2c3fdbf4d5bd764e"}, + {file = "tornado-6.4-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e43bc2e5370a6a8e413e1e1cd0c91bedc5bd62a74a532371042a18ef19e10579"}, + {file = "tornado-6.4-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f0251554cdd50b4b44362f73ad5ba7126fc5b2c2895cc62b14a1c2d7ea32f212"}, + {file = "tornado-6.4-cp38-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:fd03192e287fbd0899dd8f81c6fb9cbbc69194d2074b38f384cb6fa72b80e9c2"}, + {file = "tornado-6.4-cp38-abi3-musllinux_1_1_i686.whl", hash = "sha256:88b84956273fbd73420e6d4b8d5ccbe913c65d31351b4c004ae362eba06e1f78"}, + {file = "tornado-6.4-cp38-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:71ddfc23a0e03ef2df1c1397d859868d158c8276a0603b96cf86892bff58149f"}, + {file = "tornado-6.4-cp38-abi3-win32.whl", hash = "sha256:6f8a6c77900f5ae93d8b4ae1196472d0ccc2775cc1dfdc9e7727889145c45052"}, + {file = "tornado-6.4-cp38-abi3-win_amd64.whl", hash = "sha256:10aeaa8006333433da48dec9fe417877f8bcc21f48dda8d661ae79da357b2a63"}, + {file = "tornado-6.4.tar.gz", hash = "sha256:72291fa6e6bc84e626589f1c29d90a5a6d593ef5ae68052ee2ef000dfd273dee"}, +] + +[[package]] +name = "traitlets" +version = "5.14.3" +description = "Traitlets Python configuration system" +optional = false +python-versions = ">=3.8" +files = [ + {file = "traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f"}, + {file = "traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7"}, +] + +[package.extras] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"] +test = ["argcomplete (>=3.0.3)", "mypy (>=1.7.0)", "pre-commit", "pytest (>=7.0,<8.2)", "pytest-mock", "pytest-mypy-testing"] + [[package]] name = "twisted" version = "23.10.0" @@ -2678,6 +4556,17 @@ rich = ">=10.11.0" shellingham = ">=1.3.0" typing-extensions = ">=3.7.4.3" +[[package]] +name = "types-python-dateutil" +version = "2.9.0.20240316" +description = "Typing stubs for python-dateutil" +optional = false +python-versions = ">=3.8" +files = [ + {file = "types-python-dateutil-2.9.0.20240316.tar.gz", hash = "sha256:5d2f2e240b86905e40944dd787db6da9263f0deabef1076ddaed797351ec0202"}, + {file = "types_python_dateutil-2.9.0.20240316-py3-none-any.whl", hash = "sha256:6b8cb66d960771ce5ff974e9dd45e38facb81718cc1e208b10b1baccbfdbee3b"}, +] + [[package]] name = "typing-extensions" version = "4.9.0" @@ -2689,6 +4578,20 @@ files = [ {file = "typing_extensions-4.9.0.tar.gz", hash = "sha256:23478f88c37f27d76ac8aee6c905017a143b0b1b886c3c9f66bc2fd94f9f5783"}, ] +[[package]] +name = "uri-template" +version = "1.3.0" +description = "RFC 6570 URI Template Processor" +optional = false +python-versions = ">=3.7" +files = [ + {file = "uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7"}, + {file = "uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363"}, +] + +[package.extras] +dev = ["flake8", "flake8-annotations", "flake8-bandit", "flake8-bugbear", "flake8-commas", "flake8-comprehensions", "flake8-continuation", "flake8-datetimez", "flake8-docstrings", "flake8-import-order", "flake8-literal", "flake8-modern-annotations", "flake8-noqa", "flake8-pyproject", "flake8-requirements", "flake8-typechecking-import", "flake8-use-fstring", "mypy", "pep8-naming", "types-PyYAML"] + [[package]] name = "urllib3" version = "1.25.11" @@ -2873,6 +4776,43 @@ files = [ [package.dependencies] anyio = ">=3.0.0" +[[package]] +name = "wcwidth" +version = "0.2.13" +description = "Measures the displayed width of unicode strings in a terminal" +optional = false +python-versions = "*" +files = [ + {file = "wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859"}, + {file = "wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"}, +] + +[[package]] +name = "webcolors" +version = "1.13" +description = "A library for working with the color formats defined by HTML and CSS." +optional = false +python-versions = ">=3.7" +files = [ + {file = "webcolors-1.13-py3-none-any.whl", hash = "sha256:29bc7e8752c0a1bd4a1f03c14d6e6a72e93d82193738fa860cbff59d0fcc11bf"}, + {file = "webcolors-1.13.tar.gz", hash = "sha256:c225b674c83fa923be93d235330ce0300373d02885cef23238813b0d5668304a"}, +] + +[package.extras] +docs = ["furo", "sphinx", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-notfound-page", "sphinxext-opengraph"] +tests = ["pytest", "pytest-cov"] + +[[package]] +name = "webencodings" +version = "0.5.1" +description = "Character encoding aliases for legacy web content" +optional = false +python-versions = "*" +files = [ + {file = "webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78"}, + {file = "webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923"}, +] + [[package]] name = "webob" version = "1.8.7" @@ -2888,6 +4828,22 @@ files = [ docs = ["Sphinx (>=1.7.5)", "pylons-sphinx-themes"] testing = ["coverage", "pytest (>=3.1.0)", "pytest-cov", "pytest-xdist"] +[[package]] +name = "websocket-client" +version = "1.8.0" +description = "WebSocket client for Python with low level API options" +optional = false +python-versions = ">=3.8" +files = [ + {file = "websocket_client-1.8.0-py3-none-any.whl", hash = "sha256:17b44cc997f5c498e809b22cdf2d9c7a9e71c02c8cc2b6c56e7c2d1239bfa526"}, + {file = "websocket_client-1.8.0.tar.gz", hash = "sha256:3239df9f44da632f96012472805d40a23281a991027ce11d2f45a6f24ac4c3da"}, +] + +[package.extras] +docs = ["Sphinx (>=6.0)", "myst-parser (>=2.0.0)", "sphinx-rtd-theme (>=1.1.0)"] +optional = ["python-socks", "wsaccel"] +test = ["websockets"] + [[package]] name = "websockets" version = "12.0" @@ -2969,6 +4925,17 @@ files = [ {file = "websockets-12.0.tar.gz", hash = "sha256:81df9cbcbb6c260de1e007e58c011bfebe2dafc8435107b0537f393dd38c8b1b"}, ] +[[package]] +name = "widgetsnbextension" +version = "4.0.10" +description = "Jupyter interactive widgets for Jupyter Notebook" +optional = false +python-versions = ">=3.7" +files = [ + {file = "widgetsnbextension-4.0.10-py3-none-any.whl", hash = "sha256:d37c3724ec32d8c48400a435ecfa7d3e259995201fbefa37163124a9fcb393cc"}, + {file = "widgetsnbextension-4.0.10.tar.gz", hash = "sha256:64196c5ff3b9a9183a8e699a4227fb0b7002f252c814098e66c4d1cd0644688f"}, +] + [[package]] name = "xmltodict" version = "0.12.0" @@ -3139,4 +5106,4 @@ testing = ["coverage (>=5.0.3)", "zope.event", "zope.testing"] [metadata] lock-version = "2.0" python-versions = "^3.10" -content-hash = "bb1582dd8f9b100eabeead348983f59b12f998dda7301e32b161147316c0f458" +content-hash = "a90606a0cf1980e0d7d775b07392febadc2f550ff35d85b209de1233f79d89b2" diff --git a/pyproject.toml b/pyproject.toml index f63300a6..752d3568 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -34,8 +34,8 @@ xmltodict = "0.12.0" pydap = "3.4.0" threddsclient = "0.4.2" pandas = "1.5.0" -requests = "2.23.0" -python-dateutil = "2.8.1" +requests = "^2.31.0" +python-dateutil = "^2.9.0.post0" pytz = "2020.1" django-redis-sessions = "0.6.1" httpx = "^0.27.0" @@ -54,8 +54,12 @@ starlette-admin = "^0.13.2" itsdangerous = "^2.2.0" jinja2 = "^3.1.4" pyyaml = "^6.0.1" +alembic-postgresql-enum = "^1.2.0" +[tool.poetry.group.dev] +optional = true + [tool.poetry.group.dev.dependencies] pytest = "^8.0.1" coverage = "^7.4.1" @@ -65,6 +69,15 @@ dagger-io = "^0.9.10" ruff = "^0.2.2" pytest-httpx = "^0.30.0" + +[tool.poetry.group.jupyter] +optional = true + +[tool.poetry.group.jupyter.dependencies] +jupyterlab = "^4.2.0" +matplotlib = "^3.8.4" +ipympl = "^0.9.4" + [tool.poetry.scripts] arpav-ppcv = "arpav_ppcv.main:app" diff --git a/tests/test_operations.py b/tests/test_operations.py new file mode 100644 index 00000000..1ff0f56f --- /dev/null +++ b/tests/test_operations.py @@ -0,0 +1,16 @@ +import datetime as dt + +import pytest +from arpav_ppcv import operations + + + +@pytest.mark.parametrize("range, expected", [ + pytest.param("../..", (None, None)), + pytest.param("1982-12-10T01:01:00Z/..", (dt.datetime(1982, 12, 10, 1, 1, 0, tzinfo=dt.timezone.utc), None)), + pytest.param("1982-12-10T01:01:00+01:00/..", (dt.datetime(1982, 12, 10, 0, 1, 0, tzinfo=dt.timezone.utc), None)), + pytest.param("1982-12-10T01:01:00+02:00/..", (dt.datetime(1982, 12, 9, 23, 1, 0, tzinfo=dt.timezone.utc), None)), +]) +def test_parse_temporal_range(range, expected): + result = operations._parse_temporal_range(range) + assert result == expected \ No newline at end of file From 22b9b276278336c100bfb4c46c3d85b3bcb33408 Mon Sep 17 00:00:00 2001 From: Ricardo Garcia Silva Date: Mon, 13 May 2024 20:02:49 +0100 Subject: [PATCH 05/11] Initial implementation of time series endpoint for coverages --- arpav_ppcv/bootstrapper/__init__.py | 0 arpav_ppcv/bootstrapper/cliapp.py | 210 ++++++++++++++++++ ...ee_added_relationship_between_coverage_.py | 37 +++ ..._remove_optional_in_netcdf_dataset_name.py | 35 +++ ...d62c68_add_optional_netcdf_dataset_name.py | 31 +++ 5 files changed, 313 insertions(+) create mode 100644 arpav_ppcv/bootstrapper/__init__.py create mode 100644 arpav_ppcv/bootstrapper/cliapp.py create mode 100644 arpav_ppcv/migrations/versions/4ee22416b0ee_added_relationship_between_coverage_.py create mode 100644 arpav_ppcv/migrations/versions/9f2dedc5396e_remove_optional_in_netcdf_dataset_name.py create mode 100644 arpav_ppcv/migrations/versions/e3296ad62c68_add_optional_netcdf_dataset_name.py diff --git a/arpav_ppcv/bootstrapper/__init__.py b/arpav_ppcv/bootstrapper/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/arpav_ppcv/bootstrapper/cliapp.py b/arpav_ppcv/bootstrapper/cliapp.py new file mode 100644 index 00000000..e195c61b --- /dev/null +++ b/arpav_ppcv/bootstrapper/cliapp.py @@ -0,0 +1,210 @@ +import typer + +import sqlmodel +from rich import print +from sqlalchemy.exc import IntegrityError + +from .. import database +from ..schemas import ( + coverages, + observations, +) + +app = typer.Typer() + + +@app.command("observation-variables") +def bootstrap_observation_variables( + ctx: typer.Context, +): + """Create initial observation variables.""" + variables = [ + observations.VariableCreate( + name="TDd", + description="Mean temperature", + unit="ºC" + ), + observations.VariableCreate( + name="TXd", + description="Max temperature", + unit="ºC" + ), + observations.VariableCreate( + name="TNd", + description="Min temperature", + unit="ºC" + ), + observations.VariableCreate( + name="PRCPTOT", + description="Total precipitation", + unit="mm" + ), + observations.VariableCreate( + name="TR", + description="Tropical nights", + unit="mm" + ), + observations.VariableCreate( + name="SU30", + description="Hot days", + unit="mm" + ), + observations.VariableCreate( + name="FD", + description="Cold days", + unit="mm" + ), + ] + with sqlmodel.Session(ctx.obj["engine"]) as session: + for var_create in variables: + try: + db_variable = database.create_variable(session, var_create) + print(f"Created observation variable {db_variable.name!r}") + except IntegrityError as err: + print( + f"Could not create observation " + f"variable {var_create.name!r}: {err}" + ) + session.rollback() + print("Done!") + + +@app.command("coverage-configuration-parameters") +def bootstrap_coverage_configuration_parameters( + ctx: typer.Context, +): + """Create initial coverage configuration parameters.""" + params = [ + coverages.ConfigurationParameterCreate( + name="scenario", + description=( + "Represents the path fragment related to forecast model scenario" + ), + allowed_values=[ + coverages.ConfigurationParameterValueCreateEmbeddedInConfigurationParameter( + name="rcp26", + description="Represents the RCP2.6 scenario" + ), + coverages.ConfigurationParameterValueCreateEmbeddedInConfigurationParameter( + name="rcp45", + description="Represents the RCP4.5 scenario" + ), + coverages.ConfigurationParameterValueCreateEmbeddedInConfigurationParameter( + name="rcp85", + description="Represents the RCP8.5 scenario" + ), + ] + ), + coverages.ConfigurationParameterCreate( + name="time_window", + description=( + "Represents the path fragment related to forecast model time window" + ), + allowed_values=[ + coverages.ConfigurationParameterValueCreateEmbeddedInConfigurationParameter( + name="tw1", + description="Represents the first time window, which spans the period 2021-2050" + ), + coverages.ConfigurationParameterValueCreateEmbeddedInConfigurationParameter( + name="tw2", + description="Represents the second time window, which spans the period 2071-2100" + ), + ] + ), + coverages.ConfigurationParameterCreate( + name="year_period", + description=( + "Represents the yearly temporal aggregation period in file paths" + ), + allowed_values=[ + coverages.ConfigurationParameterValueCreateEmbeddedInConfigurationParameter( + name="DJF", + description="Represents the winter season (December, January, February)" + ), + coverages.ConfigurationParameterValueCreateEmbeddedInConfigurationParameter( + name="MAM", + description="Represents the spring season (March, April, May)" + ), + coverages.ConfigurationParameterValueCreateEmbeddedInConfigurationParameter( + name="JJA", + description="Represents the summer season (June, July, August)" + ), + coverages.ConfigurationParameterValueCreateEmbeddedInConfigurationParameter( + name="SON", + description="Represents the autumn season (September, October, November)" + ), + ] + ), + ] + with sqlmodel.Session(ctx.obj["engine"]) as session: + for param_create in params: + try: + db_param = database.create_configuration_parameter( + session, param_create) + print(f"Created configuration parameter {db_param.name!r}") + except IntegrityError as err: + print( + f"Could not create configuration parameter " + f"{param_create.name!r}: {err}" + ) + session.rollback() + print("Done!") + + +@app.command("coverage-configurations") +def bootstrap_coverage_configurations( + ctx: typer.Context, +): + """Create initial coverage configurations.""" + with sqlmodel.Session(ctx.obj["engine"]) as session: + all_vars = database.collect_all_variables(session) + all_conf_param_values = database.collect_all_configuration_parameter_values(session) + variables = {v.name: v for v in all_vars} + conf_param_values = {(pv.configuration_parameter.name, pv.name): pv for pv in all_conf_param_values} + coverage_configurations = [ + coverages.CoverageConfigurationCreate( + name="tas_absolute", + netcdf_main_dataset_name="tas", + thredds_url_pattern="ensymbc/tas_avg_{scenario}_{year_period}_ts19762100_ls.nc", + unit="ºC", + palette="default/seq-YlOrRd", + color_scale_min=-3.0, + color_scale_max=32.0, + possible_values=[ + coverages.ConfigurationParameterPossibleValueCreate( + configuration_parameter_value_id=conf_param_values[("scenario", "rcp26")].id + ), + coverages.ConfigurationParameterPossibleValueCreate( + configuration_parameter_value_id=conf_param_values[("scenario", "rcp45")].id + ), + coverages.ConfigurationParameterPossibleValueCreate( + configuration_parameter_value_id=conf_param_values[("scenario", "rcp85")].id + ), + coverages.ConfigurationParameterPossibleValueCreate( + configuration_parameter_value_id=conf_param_values[("year_period", "DJF")].id + ), + coverages.ConfigurationParameterPossibleValueCreate( + configuration_parameter_value_id=conf_param_values[("year_period", "MAM")].id + ), + coverages.ConfigurationParameterPossibleValueCreate( + configuration_parameter_value_id=conf_param_values[("year_period", "JJA")].id + ), + coverages.ConfigurationParameterPossibleValueCreate( + configuration_parameter_value_id=conf_param_values[("year_period", "SON")].id + ), + ], + observation_variable_id=v.id if (v := variables.get("TDd")) is not None else None, + observation_variable_aggregation_type=coverages.ObservationAggregationType.SEASONAL + ), + ] + for cov_conf_create in coverage_configurations: + try: + db_cov_conf = database.create_coverage_configuration( + session, cov_conf_create) + print(f"Created coverage configuration {db_cov_conf.name!r}") + except IntegrityError as err: + print( + f"Could not create coverage configuration " + f"{cov_conf_create.name!r}: {err}" + ) + session.rollback() diff --git a/arpav_ppcv/migrations/versions/4ee22416b0ee_added_relationship_between_coverage_.py b/arpav_ppcv/migrations/versions/4ee22416b0ee_added_relationship_between_coverage_.py new file mode 100644 index 00000000..d3227dc7 --- /dev/null +++ b/arpav_ppcv/migrations/versions/4ee22416b0ee_added_relationship_between_coverage_.py @@ -0,0 +1,37 @@ +"""added relationship between coverage conf and observation + +Revision ID: 4ee22416b0ee +Revises: 7a6e61611951 +Create Date: 2024-05-13 10:34:16.297450 + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa +import sqlmodel +from sqlalchemy.dialects import postgresql + +# revision identifiers, used by Alembic. +revision: str = '4ee22416b0ee' +down_revision: Union[str, None] = '7a6e61611951' +branch_labels: Union[str, Sequence[str], None] = None +depends_on: Union[str, Sequence[str], None] = None + + +def upgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + sa.Enum('MONTHLY', 'SEASONAL', 'YEARLY', name='observationaggregationtype').create(op.get_bind()) + op.add_column('coverageconfiguration', sa.Column('observation_variable_id', sqlmodel.sql.sqltypes.GUID(), nullable=True)) + op.add_column('coverageconfiguration', sa.Column('observation_variable_aggregation_type', postgresql.ENUM('MONTHLY', 'SEASONAL', 'YEARLY', name='observationaggregationtype', create_type=False), nullable=True)) + op.create_foreign_key(None, 'coverageconfiguration', 'variable', ['observation_variable_id'], ['id']) + # ### end Alembic commands ### + + +def downgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.drop_constraint(None, 'coverageconfiguration', type_='foreignkey') + op.drop_column('coverageconfiguration', 'observation_variable_aggregation_type') + op.drop_column('coverageconfiguration', 'observation_variable_id') + sa.Enum('MONTHLY', 'SEASONAL', 'YEARLY', name='observationaggregationtype').drop(op.get_bind()) + # ### end Alembic commands ### diff --git a/arpav_ppcv/migrations/versions/9f2dedc5396e_remove_optional_in_netcdf_dataset_name.py b/arpav_ppcv/migrations/versions/9f2dedc5396e_remove_optional_in_netcdf_dataset_name.py new file mode 100644 index 00000000..d5668f9c --- /dev/null +++ b/arpav_ppcv/migrations/versions/9f2dedc5396e_remove_optional_in_netcdf_dataset_name.py @@ -0,0 +1,35 @@ +"""remove optional in netcdf dataset name + +Revision ID: 9f2dedc5396e +Revises: e3296ad62c68 +Create Date: 2024-05-13 10:39:39.838577 + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa +import sqlmodel + + +# revision identifiers, used by Alembic. +revision: str = '9f2dedc5396e' +down_revision: Union[str, None] = 'e3296ad62c68' +branch_labels: Union[str, Sequence[str], None] = None +depends_on: Union[str, Sequence[str], None] = None + + +def upgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.alter_column('coverageconfiguration', 'netcdf_main_dataset_name', + existing_type=sa.VARCHAR(), + nullable=False) + # ### end Alembic commands ### + + +def downgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.alter_column('coverageconfiguration', 'netcdf_main_dataset_name', + existing_type=sa.VARCHAR(), + nullable=True) + # ### end Alembic commands ### diff --git a/arpav_ppcv/migrations/versions/e3296ad62c68_add_optional_netcdf_dataset_name.py b/arpav_ppcv/migrations/versions/e3296ad62c68_add_optional_netcdf_dataset_name.py new file mode 100644 index 00000000..97456ba9 --- /dev/null +++ b/arpav_ppcv/migrations/versions/e3296ad62c68_add_optional_netcdf_dataset_name.py @@ -0,0 +1,31 @@ +"""add optional netcdf dataset name + +Revision ID: e3296ad62c68 +Revises: 4ee22416b0ee +Create Date: 2024-05-13 10:35:11.553196 + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa +import sqlmodel + + +# revision identifiers, used by Alembic. +revision: str = 'e3296ad62c68' +down_revision: Union[str, None] = '4ee22416b0ee' +branch_labels: Union[str, Sequence[str], None] = None +depends_on: Union[str, Sequence[str], None] = None + + +def upgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.add_column('coverageconfiguration', sa.Column('netcdf_main_dataset_name', sqlmodel.sql.sqltypes.AutoString(), nullable=True)) + # ### end Alembic commands ### + + +def downgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.drop_column('coverageconfiguration', 'netcdf_main_dataset_name') + # ### end Alembic commands ### From d5913a0d49a86ace41417fe9206e4b99a9dba9a5 Mon Sep 17 00:00:00 2001 From: Ricardo Garcia Silva Date: Mon, 13 May 2024 21:28:11 +0100 Subject: [PATCH 06/11] Adding station data to time series queries for forecast models --- arpav_ppcv/database.py | 5 +- arpav_ppcv/operations.py | 140 +++++++++++++++--- arpav_ppcv/schemas/base.py | 22 +++ arpav_ppcv/schemas/coverages.py | 45 ++++-- arpav_ppcv/schemas/observations.py | 30 ++-- arpav_ppcv/webapp/admin/schemas.py | 2 +- arpav_ppcv/webapp/admin/views.py | 17 ++- arpav_ppcv/webapp/api_v2/routers/coverages.py | 7 +- .../webapp/api_v2/routers/observations.py | 4 +- .../webapp/api_v2/schemas/observations.py | 3 +- 10 files changed, 212 insertions(+), 63 deletions(-) diff --git a/arpav_ppcv/database.py b/arpav_ppcv/database.py index ebda37b7..ec733228 100644 --- a/arpav_ppcv/database.py +++ b/arpav_ppcv/database.py @@ -18,6 +18,7 @@ from . import config from .schemas import ( + base, coverages, observations, ) @@ -458,7 +459,7 @@ def list_seasonal_measurements( offset: int = 0, station_id_filter: Optional[uuid.UUID] = None, variable_id_filter: Optional[uuid.UUID] = None, - season_filter: Optional[observations.Season] = None, + season_filter: Optional[base.Season] = None, include_total: bool = False, ) -> tuple[Sequence[observations.SeasonalMeasurement], Optional[int]]: """List existing seasonal measurements.""" @@ -484,7 +485,7 @@ def collect_all_seasonal_measurements( *, station_id_filter: Optional[uuid.UUID] = None, variable_id_filter: Optional[uuid.UUID] = None, - season_filter: Optional[observations.Season] = None, + season_filter: Optional[base.Season] = None, ) -> Sequence[observations.SeasonalMeasurement]: _, num_total = list_seasonal_measurements( session, diff --git a/arpav_ppcv/operations.py b/arpav_ppcv/operations.py index 28419077..65a2ccb7 100644 --- a/arpav_ppcv/operations.py +++ b/arpav_ppcv/operations.py @@ -1,6 +1,7 @@ import datetime as dt import functools import io +import logging from typing import Optional import httpx @@ -15,13 +16,16 @@ from shapely.ops import transform from . import database +from .config import ArpavPpcvSettings from .schemas import ( + base, coverages, observations, ) -from .config import ArpavPpcvSettings from .thredds import ncss +logger = logging.getLogger(__name__) + def get_coverage_time_series( settings: ArpavPpcvSettings, @@ -33,20 +37,20 @@ def get_coverage_time_series( temporal_range: str, include_coverage_data: bool = True, include_observation_data: bool = False, - coverage_data_smoothing: coverages.CoverageDataSmoothingStrategy | None = None, - observation_data_smoothing: observations.ObservationDataSmoothingStrategy | None = None, + coverage_data_smoothing: base.CoverageDataSmoothingStrategy | None = None, + observation_data_smoothing: base.ObservationDataSmoothingStrategy | None = None, include_coverage_uncertainty: bool = False, include_coverage_related_data: bool = False, ) -> dict[str, pd.DataFrame]: start, end = _parse_temporal_range(temporal_range) - ncss_url = "/".join(( + coverage_data_ncss_url = "/".join(( settings.thredds_server.base_url, settings.thredds_server.netcdf_subset_service_url_fragment, coverage_configuration.get_thredds_url_fragment(coverage_identifier) )) raw_coverage_data = ncss.query_dataset( http_client, - thredds_ncss_url=ncss_url, + thredds_ncss_url=coverage_data_ncss_url, variable_name=coverage_configuration.netcdf_main_dataset_name, longitude=point_geom.x, latitude=point_geom.y, @@ -65,33 +69,125 @@ def get_coverage_time_series( ) measurements[coverage_configuration.name] = coverage_data if include_observation_data: - point_buffer_geom = _get_spatial_buffer( - point_geom, settings.nearest_station_radius_meters) - nearby_stations = database.collect_all_stations( - session, polygon_intersection_filter=point_buffer_geom) - if len(nearby_stations) > 0: - sorted_stations = sorted( - nearby_stations, key=lambda s: to_shape(s.geom).distance(point_geom)) - # order nearby stations by distance and then iterate through them in order to - # try to get measurements for the relevant variable and temporal aggregation - for station in sorted_stations: - ... - else: - ... + station_data = _get_station_data( + session, + settings, + point_geom, + coverage_configuration, + coverage_identifier, + ) + if station_data is not None: + raw_station_data, station = station_data + data_ = _process_station_data( + raw_station_data, + data_smoothing=observation_data_smoothing, + time_start=start, + time_end=end + ) + measurements[station.name] = data_ + if include_coverage_uncertainty: + # TODO: how to map to uncertainty related data? + ... + if include_coverage_related_data: + # TODO: how to map to related data? + ... else: raise RuntimeError("Could not retrieve coverage data") return measurements +def _get_station_data( + session: sqlmodel.Session, + settings: ArpavPpcvSettings, + point_geom: shapely.Point, + coverage_configuration: coverages.CoverageConfiguration, + coverage_identifier: str, +) -> Optional[ + tuple[ + list[ + observations.MonthlyMeasurement | + observations.SeasonalMeasurement | + observations.YearlyMeasurement + ], + observations.Station + ] +]: + point_buffer_geom = _get_spatial_buffer( + point_geom, settings.nearest_station_radius_meters) + nearby_stations = database.collect_all_stations( + session, polygon_intersection_filter=point_buffer_geom) + if len(nearby_stations) > 0: + retriever_kwargs = { + "variable_id_filter": coverage_configuration.observation_variable_id + } + aggregation_type = coverage_configuration.observation_variable_aggregation_type + if aggregation_type == base.ObservationAggregationType.MONTHLY: + retriever = functools.partial( + database.collect_all_monthly_measurements, + session, + **retriever_kwargs, + month_filter=None + ) + elif aggregation_type == base.ObservationAggregationType.SEASONAL: + retriever = functools.partial( + database.collect_all_seasonal_measurements, + session, + **retriever_kwargs, + season_filter=coverage_configuration.get_seasonal_aggregation_query_filter( + coverage_identifier) + ) + else: # ANNUAL + retriever = functools.partial( + database.collect_all_yearly_measurements, + session, + **retriever_kwargs, + ) + sorted_stations = sorted( + nearby_stations, key=lambda s: to_shape(s.geom).distance(point_geom)) + # order nearby stations by distance and then iterate through them in order to + # try to get measurements for the relevant variable and temporal aggregation + for station in sorted_stations: + raw_station_data = retriever(station_id_filter=station.id) + if len(raw_station_data) > 0: + # stop with the first station that has data + result = (raw_station_data, station) + break + else: + result = None + logger.info(f"Nearby stations do not have data") + else: + logger.info( + f"There are no nearby stations from {shapely.io.to_wkt(point_geom)}") + result = None + return result + + +def _process_station_data( + raw_data: list[ + observations.SeasonalMeasurement | + observations.MonthlyMeasurement | + observations.YearlyMeasurement + ], + data_smoothing: Optional[base.CoverageDataSmoothingStrategy], + time_start: Optional[dt.datetime], + time_end: Optional[dt.datetime], +) -> pd.DataFrame: + df = pd.DataFrame( + [i.model_dump() for i in raw_data] + ) + # throw out unneeded columns + # convert into proper timestamps + # filter out + return df + + def _process_coverage_data( raw_data: str, coverage_configuration: coverages.CoverageConfiguration, - data_smoothing: Optional[coverages.CoverageDataSmoothingStrategy], + data_smoothing: Optional[base.CoverageDataSmoothingStrategy], time_start: Optional[dt.datetime], time_end: Optional[dt.datetime], ) -> pd.DataFrame: - # - filter out columns we don't care about - # - filter out values outside the temporal range df = pd.read_csv(io.StringIO(raw_data), parse_dates=["time"]) # get name of the colum that holds the main variable @@ -171,4 +267,4 @@ def _get_spatial_buffer( distance=distance_meters ) return transform( - inverse_coordinate_transformer, buffer_geom_projected) \ No newline at end of file + inverse_coordinate_transformer, buffer_geom_projected) diff --git a/arpav_ppcv/schemas/base.py b/arpav_ppcv/schemas/base.py index cb6eadf6..e22248c9 100644 --- a/arpav_ppcv/schemas/base.py +++ b/arpav_ppcv/schemas/base.py @@ -1,6 +1,28 @@ +import enum import pydantic import sqlmodel +class Season(enum.Enum): + WINTER = "WINTER" + SPRING = "SPRING" + SUMMER = "SUMMER" + AUTUMN = "AUTUMN" + + +class ObservationDataSmoothingStrategy(enum.Enum): + MOVING_AVERAGE_5_YEARS = "MOVING_AVERAGE_5_YEARS" + + +class ObservationAggregationType(enum.Enum): + MONTHLY = "MONTHLY" + SEASONAL = "SEASONAL" + YEARLY = "YEARLY" + + +class CoverageDataSmoothingStrategy(enum.Enum): + MOVING_AVERAGE_11_YEARS_PLUS_LOESS_SMOOTHING = "MOVING_AVERAGE_11_YEARS_PLUS_LOESS_SMOOTHING" + + class ResourceList(pydantic.BaseModel): items: list[sqlmodel.SQLModel] diff --git a/arpav_ppcv/schemas/coverages.py b/arpav_ppcv/schemas/coverages.py index d0677645..c949212b 100644 --- a/arpav_ppcv/schemas/coverages.py +++ b/arpav_ppcv/schemas/coverages.py @@ -1,4 +1,3 @@ -import enum import logging import re import uuid @@ -13,6 +12,8 @@ import sqlalchemy import sqlmodel +from . import base + if TYPE_CHECKING: from . import observations @@ -20,16 +21,6 @@ _NAME_PATTERN: Final[str] = r"^[a-z][a-z0-9_]+$" -class CoverageDataSmoothingStrategy(enum.Enum): - MOVING_AVERAGE_11_YEARS_PLUS_LOESS_SMOOTHING = "MOVING_AVERAGE_11_YEARS_PLUS_LOESS_SMOOTHING" - - -class ObservationAggregationType(enum.Enum): - MONTHLY = "MONTHLY" - SEASONAL = "SEASONAL" - YEARLY = "YEARLY" - - class ConfigurationParameterValue(sqlmodel.SQLModel, table=True): __table_args__ = ( sqlalchemy.ForeignKeyConstraint( @@ -143,7 +134,7 @@ class CoverageConfiguration(sqlmodel.SQLModel, table=True): default=None, foreign_key="variable.id" ) - observation_variable_aggregation_type: Optional[ObservationAggregationType] = None + observation_variable_aggregation_type: Optional[base.ObservationAggregationType] = None possible_values: list["ConfigurationParameterPossibleValue"] = sqlmodel.Relationship( back_populates="coverage_configuration", @@ -219,6 +210,32 @@ def retrieve_configuration_parameters(self, coverage_identifier) -> dict[str, st result[configuration_parameter_name] = id_part return result + def get_seasonal_aggregation_query_filter( + self, coverage_identifier: str) -> Optional[base.Season]: + used_values = self.retrieve_used_values(coverage_identifier) + for used_value in used_values: + is_temporal_aggregation = ( + used_value.configuration_parameter_value.configuration_parameter.name in ("year_period",) + ) + if is_temporal_aggregation: + value = used_value.configuration_parameter_value.name.lower() + if value in ("djf",): + result = base.Season.WINTER + elif value in ("mam",): + result = base.Season.SPRING + elif value in ("jja",): + result = base.Season.SUMMER + elif value in ("son",): + result = base.Season.AUTUMN + break + else: + result = None + logger.warning( + f"Could not determine appropriate season for coverage " + f"identifier {coverage_identifier!r}" + ) + return result + class CoverageConfigurationCreate(sqlmodel.SQLModel): @@ -240,7 +257,7 @@ class CoverageConfigurationCreate(sqlmodel.SQLModel): color_scale_max: float possible_values: list["ConfigurationParameterPossibleValueCreate"] observation_variable_id: Optional[uuid.UUID] = None - observation_variable_aggregation_type: Optional[ObservationAggregationType] = None + observation_variable_aggregation_type: Optional[base.ObservationAggregationType] = None @pydantic.field_validator("thredds_url_pattern") @classmethod @@ -266,7 +283,7 @@ class CoverageConfigurationUpdate(sqlmodel.SQLModel): color_scale_min: Optional[float] = None color_scale_max: Optional[float] = None observation_variable_id: Optional[uuid.UUID] = None - observation_variable_aggregation_type: Optional[ObservationAggregationType] = None + observation_variable_aggregation_type: Optional[base.ObservationAggregationType] = None possible_values: list["ConfigurationParameterPossibleValueUpdate"] @pydantic.field_validator("thredds_url_pattern") diff --git a/arpav_ppcv/schemas/observations.py b/arpav_ppcv/schemas/observations.py index ae9c9677..4fc36766 100644 --- a/arpav_ppcv/schemas/observations.py +++ b/arpav_ppcv/schemas/observations.py @@ -1,5 +1,4 @@ import datetime as dt -import enum import uuid from typing import ( Optional, @@ -13,20 +12,23 @@ import sqlmodel from . import fields +from . import base if TYPE_CHECKING: from . import coverages - -class Season(enum.Enum): - WINTER = "WINTER" - SPRING = "SPRING" - SUMMER = "SUMMER" - AUTUMN = "AUTUMN" - - -class ObservationDataSmoothingStrategy(enum.Enum): - MOVING_AVERAGE_5_YEARS = "MOVING_AVERAGE_5_YEARS" + def get_season(self, value: str): + if value.lower() in ("djf",): + result = self.WINTER + elif value.lower() in ("mam",): + result = self.SPRING + elif value.lower() in ("jja",): + result = self.SUMMER + elif value.lower() in ("son",): + result = self.AUTUMN + else: + result = [] + return result class StationBase(sqlmodel.SQLModel): @@ -259,7 +261,7 @@ class SeasonalMeasurement(sqlmodel.SQLModel, table=True): variable_id: pydantic.UUID4 value: float year: int - season: Season + season: base.Season station: Station = sqlmodel.Relationship( back_populates="seasonal_measurements", @@ -286,13 +288,13 @@ class SeasonalMeasurementCreate(sqlmodel.SQLModel): variable_id: pydantic.UUID4 value: float year: int - season: Season + season: base.Season class SeasonalMeasurementUpdate(sqlmodel.SQLModel): value: Optional[float] = None year: Optional[int] = None - season: Optional[Season] = None + season: Optional[base.Season] = None class YearlyMeasurement(sqlmodel.SQLModel, table=True): diff --git a/arpav_ppcv/webapp/admin/schemas.py b/arpav_ppcv/webapp/admin/schemas.py index 38cd3e15..62d2d50d 100644 --- a/arpav_ppcv/webapp/admin/schemas.py +++ b/arpav_ppcv/webapp/admin/schemas.py @@ -3,7 +3,7 @@ import sqlmodel -from ...schemas.coverages import ObservationAggregationType +from ...schemas.base import ObservationAggregationType class ConfigurationParameterValueRead(sqlmodel.SQLModel): diff --git a/arpav_ppcv/webapp/admin/views.py b/arpav_ppcv/webapp/admin/views.py index 3067af8f..7c15cdba 100644 --- a/arpav_ppcv/webapp/admin/views.py +++ b/arpav_ppcv/webapp/admin/views.py @@ -24,7 +24,10 @@ from starlette_admin.contrib.sqlmodel import ModelView from ... import database -from ...schemas import coverages +from ...schemas import ( + coverages, + base, +) from . import schemas as read_schemas @@ -107,7 +110,15 @@ class ConfigurationParameterView(ModelView): fields = ( UuidField("id"), - starlette_admin.StringField("name"), + starlette_admin.StringField( + "name", + help_text=( + "Name for the configuration parameter. Must only use alphanumeric " + "characters and the underscore. If you use the special name " + "'year_period', then the system will use this parameter to " + "perform database queries." + ) + ), starlette_admin.StringField("description"), starlette_admin.ListField( field=starlette_admin.CollectionField( @@ -301,7 +312,7 @@ class CoverageConfigurationView(ModelView): ), starlette_admin.EnumField( "observation_variable_aggregation_type", - enum=coverages.ObservationAggregationType + enum=base.ObservationAggregationType ), starlette_admin.ListField( field=PossibleConfigurationParameterValuesField( diff --git a/arpav_ppcv/webapp/api_v2/routers/coverages.py b/arpav_ppcv/webapp/api_v2/routers/coverages.py index 23f2235b..da1855a3 100644 --- a/arpav_ppcv/webapp/api_v2/routers/coverages.py +++ b/arpav_ppcv/webapp/api_v2/routers/coverages.py @@ -21,8 +21,7 @@ ) from ....config import ArpavPpcvSettings from ....thredds import utils as thredds_utils -from ....schemas import coverages as base_coverages -from ....schemas import observations as base_observations +from ....schemas import base from ... import dependencies from ..schemas import coverages as coverage_schemas @@ -215,11 +214,11 @@ def get_time_series( db_session, coverage_configuration_name) if db_coverage_configuration is not None: cov_smoothing = ( - base_coverages.CoverageDataSmoothingStrategy.MOVING_AVERAGE_11_YEARS_PLUS_LOESS_SMOOTHING + base.CoverageDataSmoothingStrategy.MOVING_AVERAGE_11_YEARS_PLUS_LOESS_SMOOTHING if coverage_data_smoothing else None ) obs_smoothing = ( - base_observations.ObservationDataSmoothingStrategy.MOVING_AVERAGE_5_YEARS + base.ObservationDataSmoothingStrategy.MOVING_AVERAGE_5_YEARS if observation_data_smoothing else None ) geom = shapely.io.from_wkt(coords) diff --git a/arpav_ppcv/webapp/api_v2/routers/observations.py b/arpav_ppcv/webapp/api_v2/routers/observations.py index c283eca8..b37461ce 100644 --- a/arpav_ppcv/webapp/api_v2/routers/observations.py +++ b/arpav_ppcv/webapp/api_v2/routers/observations.py @@ -14,7 +14,7 @@ from sqlmodel import Session from .... import database -from ....schemas import observations as base_observations +from ....schemas import base from ... import dependencies from ..schemas import observations from ..schemas.geojson import observations as observations_geojson @@ -206,7 +206,7 @@ def list_seasonal_measurements( list_params: Annotated[dependencies.CommonListFilterParameters, Depends()], station_code: str | None = None, variable_name: str | None = None, - season: base_observations.Season | None = None, + season: base.Season | None = None, ): """List known seasonal measurements.""" if station_code is not None: diff --git a/arpav_ppcv/webapp/api_v2/schemas/observations.py b/arpav_ppcv/webapp/api_v2/schemas/observations.py index 2c784911..d7522281 100644 --- a/arpav_ppcv/webapp/api_v2/schemas/observations.py +++ b/arpav_ppcv/webapp/api_v2/schemas/observations.py @@ -4,6 +4,7 @@ from fastapi import Request from ....schemas import observations +from ....schemas.base import Season from .base import WebResourceList logger = logging.getLogger(__name__) @@ -67,7 +68,7 @@ class SeasonalMeasurementReadListItem(pydantic.BaseModel): variable_name: str station_code: str year: int - season: observations.Season + season: Season value: float @classmethod From 5e9109ef4bf888251c58c4f2ed0033521700a072 Mon Sep 17 00:00:00 2001 From: Ricardo Garcia Silva Date: Tue, 14 May 2024 19:36:47 +0100 Subject: [PATCH 07/11] Adding smoothing of the time series --- arpav_ppcv/cliapp/app.py | 9 +- arpav_ppcv/cliapp/schemas.py | 7 +- arpav_ppcv/database.py | 27 +- arpav_ppcv/operations.py | 56 +- arpav_ppcv/schemas/base.py | 3 +- arpav_ppcv/webapp/api_v2/routers/coverages.py | 20 +- poetry.lock | 74 +- pyproject.toml | 1 + tests/notebooks/timeseries.ipynb | 781 ++++++++++++++++++ 9 files changed, 944 insertions(+), 34 deletions(-) create mode 100644 tests/notebooks/timeseries.ipynb diff --git a/arpav_ppcv/cliapp/app.py b/arpav_ppcv/cliapp/app.py index 0088c425..56c10107 100644 --- a/arpav_ppcv/cliapp/app.py +++ b/arpav_ppcv/cliapp/app.py @@ -12,7 +12,10 @@ from rich import print from .. import database -from ..schemas import observations +from ..schemas import ( + base, + observations, +) from . import schemas app = typer.Typer() @@ -212,7 +215,8 @@ def create_seasonal_measurement( ctx: typer.Context, station_code: str, variable: str, - season: observations.Season, + year: int, + season: base.Season, value: float, ) -> None: """Create a new seasonal measurement.""" @@ -229,6 +233,7 @@ def create_seasonal_measurement( observations.SeasonalMeasurementCreate( station_id=db_station.id, variable_id=db_variable.id, + year=year, season=season, value=value, ) diff --git a/arpav_ppcv/cliapp/schemas.py b/arpav_ppcv/cliapp/schemas.py index 7a56a5ad..80904078 100644 --- a/arpav_ppcv/cliapp/schemas.py +++ b/arpav_ppcv/cliapp/schemas.py @@ -1,6 +1,9 @@ import pydantic -from ..schemas import observations +from ..schemas import ( + base, + observations +) class StationRead(observations.StationBase): @@ -46,7 +49,7 @@ class SeasonalMeasurementRead(pydantic.BaseModel): station_id: pydantic.UUID4 variable_id: pydantic.UUID4 year: int - season: observations.Season + season: base.Season value: float diff --git a/arpav_ppcv/database.py b/arpav_ppcv/database.py index ec733228..59fcd200 100644 --- a/arpav_ppcv/database.py +++ b/arpav_ppcv/database.py @@ -244,7 +244,11 @@ def list_stations( include_total: bool = False, polygon_intersection_filter: shapely.Polygon = None, ) -> tuple[Sequence[observations.Station], Optional[int]]: - """List existing stations.""" + """List existing stations. + + The ``polygon_intersetion_filter`` parameter is expected to be a polygon + geometry in the EPSG:4326 CRS. + """ statement = ( sqlmodel.select(observations.Station) .order_by(observations.Station.code) @@ -253,7 +257,10 @@ def list_stations( statement = statement.where( func.ST_Intersects( observations.Station.geom, - func.ST_GeomFromWKB(shapely.io.to_wkb(polygon_intersection_filter)) + func.ST_GeomFromWKB( + shapely.io.to_wkb(polygon_intersection_filter), + 4326 + ) ) ) items = session.exec(statement.offset(offset).limit(limit)).all() @@ -266,6 +273,11 @@ def collect_all_stations( session: sqlmodel.Session, polygon_intersection_filter: shapely.Polygon = None, ) -> Sequence[observations.Station]: + """Collect all stations. + + The ``polygon_intersetion_filter`` parameter is expected to be a polygon + geometry in the EPSG:4326 CRS. + """ _, num_total = list_stations( session, limit=1, @@ -783,6 +795,17 @@ def get_coverage_configuration_by_name( ).first() +def get_coverage_configuration_by_coverage_identifier( + session: sqlmodel.Session, + coverage_identifier: str +) -> Optional[coverages.CoverageConfiguration]: + """ + Get a coverage configuration by the identifier of one of its possible coverages. + """ + coverage_configuration_name = coverage_identifier.partition("-")[0] + return get_coverage_configuration_by_name(session, coverage_configuration_name) + + def list_coverage_configurations( session: sqlmodel.Session, *, diff --git a/arpav_ppcv/operations.py b/arpav_ppcv/operations.py index 65a2ccb7..0ac5e746 100644 --- a/arpav_ppcv/operations.py +++ b/arpav_ppcv/operations.py @@ -12,6 +12,7 @@ import sqlmodel from dateutil.parser import isoparse from geoalchemy2.shape import to_shape +from loess.loess_1d import loess_1d from pyproj.enums import TransformDirection from shapely.ops import transform @@ -78,13 +79,19 @@ def get_coverage_time_series( ) if station_data is not None: raw_station_data, station = station_data - data_ = _process_station_data( + data_ = _process_seasonal_station_data( raw_station_data, data_smoothing=observation_data_smoothing, time_start=start, time_end=end ) - measurements[station.name] = data_ + station_data_series_key = "-".join(( + "variable", + str(coverage_configuration.observation_variable_id), + "station", + str(station.id) + )) + measurements[station_data_series_key] = data_ if include_coverage_uncertainty: # TODO: how to map to uncertainty related data? ... @@ -146,8 +153,10 @@ def _get_station_data( nearby_stations, key=lambda s: to_shape(s.geom).distance(point_geom)) # order nearby stations by distance and then iterate through them in order to # try to get measurements for the relevant variable and temporal aggregation + logger.debug(f"{sorted_stations=}") for station in sorted_stations: raw_station_data = retriever(station_id_filter=station.id) + logger.debug(f"Processing station {station.id}...") if len(raw_station_data) > 0: # stop with the first station that has data result = (raw_station_data, station) @@ -162,22 +171,34 @@ def _get_station_data( return result -def _process_station_data( - raw_data: list[ - observations.SeasonalMeasurement | - observations.MonthlyMeasurement | - observations.YearlyMeasurement - ], - data_smoothing: Optional[base.CoverageDataSmoothingStrategy], +def _process_seasonal_station_data( + raw_data: list[observations.SeasonalMeasurement], + data_smoothing: Optional[base.ObservationDataSmoothingStrategy], time_start: Optional[dt.datetime], time_end: Optional[dt.datetime], ) -> pd.DataFrame: df = pd.DataFrame( [i.model_dump() for i in raw_data] ) - # throw out unneeded columns - # convert into proper timestamps - # filter out + df = df[["value", "season", "year"]] + df["season_month"] = df["season"].astype("string").replace({ + "Season.WINTER": "01", + "Season.SPRING": "04", + "Season.SUMMER": "07", + "Season.AUTUMN": "10" + }) + df["time"] = pd.to_datetime( + df["year"].astype("string") + "-" + df["season_month"] + "-01", + utc=True + ) + df = df[["value", "time"]] + df.set_index("time", inplace=True) + if time_start is not None: + df = df[time_start:] + if time_end is not None: + df = df[:time_end] + if data_smoothing == base.ObservationDataSmoothingStrategy.MOVING_AVERAGE_5_YEARS: + df["smoothed_value"] = df["value"].rolling(window=5, min_periods=1).mean() return df @@ -210,9 +231,14 @@ def _process_coverage_data( df = df[time_start:] if time_end is not None: df = df[:time_end] - - if data_smoothing is not None: - ... + if data_smoothing == base.CoverageDataSmoothingStrategy.MOVING_AVERAGE_11_YEARS: + df["smoothed_value"] = df[variable_name].rolling(window=11, min_periods=1).mean() + elif data_smoothing == base.CoverageDataSmoothingStrategy.LOESS_SMOOTHING: + _, loess_smoothed, _ = loess_1d( + df.index.astype("int64"), + df[variable_name], + ) + df["smoothed_value"] = loess_smoothed return df diff --git a/arpav_ppcv/schemas/base.py b/arpav_ppcv/schemas/base.py index e22248c9..99c0a7aa 100644 --- a/arpav_ppcv/schemas/base.py +++ b/arpav_ppcv/schemas/base.py @@ -21,7 +21,8 @@ class ObservationAggregationType(enum.Enum): class CoverageDataSmoothingStrategy(enum.Enum): - MOVING_AVERAGE_11_YEARS_PLUS_LOESS_SMOOTHING = "MOVING_AVERAGE_11_YEARS_PLUS_LOESS_SMOOTHING" + LOESS_SMOOTHING = "LOESS_SMOOTHING" + MOVING_AVERAGE_11_YEARS = "MOVING_AVERAGE_11" class ResourceList(pydantic.BaseModel): diff --git a/arpav_ppcv/webapp/api_v2/routers/coverages.py b/arpav_ppcv/webapp/api_v2/routers/coverages.py index da1855a3..e4838808 100644 --- a/arpav_ppcv/webapp/api_v2/routers/coverages.py +++ b/arpav_ppcv/webapp/api_v2/routers/coverages.py @@ -16,7 +16,7 @@ from sqlmodel import Session from .... import ( - database, + database as db, operations, ) from ....config import ArpavPpcvSettings @@ -74,13 +74,13 @@ async def list_coverage_configurations( endpoint. """ - coverage_configurations, filtered_total = database.list_coverage_configurations( + coverage_configurations, filtered_total = db.list_coverage_configurations( db_session, limit=list_params.limit, offset=list_params.offset, include_total=True ) - _, unfiltered_total = database.list_coverage_configurations( + _, unfiltered_total = db.list_coverage_configurations( db_session, limit=1, offset=0, include_total=True ) return coverage_schemas.CoverageConfigurationList.from_items( @@ -102,9 +102,9 @@ def get_coverage_configuration( db_session: Annotated[Session, Depends(dependencies.get_db_session)], coverage_configuration_id: pydantic.UUID4 ): - db_coverage_configuration = database.get_coverage_configuration( + db_coverage_configuration = db.get_coverage_configuration( db_session, coverage_configuration_id) - allowed_coverage_identifiers = database.list_allowed_coverage_identifiers( + allowed_coverage_identifiers = db.list_allowed_coverage_identifiers( db_session, coverage_configuration_id=db_coverage_configuration.id) return coverage_schemas.CoverageConfigurationReadDetail.from_db_instance( db_coverage_configuration, allowed_coverage_identifiers, request) @@ -123,9 +123,8 @@ async def wms_endpoint( Pass additional relevant WMS query parameters directly to this endpoint. """ - coverage_configuration_name = coverage_identifier.partition("-")[0] - db_coverage_configuration = database.get_coverage_configuration_by_name( - db_session, coverage_configuration_name) + db_coverage_configuration = db.get_coverage_configuration_by_coverage_identifier( + db_session, coverage_identifier) if db_coverage_configuration is not None: try: thredds_url_fragment = db_coverage_configuration.get_thredds_url_fragment(coverage_identifier) @@ -209,9 +208,8 @@ def get_time_series( include_coverage_uncertainty: bool = False, include_coverage_related_data: bool = False, ): - coverage_configuration_name = coverage_identifier.partition("-")[0] - db_coverage_configuration = database.get_coverage_configuration_by_name( - db_session, coverage_configuration_name) + db_coverage_configuration = db.get_coverage_configuration_by_coverage_identifier( + db_session, coverage_identifier) if db_coverage_configuration is not None: cov_smoothing = ( base.CoverageDataSmoothingStrategy.MOVING_AVERAGE_11_YEARS_PLUS_LOESS_SMOOTHING diff --git a/poetry.lock b/poetry.lock index b3cc423b..e6cc5c9b 100644 --- a/poetry.lock +++ b/poetry.lock @@ -2255,6 +2255,21 @@ sqs = ["boto3 (>=1.4.4)", "pycurl (==7.43.0.2)"] yaml = ["PyYAML (>=3.10)"] zookeeper = ["kazoo (>=1.3.1)"] +[[package]] +name = "loess" +version = "2.1.2" +description = "LOESS: smoothing via robust locally-weighted regression in one or two dimensions" +optional = false +python-versions = "*" +files = [ + {file = "loess-2.1.2.tar.gz", hash = "sha256:f0c1e83e70c5f9b95da635495c0ec555cf7c225186f7e6d978ed7c20d2f3828a"}, +] + +[package.dependencies] +matplotlib = "*" +numpy = "*" +plotbin = "*" + [[package]] name = "lxml" version = "5.1.0" @@ -3019,6 +3034,21 @@ files = [ docs = ["furo (>=2023.9.10)", "proselint (>=0.13)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1.25.2)"] test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=7.4.3)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)"] +[[package]] +name = "plotbin" +version = "3.1.5" +description = "PlotBin: Plotting Binned Maps and Other Utilities" +optional = false +python-versions = "*" +files = [ + {file = "plotbin-3.1.5.tar.gz", hash = "sha256:9fb2d86bd887eaaad9612dea306f57fed5bcb4252a54d8ff040beb9bb1645410"}, +] + +[package.dependencies] +matplotlib = "*" +numpy = "*" +scipy = "*" + [[package]] name = "pluggy" version = "1.4.0" @@ -4022,6 +4052,48 @@ files = [ {file = "ruff-0.2.2.tar.gz", hash = "sha256:e62ed7f36b3068a30ba39193a14274cd706bc486fad521276458022f7bccb31d"}, ] +[[package]] +name = "scipy" +version = "1.13.0" +description = "Fundamental algorithms for scientific computing in Python" +optional = false +python-versions = ">=3.9" +files = [ + {file = "scipy-1.13.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ba419578ab343a4e0a77c0ef82f088238a93eef141b2b8017e46149776dfad4d"}, + {file = "scipy-1.13.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:22789b56a999265431c417d462e5b7f2b487e831ca7bef5edeb56efe4c93f86e"}, + {file = "scipy-1.13.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:05f1432ba070e90d42d7fd836462c50bf98bd08bed0aa616c359eed8a04e3922"}, + {file = "scipy-1.13.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8434f6f3fa49f631fae84afee424e2483289dfc30a47755b4b4e6b07b2633a4"}, + {file = "scipy-1.13.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:dcbb9ea49b0167de4167c40eeee6e167caeef11effb0670b554d10b1e693a8b9"}, + {file = "scipy-1.13.0-cp310-cp310-win_amd64.whl", hash = "sha256:1d2f7bb14c178f8b13ebae93f67e42b0a6b0fc50eba1cd8021c9b6e08e8fb1cd"}, + {file = "scipy-1.13.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0fbcf8abaf5aa2dc8d6400566c1a727aed338b5fe880cde64907596a89d576fa"}, + {file = "scipy-1.13.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:5e4a756355522eb60fcd61f8372ac2549073c8788f6114449b37e9e8104f15a5"}, + {file = "scipy-1.13.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b5acd8e1dbd8dbe38d0004b1497019b2dbbc3d70691e65d69615f8a7292865d7"}, + {file = "scipy-1.13.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ff7dad5d24a8045d836671e082a490848e8639cabb3dbdacb29f943a678683d"}, + {file = "scipy-1.13.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:4dca18c3ffee287ddd3bc8f1dabaf45f5305c5afc9f8ab9cbfab855e70b2df5c"}, + {file = "scipy-1.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:a2f471de4d01200718b2b8927f7d76b5d9bde18047ea0fa8bd15c5ba3f26a1d6"}, + {file = "scipy-1.13.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:d0de696f589681c2802f9090fff730c218f7c51ff49bf252b6a97ec4a5d19e8b"}, + {file = "scipy-1.13.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:b2a3ff461ec4756b7e8e42e1c681077349a038f0686132d623fa404c0bee2551"}, + {file = "scipy-1.13.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6bf9fe63e7a4bf01d3645b13ff2aa6dea023d38993f42aaac81a18b1bda7a82a"}, + {file = "scipy-1.13.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1e7626dfd91cdea5714f343ce1176b6c4745155d234f1033584154f60ef1ff42"}, + {file = "scipy-1.13.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:109d391d720fcebf2fbe008621952b08e52907cf4c8c7efc7376822151820820"}, + {file = "scipy-1.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:8930ae3ea371d6b91c203b1032b9600d69c568e537b7988a3073dfe4d4774f21"}, + {file = "scipy-1.13.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5407708195cb38d70fd2d6bb04b1b9dd5c92297d86e9f9daae1576bd9e06f602"}, + {file = "scipy-1.13.0-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:ac38c4c92951ac0f729c4c48c9e13eb3675d9986cc0c83943784d7390d540c78"}, + {file = "scipy-1.13.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:09c74543c4fbeb67af6ce457f6a6a28e5d3739a87f62412e4a16e46f164f0ae5"}, + {file = "scipy-1.13.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:28e286bf9ac422d6beb559bc61312c348ca9b0f0dae0d7c5afde7f722d6ea13d"}, + {file = "scipy-1.13.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:33fde20efc380bd23a78a4d26d59fc8704e9b5fd9b08841693eb46716ba13d86"}, + {file = "scipy-1.13.0-cp39-cp39-win_amd64.whl", hash = "sha256:45c08bec71d3546d606989ba6e7daa6f0992918171e2a6f7fbedfa7361c2de1e"}, + {file = "scipy-1.13.0.tar.gz", hash = "sha256:58569af537ea29d3f78e5abd18398459f195546bb3be23d16677fb26616cc11e"}, +] + +[package.dependencies] +numpy = ">=1.22.4,<2.3" + +[package.extras] +dev = ["cython-lint (>=0.12.2)", "doit (>=0.36.0)", "mypy", "pycodestyle", "pydevtool", "rich-click", "ruff", "types-psutil", "typing_extensions"] +doc = ["jupyterlite-pyodide-kernel", "jupyterlite-sphinx (>=0.12.0)", "jupytext", "matplotlib (>=3.5)", "myst-nb", "numpydoc", "pooch", "pydata-sphinx-theme (>=0.15.2)", "sphinx (>=5.0.0)", "sphinx-design (>=0.4.0)"] +test = ["array-api-strict", "asv", "gmpy2", "hypothesis (>=6.30)", "mpmath", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"] + [[package]] name = "send2trash" version = "1.8.3" @@ -5106,4 +5178,4 @@ testing = ["coverage (>=5.0.3)", "zope.event", "zope.testing"] [metadata] lock-version = "2.0" python-versions = "^3.10" -content-hash = "a90606a0cf1980e0d7d775b07392febadc2f550ff35d85b209de1233f79d89b2" +content-hash = "a68fdc62c692336235c72313861151b3f75eed2b91f41a03bcb9df15887706ee" diff --git a/pyproject.toml b/pyproject.toml index 752d3568..0dd6a2ae 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -55,6 +55,7 @@ itsdangerous = "^2.2.0" jinja2 = "^3.1.4" pyyaml = "^6.0.1" alembic-postgresql-enum = "^1.2.0" +loess = "^2.1.2" [tool.poetry.group.dev] diff --git a/tests/notebooks/timeseries.ipynb b/tests/notebooks/timeseries.ipynb new file mode 100644 index 00000000..eb55260b --- /dev/null +++ b/tests/notebooks/timeseries.ipynb @@ -0,0 +1,781 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ba6c0d2b-df3e-451d-922f-a812e7986ef8", + "metadata": {}, + "source": [ + "# arpav-ppcv-backend test notebook\n", + "\n", + "This notebook has some interactive tests of time series data" + ] + }, + { + "cell_type": "markdown", + "id": "ef262da9-b90c-48eb-a1ef-221a3d7ea21f", + "metadata": {}, + "source": [ + "We start off by doing some imports and initializing both the `settings` and a DB `session`, as these often come in handy\n", + "\n", + "Then we proceed to get some sample data and ask for a the corresponding time series" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b0e6fa14-a6a9-459a-8233-9d83f7c1f83d", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib widget\n", + "\n", + "import logging\n", + "\n", + "import httpx\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import shapely.io\n", + "import sqlmodel\n", + "from loess.loess_1d import loess_1d\n", + "\n", + "from arpav_ppcv import (\n", + " database as db,\n", + " operations,\n", + ")\n", + "from arpav_ppcv.config import get_settings\n", + "from arpav_ppcv.schemas.base import (\n", + " CoverageDataSmoothingStrategy,\n", + " ObservationDataSmoothingStrategy,\n", + " Season,\n", + ")\n", + "\n", + "logging.basicConfig(level=logging.DEBUG)\n", + "logging.getLogger(\"httpx\").setLevel(logging.WARNING)\n", + "logging.getLogger(\"httpcore\").setLevel(logging.WARNING)\n", + "logging.getLogger(\"matplotlib\").setLevel(logging.WARNING)\n", + "\n", + "settings = get_settings()\n", + "session = sqlmodel.Session(db.get_engine(settings))\n", + "http_client = httpx.Client()\n", + "\n", + "coverage_identifier = \"tas_absolute-rcp26-DJF\"\n", + "coverage_configuration = db.get_coverage_configuration_by_coverage_identifier(\n", + " session, coverage_identifier)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "aa844bd5-eb54-43d4-ac95-d6a8be6d27cc", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEBUG:arpav_ppcv.operations:sorted_stations=[Station(id=UUID('d0e32657-3e6b-454c-8e51-ceb69d78e0ce'), active_since=datetime.date(1989, 1, 10), altitude_m=6.0, type_='agro', geom=, code='96', active_until=None, name='Bagnolo di Po - Pellizzare'), Station(id=UUID('608efa75-0148-4ba8-88b3-12a521b6eb18'), active_since=datetime.date(1989, 1, 17), altitude_m=6.0, type_='agro', geom=, code='99', active_until=None, name='San Bellino')]\n", + "DEBUG:arpav_ppcv.operations:Processing station d0e32657-3e6b-454c-8e51-ceb69d78e0ce...\n" + ] + } + ], + "source": [ + "POINT_GEOMS = {\n", + " \"near\": shapely.io.from_wkt(\"POINT(11.5469 44.9524)\"),\n", + "}\n", + "\n", + "temporal_range = \"../..\"\n", + "\n", + "time_series = operations.get_coverage_time_series(\n", + " settings,\n", + " session,\n", + " http_client,\n", + " coverage_configuration=coverage_configuration,\n", + " coverage_identifier=coverage_identifier,\n", + " point_geom=POINT_GEOMS[\"near\"],\n", + " temporal_range=temporal_range,\n", + " include_coverage_data=True,\n", + " include_observation_data=True,\n", + " coverage_data_smoothing=CoverageDataSmoothingStrategy.MOVING_AVERAGE_11_YEARS,\n", + " observation_data_smoothing=ObservationDataSmoothingStrategy.MOVING_AVERAGE_5_YEARS,\n", + " include_coverage_uncertainty=False,\n", + " include_coverage_related_data=False\n", + ")\n", + "\n", + "station_series_name = [i for i in time_series.keys() if i.startswith(\"variable-\")][0]\n", + "\n", + "df1 = time_series[coverage_configuration.name]\n", + "df2 = time_series[station_series_name]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ca9ef190-499f-4c8d-a4de-49d3de94e9b8", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "137db01cde354a1cb5774a2c9f32408e", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "7fb36aea-718d-4d49-aed8-15d030cd4917", + "metadata": {}, + "outputs": [], + "source": [ + "tas_line, = ax.plot(df1[\"tas\"], label=coverage_configuration.name)\n", + "station_line, = ax.plot(df2[\"value\"], label=station_series_name)\n", + "tas_line.set_linestyle(\":\")\n", + "tas_line.set_marker(\".\")\n", + "station_line.set_linestyle(\":\")\n", + "station_line.set_marker(\".\")\n", + "\n", + "smoothed_tas_line, = ax.plot(df1[\"smoothed_value\"], label=f\"smoothed_{coverage_configuration.name}\")\n", + "\n", + "smoothed_station_line = ax.plot(df2[\"smoothed_value\"], label=\"smoothed station data\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "51903e65-8f99-47e7-a830-dd4d49ef5fc1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "414bda58-fbac-4bb3-9057-8de8d3dd53be", + "metadata": {}, + "outputs": [], + "source": [ + "ax.clear()" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "26b0f139-eb7b-4908-b242-1e851078201b", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " a = x[:, None]**np.arange(degree + 1)\n", + "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n" + ] + } + ], + "source": [ + "xout, yout, wout = loess_1d.loess_1d(df1.index.astype(\"int64\"), df1[\"tas\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "3b6fdef4-ea4c-4eaa-9a1a-814a72742a69", + "metadata": {}, + "outputs": [], + "source": [ + "loess_lines, = ax.plot(df1.index, yout)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "2a882067-bc3b-45c6-8973-7a487daee54a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Int64Index([ 193233600000000000, 224791024390000000, 256348448780000000,\n", + " 287905873171000000, 319463297561000000, 351020721951000000,\n", + " 382578146341000000, 414135570732000000, 445692995122000000,\n", + " 477250419512000000,\n", + " ...\n", + " 3790779980488000000, 3822337404878000000, 3853894829268000000,\n", + " 3885452253659000000, 3917009678049000000, 3948567102439000000,\n", + " 3980124526829000000, 4011681951220000000, 4043239375610000000,\n", + " 4074796800000000000],\n", + " dtype='int64', name='time', length=124)" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df1.index.astype(\"int64\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f86dd11c-39b7-4232-b7e5-7089d12a54f2", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 4091693a78f64d49af2ff557fb874ff2d9ed9fe4 Mon Sep 17 00:00:00 2001 From: Ricardo Garcia Silva Date: Wed, 15 May 2024 15:25:39 +0100 Subject: [PATCH 08/11] Improve smoothing of data series --- arpav_ppcv/operations.py | 51 +-- arpav_ppcv/schemas/base.py | 4 +- arpav_ppcv/webapp/api_v2/routers/coverages.py | 69 ++-- tests/notebooks/timeseries.ipynb | 310 +++++++++--------- tests/notebooks/timeseries_via_api.ipynb | 226 +++++++++++++ 5 files changed, 463 insertions(+), 197 deletions(-) create mode 100644 tests/notebooks/timeseries_via_api.ipynb diff --git a/arpav_ppcv/operations.py b/arpav_ppcv/operations.py index 0ac5e746..fd2b9e4f 100644 --- a/arpav_ppcv/operations.py +++ b/arpav_ppcv/operations.py @@ -36,10 +36,10 @@ def get_coverage_time_series( coverage_identifier: str, point_geom: shapely.Point, temporal_range: str, + coverage_data_smoothing: base.CoverageDataSmoothingStrategy, + observation_data_smoothing: base.ObservationDataSmoothingStrategy, include_coverage_data: bool = True, include_observation_data: bool = False, - coverage_data_smoothing: base.CoverageDataSmoothingStrategy | None = None, - observation_data_smoothing: base.ObservationDataSmoothingStrategy | None = None, include_coverage_uncertainty: bool = False, include_coverage_related_data: bool = False, ) -> dict[str, pd.DataFrame]: @@ -64,11 +64,12 @@ def get_coverage_time_series( coverage_data = _process_coverage_data( raw_coverage_data, coverage_configuration, + coverage_identifier, coverage_data_smoothing, start, end ) - measurements[coverage_configuration.name] = coverage_data + measurements[coverage_identifier] = coverage_data if include_observation_data: station_data = _get_station_data( session, @@ -80,16 +81,16 @@ def get_coverage_time_series( if station_data is not None: raw_station_data, station = station_data data_ = _process_seasonal_station_data( + coverage_configuration.related_observation_variable, raw_station_data, data_smoothing=observation_data_smoothing, time_start=start, time_end=end ) station_data_series_key = "-".join(( - "variable", - str(coverage_configuration.observation_variable_id), "station", - str(station.id) + str(station.id), + coverage_configuration.related_observation_variable.name, )) measurements[station_data_series_key] = data_ if include_coverage_uncertainty: @@ -155,8 +156,8 @@ def _get_station_data( # try to get measurements for the relevant variable and temporal aggregation logger.debug(f"{sorted_stations=}") for station in sorted_stations: - raw_station_data = retriever(station_id_filter=station.id) logger.debug(f"Processing station {station.id}...") + raw_station_data = retriever(station_id_filter=station.id) if len(raw_station_data) > 0: # stop with the first station that has data result = (raw_station_data, station) @@ -172,8 +173,9 @@ def _get_station_data( def _process_seasonal_station_data( + variable: observations.Variable, raw_data: list[observations.SeasonalMeasurement], - data_smoothing: Optional[base.ObservationDataSmoothingStrategy], + data_smoothing: base.ObservationDataSmoothingStrategy, time_start: Optional[dt.datetime], time_end: Optional[dt.datetime], ) -> pd.DataFrame: @@ -181,6 +183,8 @@ def _process_seasonal_station_data( [i.model_dump() for i in raw_data] ) df = df[["value", "season", "year"]] + df = df.rename(columns={"value": variable.name}) + df["season_month"] = df["season"].astype("string").replace({ "Season.WINTER": "01", "Season.SPRING": "04", @@ -191,21 +195,24 @@ def _process_seasonal_station_data( df["year"].astype("string") + "-" + df["season_month"] + "-01", utc=True ) - df = df[["value", "time"]] + df = df[[variable.name, "time"]] df.set_index("time", inplace=True) if time_start is not None: df = df[time_start:] if time_end is not None: df = df[:time_end] + smoothed_key = f"smoothed_{variable.name}" if data_smoothing == base.ObservationDataSmoothingStrategy.MOVING_AVERAGE_5_YEARS: - df["smoothed_value"] = df["value"].rolling(window=5, min_periods=1).mean() + df[smoothed_key] = df[variable.name].rolling(window=5, center=True).mean() + df = df.dropna() return df def _process_coverage_data( raw_data: str, coverage_configuration: coverages.CoverageConfiguration, - data_smoothing: Optional[base.CoverageDataSmoothingStrategy], + coverage_identifier: str, + data_smoothing: base.CoverageDataSmoothingStrategy, time_start: Optional[dt.datetime], time_end: Optional[dt.datetime], ) -> pd.DataFrame: @@ -223,7 +230,7 @@ def _process_coverage_data( else: # keep only time and main variable - we don't care about other stuff df = df[["time", col_name]] - df = df.rename(columns={col_name: variable_name}) + df = df.rename(columns={col_name: coverage_identifier}) # - filter out values outside the temporal range df.set_index("time", inplace=True) @@ -231,14 +238,18 @@ def _process_coverage_data( df = df[time_start:] if time_end is not None: df = df[:time_end] - if data_smoothing == base.CoverageDataSmoothingStrategy.MOVING_AVERAGE_11_YEARS: - df["smoothed_value"] = df[variable_name].rolling(window=11, min_periods=1).mean() - elif data_smoothing == base.CoverageDataSmoothingStrategy.LOESS_SMOOTHING: - _, loess_smoothed, _ = loess_1d( - df.index.astype("int64"), - df[variable_name], - ) - df["smoothed_value"] = loess_smoothed + if data_smoothing != base.CoverageDataSmoothingStrategy.NO_SMOOTHING: + smoothed_key = f"smoothed_{coverage_identifier}" + if data_smoothing == base.CoverageDataSmoothingStrategy.MOVING_AVERAGE_11_YEARS: + df[smoothed_key] = df[coverage_identifier].rolling( + center=True, window=11).mean() + elif data_smoothing == base.CoverageDataSmoothingStrategy.LOESS_SMOOTHING: + _, loess_smoothed, _ = loess_1d( + df.index.astype("int64"), + df[coverage_identifier], + ) + df[smoothed_key] = loess_smoothed + df = df.dropna() return df diff --git a/arpav_ppcv/schemas/base.py b/arpav_ppcv/schemas/base.py index 99c0a7aa..23bdb60c 100644 --- a/arpav_ppcv/schemas/base.py +++ b/arpav_ppcv/schemas/base.py @@ -11,6 +11,7 @@ class Season(enum.Enum): class ObservationDataSmoothingStrategy(enum.Enum): + NO_SMOOTHING = "NO_SMOOTHING" MOVING_AVERAGE_5_YEARS = "MOVING_AVERAGE_5_YEARS" @@ -21,8 +22,9 @@ class ObservationAggregationType(enum.Enum): class CoverageDataSmoothingStrategy(enum.Enum): + NO_SMOOTHING = "NO_SMOOTHING" LOESS_SMOOTHING = "LOESS_SMOOTHING" - MOVING_AVERAGE_11_YEARS = "MOVING_AVERAGE_11" + MOVING_AVERAGE_11_YEARS = "MOVING_AVERAGE_11_YEARS" class ResourceList(pydantic.BaseModel): diff --git a/arpav_ppcv/webapp/api_v2/routers/coverages.py b/arpav_ppcv/webapp/api_v2/routers/coverages.py index e4838808..21bee664 100644 --- a/arpav_ppcv/webapp/api_v2/routers/coverages.py +++ b/arpav_ppcv/webapp/api_v2/routers/coverages.py @@ -1,6 +1,9 @@ import logging import urllib.parse -from typing import Annotated +from typing import ( + Annotated, + Optional, +) import httpx import pydantic @@ -200,25 +203,19 @@ def get_time_series( http_client: Annotated[httpx.Client, Depends(dependencies.get_sync_http_client)], coverage_identifier: str, coords: str, - datetime: str, + datetime: Optional[str] = "../..", include_coverage_data: bool = True, include_observation_data: bool = False, - coverage_data_smoothing: bool = True, - observation_data_smoothing: bool = True, + coverage_data_smoothing: base.CoverageDataSmoothingStrategy = ( + base.CoverageDataSmoothingStrategy.NO_SMOOTHING), + observation_data_smoothing: base.ObservationDataSmoothingStrategy = ( + base.ObservationDataSmoothingStrategy.NO_SMOOTHING), include_coverage_uncertainty: bool = False, include_coverage_related_data: bool = False, ): db_coverage_configuration = db.get_coverage_configuration_by_coverage_identifier( db_session, coverage_identifier) if db_coverage_configuration is not None: - cov_smoothing = ( - base.CoverageDataSmoothingStrategy.MOVING_AVERAGE_11_YEARS_PLUS_LOESS_SMOOTHING - if coverage_data_smoothing else None - ) - obs_smoothing = ( - base.ObservationDataSmoothingStrategy.MOVING_AVERAGE_5_YEARS - if observation_data_smoothing else None - ) geom = shapely.io.from_wkt(coords) if geom.geom_type == "MultiPoint": logger.warning( @@ -244,21 +241,49 @@ def get_time_series( temporal_range=datetime, include_coverage_data=include_coverage_data, include_observation_data=include_observation_data, - coverage_data_smoothing=cov_smoothing, - observation_data_smoothing=obs_smoothing, + coverage_data_smoothing=coverage_data_smoothing, + observation_data_smoothing=observation_data_smoothing, include_coverage_uncertainty=include_coverage_uncertainty, include_coverage_related_data=include_coverage_related_data, ) measurements = [] - for name, df in time_series.items(): - serialized_time_series = df.to_dict()[db_coverage_configuration.netcdf_main_dataset_name] - for timestamp, value in serialized_time_series.items(): - measurement = coverage_schemas.TimeSeriesItem( - value=value, - series=name, - datetime=timestamp, + coverage_df = time_series[coverage_identifier] + if include_coverage_data: + series_key = ( + f"smoothed_{coverage_identifier}" if + coverage_data_smoothing != base.CoverageDataSmoothingStrategy.NO_SMOOTHING + else coverage_identifier + ) + for timestamp, value in coverage_df.to_dict()[series_key].items(): + measurements.append( + coverage_schemas.TimeSeriesItem( + value=value, + series=coverage_identifier, + datetime=timestamp + ) + ) + if include_observation_data: + variable = db_coverage_configuration.related_observation_variable + obs_df_name = [ + n for n in time_series.keys() if n.startswith('station-')][0] + obs_df = time_series[obs_df_name] + series_key = ( + f"smoothed_{variable.name}" + if observation_data_smoothing != base.ObservationDataSmoothingStrategy.NO_SMOOTHING + else variable.name + ) + for timestamp, value in obs_df.to_dict()[series_key].items(): + measurements.append( + coverage_schemas.TimeSeriesItem( + value=value, + series=variable.name, + datetime=timestamp + ) ) - measurements.append(measurement) + if include_coverage_uncertainty: + ... + if include_coverage_related_data: + ... return coverage_schemas.TimeSeries(values=measurements) else: raise HTTPException(status_code=400, detail="Invalid coverage_identifier") diff --git a/tests/notebooks/timeseries.ipynb b/tests/notebooks/timeseries.ipynb index eb55260b..51b50df8 100644 --- a/tests/notebooks/timeseries.ipynb +++ b/tests/notebooks/timeseries.ipynb @@ -23,8 +23,10 @@ { "cell_type": "code", "execution_count": 1, - "id": "b0e6fa14-a6a9-459a-8233-9d83f7c1f83d", - "metadata": {}, + "id": "9d76dcd5-acef-408f-92d7-a1ea120e3591", + "metadata": { + "scrolled": true + }, "outputs": [], "source": [ "%matplotlib widget\n", @@ -60,143 +62,19 @@ "\n", "coverage_identifier = \"tas_absolute-rcp26-DJF\"\n", "coverage_configuration = db.get_coverage_configuration_by_coverage_identifier(\n", - " session, coverage_identifier)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "aa844bd5-eb54-43d4-ac95-d6a8be6d27cc", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:arpav_ppcv.operations:sorted_stations=[Station(id=UUID('d0e32657-3e6b-454c-8e51-ceb69d78e0ce'), active_since=datetime.date(1989, 1, 10), altitude_m=6.0, type_='agro', geom=, code='96', active_until=None, name='Bagnolo di Po - Pellizzare'), Station(id=UUID('608efa75-0148-4ba8-88b3-12a521b6eb18'), active_since=datetime.date(1989, 1, 17), altitude_m=6.0, type_='agro', geom=, code='99', active_until=None, name='San Bellino')]\n", - "DEBUG:arpav_ppcv.operations:Processing station d0e32657-3e6b-454c-8e51-ceb69d78e0ce...\n" - ] - } - ], - "source": [ + " session, coverage_identifier)\n", + "\n", "POINT_GEOMS = {\n", " \"near\": shapely.io.from_wkt(\"POINT(11.5469 44.9524)\"),\n", "}\n", "\n", - "temporal_range = \"../..\"\n", - "\n", - "time_series = operations.get_coverage_time_series(\n", - " settings,\n", - " session,\n", - " http_client,\n", - " coverage_configuration=coverage_configuration,\n", - " coverage_identifier=coverage_identifier,\n", - " point_geom=POINT_GEOMS[\"near\"],\n", - " temporal_range=temporal_range,\n", - " include_coverage_data=True,\n", - " include_observation_data=True,\n", - " coverage_data_smoothing=CoverageDataSmoothingStrategy.MOVING_AVERAGE_11_YEARS,\n", - " observation_data_smoothing=ObservationDataSmoothingStrategy.MOVING_AVERAGE_5_YEARS,\n", - " include_coverage_uncertainty=False,\n", - " include_coverage_related_data=False\n", - ")\n", - "\n", - "station_series_name = [i for i in time_series.keys() if i.startswith(\"variable-\")][0]\n", - "\n", - "df1 = time_series[coverage_configuration.name]\n", - "df2 = time_series[station_series_name]" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "ca9ef190-499f-4c8d-a4de-49d3de94e9b8", - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "137db01cde354a1cb5774a2c9f32408e", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "7fb36aea-718d-4d49-aed8-15d030cd4917", - "metadata": {}, - "outputs": [], - "source": [ - "tas_line, = ax.plot(df1[\"tas\"], label=coverage_configuration.name)\n", - "station_line, = ax.plot(df2[\"value\"], label=station_series_name)\n", - "tas_line.set_linestyle(\":\")\n", - "tas_line.set_marker(\".\")\n", - "station_line.set_linestyle(\":\")\n", - "station_line.set_marker(\".\")\n", - "\n", - "smoothed_tas_line, = ax.plot(df1[\"smoothed_value\"], label=f\"smoothed_{coverage_configuration.name}\")\n", - "\n", - "smoothed_station_line = ax.plot(df2[\"smoothed_value\"], label=\"smoothed station data\")" + "temporal_range = \"../..\"" ] }, { "cell_type": "code", - "execution_count": 7, - "id": "51903e65-8f99-47e7-a830-dd4d49ef5fc1", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ax.legend()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "414bda58-fbac-4bb3-9057-8de8d3dd53be", - "metadata": {}, - "outputs": [], - "source": [ - "ax.clear()" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "26b0f139-eb7b-4908-b242-1e851078201b", + "execution_count": 2, + "id": "fee64549-56ef-40d0-8a31-e27594b363c0", "metadata": { "scrolled": true }, @@ -700,61 +578,185 @@ "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:81: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", " a = x[:, None]**np.arange(degree + 1)\n", "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", - " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n" + " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", + "DEBUG:arpav_ppcv.operations:sorted_stations=[Station(id=UUID('d0e32657-3e6b-454c-8e51-ceb69d78e0ce'), active_since=datetime.date(1989, 1, 10), altitude_m=6.0, type_='agro', geom=, code='96', active_until=None, name='Bagnolo di Po - Pellizzare'), Station(id=UUID('608efa75-0148-4ba8-88b3-12a521b6eb18'), active_since=datetime.date(1989, 1, 17), altitude_m=6.0, type_='agro', geom=, code='99', active_until=None, name='San Bellino')]\n", + "DEBUG:arpav_ppcv.operations:Processing station d0e32657-3e6b-454c-8e51-ceb69d78e0ce...\n" ] } ], "source": [ - "xout, yout, wout = loess_1d.loess_1d(df1.index.astype(\"int64\"), df1[\"tas\"])" + "time_series = operations.get_coverage_time_series(\n", + " settings,\n", + " session,\n", + " http_client,\n", + " coverage_configuration=coverage_configuration,\n", + " coverage_identifier=coverage_identifier,\n", + " point_geom=POINT_GEOMS[\"near\"],\n", + " temporal_range=temporal_range,\n", + " include_coverage_data=True,\n", + " include_observation_data=True,\n", + " coverage_data_smoothing=CoverageDataSmoothingStrategy.LOESS_SMOOTHING,\n", + " observation_data_smoothing=ObservationDataSmoothingStrategy.MOVING_AVERAGE_5_YEARS,\n", + " include_coverage_uncertainty=False,\n", + " include_coverage_related_data=False\n", + ")\n", + "\n", + "station_series_name = [i for i in time_series.keys() if i.startswith(\"station\")][0]\n", + "\n", + "df1 = time_series[coverage_identifier]\n", + "df2 = time_series[station_series_name]" ] }, { "cell_type": "code", - "execution_count": 38, - "id": "3b6fdef4-ea4c-4eaa-9a1a-814a72742a69", + "execution_count": 3, + "id": "73ba59d8-9c20-4b17-8678-2cbb088ce315", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ab1283ec93864bc5858cb247941da7ec", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "\n", + "tas_line, = ax.plot(df1[coverage_identifier], label=coverage_identifier)\n", + "station_line, = ax.plot(df2[coverage_configuration.related_observation_variable.name], label=station_series_name)\n", + "tas_line.set_linestyle(\":\")\n", + "tas_line.set_marker(\".\")\n", + "station_line.set_linestyle(\":\")\n", + "station_line.set_marker(\".\")\n", + "\n", + "smoothed_tas_line, = ax.plot(df1[f\"smoothed_{coverage_identifier}\"], label=f\"smoothed_{coverage_identifier}_LOESS\")\n", + "\n", + "smoothed_station_line = ax.plot(df2[f\"smoothed_{coverage_configuration.related_observation_variable.name}\"], label=\"smoothed station data\")\n", + "\n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "414bda58-fbac-4bb3-9057-8de8d3dd53be", "metadata": {}, "outputs": [], "source": [ - "loess_lines, = ax.plot(df1.index, yout)" + "ax.clear()" ] }, { "cell_type": "code", - "execution_count": 35, - "id": "2a882067-bc3b-45c6-8973-7a487daee54a", + "execution_count": 7, + "id": "c2ea1b9f-0377-4e16-9e69-ed3871c01483", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Int64Index([ 193233600000000000, 224791024390000000, 256348448780000000,\n", - " 287905873171000000, 319463297561000000, 351020721951000000,\n", - " 382578146341000000, 414135570732000000, 445692995122000000,\n", - " 477250419512000000,\n", - " ...\n", - " 3790779980488000000, 3822337404878000000, 3853894829268000000,\n", - " 3885452253659000000, 3917009678049000000, 3948567102439000000,\n", - " 3980124526829000000, 4011681951220000000, 4043239375610000000,\n", - " 4074796800000000000],\n", - " dtype='int64', name='time', length=124)" + "" ] }, - "execution_count": 35, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "df1.index.astype(\"int64\")" + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "61dd07f7-24a8-46d1-88bf-ff8c289a173f", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEBUG:arpav_ppcv.operations:sorted_stations=[Station(id=UUID('d0e32657-3e6b-454c-8e51-ceb69d78e0ce'), active_since=datetime.date(1989, 1, 10), altitude_m=6.0, type_='agro', geom=, code='96', active_until=None, name='Bagnolo di Po - Pellizzare'), Station(id=UUID('608efa75-0148-4ba8-88b3-12a521b6eb18'), active_since=datetime.date(1989, 1, 17), altitude_m=6.0, type_='agro', geom=, code='99', active_until=None, name='San Bellino')]\n", + "DEBUG:arpav_ppcv.operations:Processing station d0e32657-3e6b-454c-8e51-ceb69d78e0ce...\n" + ] + } + ], + "source": [ + "time_series2 = operations.get_coverage_time_series(\n", + " settings,\n", + " session,\n", + " http_client,\n", + " coverage_configuration=coverage_configuration,\n", + " coverage_identifier=coverage_identifier,\n", + " point_geom=POINT_GEOMS[\"near\"],\n", + " temporal_range=temporal_range,\n", + " include_coverage_data=True,\n", + " include_observation_data=True,\n", + " coverage_data_smoothing=CoverageDataSmoothingStrategy.MOVING_AVERAGE_11_YEARS,\n", + " observation_data_smoothing=ObservationDataSmoothingStrategy.MOVING_AVERAGE_5_YEARS,\n", + " include_coverage_uncertainty=False,\n", + " include_coverage_related_data=False\n", + ")\n", + "\n", + "station_series_name2 = [i for i in time_series.keys() if i.startswith(\"station\")][0]\n", + "\n", + "df21 = time_series2[coverage_identifier]\n", + "df22 = time_series2[station_series_name]" ] }, { "cell_type": "code", - "execution_count": null, - "id": "f86dd11c-39b7-4232-b7e5-7089d12a54f2", + "execution_count": 6, + "id": "2fc9328e-54f0-47d0-8b59-698898d45572", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ax.plot(df21[f\"smoothed_{coverage_identifier}\"], label=f\"smoothed_{coverage_identifier}_(MA)\")" + ] } ], "metadata": { diff --git a/tests/notebooks/timeseries_via_api.ipynb b/tests/notebooks/timeseries_via_api.ipynb new file mode 100644 index 00000000..f5b95831 --- /dev/null +++ b/tests/notebooks/timeseries_via_api.ipynb @@ -0,0 +1,226 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1c84df8e-9d6a-4bb7-9b30-968e11bdb47f", + "metadata": {}, + "source": [ + "# Timeseries via API\n", + "\n", + "In this notebook we use the backend API to retrieve a time series and then plot it." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "ff511e0b-ab32-49a6-add1-28f5423929c9", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib widget\n", + "\n", + "import httpx\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "\n", + "coverage_identifier = \"tas_absolute-rcp26-DJF\"\n", + "point_coords = \"POINT(11.5469 44.9524)\"\n", + "date_range = \"../..\"\n", + "api_url = f\"http://webapp:5001/api/v2/coverages/time-series/{coverage_identifier}\"" + ] + }, + { + "cell_type": "markdown", + "id": "ca5e2e86-8f69-469f-aac7-fab0632fbe40", + "metadata": {}, + "source": [ + "### Time series without smoothing" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "d983c33d-f903-45e4-a5f2-930bcbe8b246", + "metadata": {}, + "outputs": [], + "source": [ + "raw_response = httpx.get(\n", + " api_url,\n", + " params={\n", + " \"coords\": point_coords,\n", + " \"datetime\": date_range,\n", + " \"include_coverage_data\": True,\n", + " \"include_observation_data\": True,\n", + " \"coverage_data_smoothing\": \"NO_SMOOTHING\",\n", + " \"observation_data_smoothing\": \"NO_SMOOTHING\",\n", + " \"include_coverage_uncertainty\": False,\n", + " \"include_coverage_related_data\": False,\n", + " }\n", + ")\n", + "raw_response.raise_for_status()\n", + "\n", + "raw_series = {}\n", + "for measurement in raw_response.json()[\"values\"]:\n", + " series_name = measurement[\"series\"]\n", + " measurement_series = raw_series.setdefault(series_name, list())\n", + " measurement_series.append({\"value\": measurement[\"value\"], \"datetime\": measurement[\"datetime\"]})\n", + "\n", + "raw_coverage_df = pd.DataFrame.from_dict(raw_series[coverage_identifier])\n", + "raw_station_df = pd.DataFrame.from_dict(raw_series[\"TDd\"])\n", + "\n", + "raw_coverage_df[\"datetime\"] = pd.to_datetime(raw_coverage_df[\"datetime\"])\n", + "raw_coverage_df.set_index(\"datetime\", inplace=True)\n", + "raw_station_df[\"datetime\"] = pd.to_datetime(raw_station_df[\"datetime\"])\n", + "raw_station_df.set_index(\"datetime\", inplace=True)" + ] + }, + { + "cell_type": "markdown", + "id": "c572ff75-6f0b-4f37-b5d5-16621ee12b61", + "metadata": {}, + "source": [ + "### Time series with smoothing" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "81ae9c67-5619-45bb-aa5b-1eb553b31388", + "metadata": {}, + "outputs": [], + "source": [ + "smoothed_response = httpx.get(\n", + " api_url,\n", + " params={\n", + " \"coords\": point_coords,\n", + " \"datetime\": date_range,\n", + " \"include_coverage_data\": True,\n", + " \"include_observation_data\": True,\n", + " \"coverage_data_smoothing\": \"MOVING_AVERAGE_11_YEARS\",\n", + " \"observation_data_smoothing\": \"MOVING_AVERAGE_5_YEARS\",\n", + " \"include_coverage_uncertainty\": False,\n", + " \"include_coverage_related_data\": False,\n", + " }\n", + ")\n", + "smoothed_response.raise_for_status()\n", + "\n", + "smoothed_series = {}\n", + "for measurement in smoothed_response.json()[\"values\"]:\n", + " series_name = measurement[\"series\"]\n", + " measurement_series = smoothed_series.setdefault(series_name, list())\n", + " measurement_series.append({\"value\": measurement[\"value\"], \"datetime\": measurement[\"datetime\"]})\n", + "\n", + "smoothed_coverage_df = pd.DataFrame.from_dict(smoothed_series[coverage_identifier])\n", + "smoothed_station_df = pd.DataFrame.from_dict(smoothed_series[\"TDd\"])\n", + "\n", + "smoothed_coverage_df[\"datetime\"] = pd.to_datetime(smoothed_coverage_df[\"datetime\"])\n", + "smoothed_coverage_df.set_index(\"datetime\", inplace=True)\n", + "smoothed_station_df[\"datetime\"] = pd.to_datetime(smoothed_station_df[\"datetime\"])\n", + "smoothed_station_df.set_index(\"datetime\", inplace=True)" + ] + }, + { + "cell_type": "markdown", + "id": "a39724be-fb1b-4fff-9a92-b5a4c0d70ae6", + "metadata": {}, + "source": [ + "### Plotting" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "9b1ddd10-6e0e-478f-babe-464e16dc07d3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e2e3dfa581204303bda7565fe2094952", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "raw_tas_line, = ax.plot(raw_coverage_df, label=f\"raw_{coverage_identifier}\")\n", + "raw_station_line, = ax.plot(raw_station_df, label=\"raw_TDd\")\n", + "raw_tas_line.set_linestyle(\":\")\n", + "raw_tas_line.set_marker(\".\")\n", + "raw_station_line.set_linestyle(\":\")\n", + "raw_station_line.set_marker(\".\")\n", + "\n", + "smoothed_tas_line, = ax.plot(smoothed_coverage_df, label=f\"smoothed_{coverage_identifier}\")\n", + "smoothed_station_line, = ax.plot(smoothed_station_df, label=\"smoothed_TDd\")\n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "ad36d2cb-c748-4076-944c-fffecf3c5818", + "metadata": {}, + "outputs": [], + "source": [ + "ax.clear()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2a6b9b95-aacb-4f4d-af08-50c60751675e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 923af9c72003775dd31506ef7bd28d0b32a33d0a Mon Sep 17 00:00:00 2001 From: Ricardo Garcia Silva Date: Thu, 16 May 2024 00:30:53 +0100 Subject: [PATCH 09/11] observations harvester cli app now allows multiple stations --- arpav_ppcv/observations_harvester/cliapp.py | 93 ++++++++++++------- .../observations_harvester/operations.py | 11 ++- 2 files changed, 66 insertions(+), 38 deletions(-) diff --git a/arpav_ppcv/observations_harvester/cliapp.py b/arpav_ppcv/observations_harvester/cliapp.py index f4a21a34..bdcde653 100644 --- a/arpav_ppcv/observations_harvester/cliapp.py +++ b/arpav_ppcv/observations_harvester/cliapp.py @@ -26,14 +26,15 @@ def refresh_stations(ctx: typer.Context) -> None: def refresh_monthly_measurements( ctx: typer.Context, station: Annotated[ - str, + list[str], typer.Option( + default_factory=list, help=( "Code of the station to process. If not provided, all " "stations are processed." ) ) - ] = None, + ], variable: Annotated[ str, typer.Option( @@ -46,34 +47,37 @@ def refresh_monthly_measurements( ) -> None: client = httpx.Client() with sqlmodel.Session(ctx.obj["engine"]) as session: - created = _refresh_measurements( - session, - client, - variable, - station, - "monthly" - ) - print(f"Created {len(created)} monthly measurements:") - print( - "\n".join( - f"{m.station.code}-{m.variable.name}-{m.date.strftime('%Y-%m-%d')}" - for m in created + for station_code in station: + print(f"Processing station: {station_code!r}...") + created = _refresh_measurements( + session, + client, + variable, + station_code, + "monthly" + ) + print(f"Created {len(created)} monthly measurements:") + print( + "\n".join( + f"{m.station.code}-{m.variable.name}-{m.date.strftime('%Y-%m-%d')}" + for m in created + ) ) - ) @app.command() def refresh_seasonal_measurements( ctx: typer.Context, station: Annotated[ - str, + list[str], typer.Option( + default_factory=list, help=( "Code of the station to process. If not provided, all " "stations are processed." ) ) - ] = None, + ], variable: Annotated[ str, typer.Option( @@ -86,13 +90,24 @@ def refresh_seasonal_measurements( ) -> None: client = httpx.Client() with sqlmodel.Session(ctx.obj["engine"]) as session: - created = _refresh_measurements( - session, - client, - variable, - station, - "seasonal" - ) + if len(station) > 0: + for station_code in station: + print(f"Processing station {station_code!r}...") + created = _refresh_measurements( + session, + client, + variable, + station_code, + "seasonal" + ) + else: + created = _refresh_measurements( + session, + client, + variable, + None, + "seasonal" + ) print(f"Created {len(created)} seasonal measurements:") print( "\n".join( @@ -106,14 +121,15 @@ def refresh_seasonal_measurements( def refresh_yearly_measurements( ctx: typer.Context, station: Annotated[ - str, + list[str], typer.Option( + default_factory=list, help=( "Code of the station to process. If not provided, all " "stations are processed." ) ) - ] = None, + ], variable: Annotated[ str, typer.Option( @@ -126,13 +142,24 @@ def refresh_yearly_measurements( ) -> None: client = httpx.Client() with sqlmodel.Session(ctx.obj["engine"]) as session: - created = _refresh_measurements( - session, - client, - variable, - station, - "yearly" - ) + if len(station) > 0: + for station_code in station: + print(f"Processing station {station_code!r}...") + created = _refresh_measurements( + session, + client, + variable, + station_code, + "yearly" + ) + else: + created = _refresh_measurements( + session, + client, + variable, + None, + "yearly" + ) print(f"Created {len(created)} yearly measurements:") print( "\n".join( diff --git a/arpav_ppcv/observations_harvester/operations.py b/arpav_ppcv/observations_harvester/operations.py index 923e3140..e74221d6 100644 --- a/arpav_ppcv/observations_harvester/operations.py +++ b/arpav_ppcv/observations_harvester/operations.py @@ -13,6 +13,7 @@ from .. import ( database, ) +from ..schemas.base import Season from ..schemas import observations logger = logging.getLogger(__name__) @@ -186,7 +187,7 @@ def harvest_seasonal_measurements( f"\tProcessing variable {variable.name!r} ({var_idx+1}/" f"{len(existing_variables)})..." ) - for current_season in observations.Season: + for current_season in Season: logger.info( f"\t\tProcessing season {current_season!r}...") existing_measurements = database.collect_all_seasonal_measurements( @@ -201,10 +202,10 @@ def harvest_seasonal_measurements( existing[measurement_id] = db_measurement season_query_param = { - observations.Season.WINTER: 1, - observations.Season.SPRING: 2, - observations.Season.SUMMER: 3, - observations.Season.AUTUMN: 4, + Season.WINTER: 1, + Season.SPRING: 2, + Season.SUMMER: 3, + Season.AUTUMN: 4, }[current_season] response = client.get( "https://api.arpa.veneto.it/REST/v1/clima_indicatori", From 9d7510e49bcf508a365ff01530db2f251035c1f6 Mon Sep 17 00:00:00 2001 From: Ricardo Garcia Silva Date: Fri, 17 May 2024 12:08:28 +0100 Subject: [PATCH 10/11] Allow a list of smoothing strategies and also modified the response --- arpav_ppcv/operations.py | 41 +++--- arpav_ppcv/webapp/api_v2/routers/coverages.py | 110 +++++++++----- arpav_ppcv/webapp/api_v2/schemas/coverages.py | 8 +- tests/notebooks/timeseries.ipynb | 136 +++++------------- tests/notebooks/timeseries_via_api.ipynb | 107 +++++--------- 5 files changed, 177 insertions(+), 225 deletions(-) diff --git a/arpav_ppcv/operations.py b/arpav_ppcv/operations.py index fd2b9e4f..2a2f356e 100644 --- a/arpav_ppcv/operations.py +++ b/arpav_ppcv/operations.py @@ -36,8 +36,8 @@ def get_coverage_time_series( coverage_identifier: str, point_geom: shapely.Point, temporal_range: str, - coverage_data_smoothing: base.CoverageDataSmoothingStrategy, - observation_data_smoothing: base.ObservationDataSmoothingStrategy, + coverage_data_smoothing: list[base.CoverageDataSmoothingStrategy], + observation_data_smoothing: list[base.ObservationDataSmoothingStrategy], include_coverage_data: bool = True, include_observation_data: bool = False, include_coverage_uncertainty: bool = False, @@ -87,7 +87,7 @@ def get_coverage_time_series( time_start=start, time_end=end ) - station_data_series_key = "-".join(( + station_data_series_key = "_".join(( "station", str(station.id), coverage_configuration.related_observation_variable.name, @@ -175,7 +175,7 @@ def _get_station_data( def _process_seasonal_station_data( variable: observations.Variable, raw_data: list[observations.SeasonalMeasurement], - data_smoothing: base.ObservationDataSmoothingStrategy, + data_smoothing: list[base.ObservationDataSmoothingStrategy], time_start: Optional[dt.datetime], time_end: Optional[dt.datetime], ) -> pd.DataFrame: @@ -201,10 +201,14 @@ def _process_seasonal_station_data( df = df[time_start:] if time_end is not None: df = df[:time_end] - smoothed_key = f"smoothed_{variable.name}" - if data_smoothing == base.ObservationDataSmoothingStrategy.MOVING_AVERAGE_5_YEARS: - df[smoothed_key] = df[variable.name].rolling(window=5, center=True).mean() - df = df.dropna() + for strategy in data_smoothing: + column_name = "__".join((variable.name, strategy.value)) + if strategy == base.ObservationDataSmoothingStrategy.NO_SMOOTHING: + df[column_name] = df[variable.name] + elif strategy == base.ObservationDataSmoothingStrategy.MOVING_AVERAGE_5_YEARS: + df[column_name] = df[variable.name].rolling(window=5, center=True).mean() + df = df.drop(columns=[variable.name]) + df = df.dropna() return df @@ -212,7 +216,7 @@ def _process_coverage_data( raw_data: str, coverage_configuration: coverages.CoverageConfiguration, coverage_identifier: str, - data_smoothing: base.CoverageDataSmoothingStrategy, + data_smoothing: list[base.CoverageDataSmoothingStrategy], time_start: Optional[dt.datetime], time_end: Optional[dt.datetime], ) -> pd.DataFrame: @@ -238,19 +242,22 @@ def _process_coverage_data( df = df[time_start:] if time_end is not None: df = df[:time_end] - if data_smoothing != base.CoverageDataSmoothingStrategy.NO_SMOOTHING: - smoothed_key = f"smoothed_{coverage_identifier}" - if data_smoothing == base.CoverageDataSmoothingStrategy.MOVING_AVERAGE_11_YEARS: - df[smoothed_key] = df[coverage_identifier].rolling( + for strategy in data_smoothing: + column_name = "__".join((coverage_identifier, strategy.value)) + if strategy == base.CoverageDataSmoothingStrategy.NO_SMOOTHING: + df[column_name] = df[coverage_identifier] + elif strategy == base.CoverageDataSmoothingStrategy.MOVING_AVERAGE_11_YEARS: + df[column_name] = df[coverage_identifier].rolling( center=True, window=11).mean() - elif data_smoothing == base.CoverageDataSmoothingStrategy.LOESS_SMOOTHING: + elif strategy == base.CoverageDataSmoothingStrategy.LOESS_SMOOTHING: _, loess_smoothed, _ = loess_1d( df.index.astype("int64"), df[coverage_identifier], ) - df[smoothed_key] = loess_smoothed - df = df.dropna() - return df + df[column_name] = loess_smoothed + df = df.drop(columns=[coverage_identifier]) + df = df.dropna() + return df def _parse_temporal_range( diff --git a/arpav_ppcv/webapp/api_v2/routers/coverages.py b/arpav_ppcv/webapp/api_v2/routers/coverages.py index 21bee664..7ab4fcfd 100644 --- a/arpav_ppcv/webapp/api_v2/routers/coverages.py +++ b/arpav_ppcv/webapp/api_v2/routers/coverages.py @@ -1,5 +1,6 @@ import logging import urllib.parse +import uuid from typing import ( Annotated, Optional, @@ -12,6 +13,7 @@ APIRouter, Depends, HTTPException, + Query, Request, Response, status, @@ -24,7 +26,10 @@ ) from ....config import ArpavPpcvSettings from ....thredds import utils as thredds_utils -from ....schemas import base +from ....schemas.base import ( + CoverageDataSmoothingStrategy, + ObservationDataSmoothingStrategy, +) from ... import dependencies from ..schemas import coverages as coverage_schemas @@ -196,7 +201,7 @@ async def wms_endpoint( @router.get( - "/time-series/{coverage_identifier}", response_model=coverage_schemas.TimeSeries) + "/time-series/{coverage_identifier}", response_model=coverage_schemas.TimeSeriesList) def get_time_series( db_session: Annotated[Session, Depends(dependencies.get_db_session)], settings: Annotated[ArpavPpcvSettings, Depends(dependencies.get_settings)], @@ -206,10 +211,14 @@ def get_time_series( datetime: Optional[str] = "../..", include_coverage_data: bool = True, include_observation_data: bool = False, - coverage_data_smoothing: base.CoverageDataSmoothingStrategy = ( - base.CoverageDataSmoothingStrategy.NO_SMOOTHING), - observation_data_smoothing: base.ObservationDataSmoothingStrategy = ( - base.ObservationDataSmoothingStrategy.NO_SMOOTHING), + coverage_data_smoothing: Annotated[ + list[CoverageDataSmoothingStrategy], + Query() + ] = [ObservationDataSmoothingStrategy.NO_SMOOTHING], # noqa + observation_data_smoothing: Annotated[ + list[ObservationDataSmoothingStrategy], + Query() + ] = [ObservationDataSmoothingStrategy.NO_SMOOTHING], # noqa include_coverage_uncertainty: bool = False, include_coverage_related_data: bool = False, ): @@ -246,45 +255,74 @@ def get_time_series( include_coverage_uncertainty=include_coverage_uncertainty, include_coverage_related_data=include_coverage_related_data, ) - measurements = [] coverage_df = time_series[coverage_identifier] + series = [] if include_coverage_data: - series_key = ( - f"smoothed_{coverage_identifier}" if - coverage_data_smoothing != base.CoverageDataSmoothingStrategy.NO_SMOOTHING - else coverage_identifier - ) - for timestamp, value in coverage_df.to_dict()[series_key].items(): - measurements.append( - coverage_schemas.TimeSeriesItem( - value=value, - series=coverage_identifier, - datetime=timestamp + for series_name, series_measurements in coverage_df.to_dict().items(): + name_prefix, smoothing_strategy = series_name.rpartition("__")[::2] + smoothed_with = CoverageDataSmoothingStrategy(smoothing_strategy) + if ( + smoothed_with == CoverageDataSmoothingStrategy.NO_SMOOTHING and + CoverageDataSmoothingStrategy.NO_SMOOTHING not in coverage_data_smoothing + ): + continue # client did not ask for the NO_SMOOTHING strategy + else: + measurements = [] + for timestamp, value in series_measurements.items(): + measurements.append( + coverage_schemas.TimeSeriesItem( + value=value, datetime=timestamp) + ) + series.append( + coverage_schemas.TimeSeries( + name=series_name, + values=measurements, + info={ + "coverage_identifier": coverage_identifier, + "smoothing": smoothing_strategy.lower() + } + ) ) - ) + if include_observation_data: variable = db_coverage_configuration.related_observation_variable - obs_df_name = [ - n for n in time_series.keys() if n.startswith('station-')][0] - obs_df = time_series[obs_df_name] - series_key = ( - f"smoothed_{variable.name}" - if observation_data_smoothing != base.ObservationDataSmoothingStrategy.NO_SMOOTHING - else variable.name - ) - for timestamp, value in obs_df.to_dict()[series_key].items(): - measurements.append( - coverage_schemas.TimeSeriesItem( - value=value, - series=variable.name, - datetime=timestamp - ) - ) + for df_name, df in time_series.items(): + if df_name.startswith("station_"): + station_id = uuid.UUID(df_name.split("_")[1]) + db_station = db.get_station(db_session, station_id) + for series_name, series_measurements in df.to_dict().items(): + name_prefix, smoothing_strategy = series_name.rpartition("__")[::2] + smoothed_with = ObservationDataSmoothingStrategy(smoothing_strategy) + if ( + smoothed_with == ObservationDataSmoothingStrategy.NO_SMOOTHING and + ObservationDataSmoothingStrategy.NO_SMOOTHING not in observation_data_smoothing + ): + continue # client did not ask for the NO_SMOOTHING strategy + else: + measurements = [] + for timestamp, value in series_measurements.items(): + measurements.append( + coverage_schemas.TimeSeriesItem( + value=value, datetime=timestamp) + ) + series.append( + coverage_schemas.TimeSeries( + name=series_name, + values=measurements, + info={ + "station_id": str(db_station.id), + "station_name": db_station.name, + "variable_name": variable.name, + "variable_description": variable.description, + "smoothing": smoothing_strategy.lower() + } + ), + ) if include_coverage_uncertainty: ... if include_coverage_related_data: ... - return coverage_schemas.TimeSeries(values=measurements) + return coverage_schemas.TimeSeriesList(series=series) else: raise HTTPException(status_code=400, detail="Invalid coverage_identifier") diff --git a/arpav_ppcv/webapp/api_v2/schemas/coverages.py b/arpav_ppcv/webapp/api_v2/schemas/coverages.py index 908d4e70..9b6fb3e5 100644 --- a/arpav_ppcv/webapp/api_v2/schemas/coverages.py +++ b/arpav_ppcv/webapp/api_v2/schemas/coverages.py @@ -1,5 +1,6 @@ import datetime as dt import uuid +from typing import Optional import pydantic from fastapi import Request @@ -97,9 +98,14 @@ class ForecastModelScenarioList(WebResourceList): class TimeSeriesItem(pydantic.BaseModel): value: float - series: str datetime: dt.datetime class TimeSeries(pydantic.BaseModel): + name: str values: list[TimeSeriesItem] + info: Optional[dict[str, str]] = None + + +class TimeSeriesList(pydantic.BaseModel): + series: list[TimeSeries] diff --git a/tests/notebooks/timeseries.ipynb b/tests/notebooks/timeseries.ipynb index 51b50df8..3529ebe0 100644 --- a/tests/notebooks/timeseries.ipynb +++ b/tests/notebooks/timeseries.ipynb @@ -73,8 +73,8 @@ }, { "cell_type": "code", - "execution_count": 2, - "id": "fee64549-56ef-40d0-8a31-e27594b363c0", + "execution_count": 7, + "id": "e7f37a28-5d1e-4787-b3c8-1e4ad177fedf", "metadata": { "scrolled": true }, @@ -579,7 +579,7 @@ " a = x[:, None]**np.arange(degree + 1)\n", "/home/appuser/.cache/pypoetry/virtualenvs/arpav-ppcv-backend-f8CPI8sp-py3.10/lib/python3.10/site-packages/loess/loess_1d.py:83: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n", " self.coeff = np.linalg.lstsq(a*sqw[:, None], y*sqw, rcond=None)[0]\n", - "DEBUG:arpav_ppcv.operations:sorted_stations=[Station(id=UUID('d0e32657-3e6b-454c-8e51-ceb69d78e0ce'), active_since=datetime.date(1989, 1, 10), altitude_m=6.0, type_='agro', geom=, code='96', active_until=None, name='Bagnolo di Po - Pellizzare'), Station(id=UUID('608efa75-0148-4ba8-88b3-12a521b6eb18'), active_since=datetime.date(1989, 1, 17), altitude_m=6.0, type_='agro', geom=, code='99', active_until=None, name='San Bellino')]\n", + "DEBUG:arpav_ppcv.operations:sorted_stations=[Station(id=UUID('d0e32657-3e6b-454c-8e51-ceb69d78e0ce'), active_since=datetime.date(1989, 1, 10), altitude_m=6.0, type_='agro', geom=, code='96', active_until=None, name='Bagnolo di Po - Pellizzare'), Station(id=UUID('608efa75-0148-4ba8-88b3-12a521b6eb18'), active_since=datetime.date(1989, 1, 17), altitude_m=6.0, type_='agro', geom=, code='99', active_until=None, name='San Bellino')]\n", "DEBUG:arpav_ppcv.operations:Processing station d0e32657-3e6b-454c-8e51-ceb69d78e0ce...\n" ] } @@ -595,12 +595,29 @@ " temporal_range=temporal_range,\n", " include_coverage_data=True,\n", " include_observation_data=True,\n", - " coverage_data_smoothing=CoverageDataSmoothingStrategy.LOESS_SMOOTHING,\n", - " observation_data_smoothing=ObservationDataSmoothingStrategy.MOVING_AVERAGE_5_YEARS,\n", + " coverage_data_smoothing=[\n", + " CoverageDataSmoothingStrategy.NO_SMOOTHING,\n", + " CoverageDataSmoothingStrategy.LOESS_SMOOTHING,\n", + " CoverageDataSmoothingStrategy.MOVING_AVERAGE_11_YEARS,\n", + " ],\n", + " observation_data_smoothing=[\n", + " ObservationDataSmoothingStrategy.NO_SMOOTHING, \n", + " ObservationDataSmoothingStrategy.MOVING_AVERAGE_5_YEARS,\n", + " ],\n", " include_coverage_uncertainty=False,\n", " include_coverage_related_data=False\n", - ")\n", - "\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "aed3a45b-2416-4689-a5c4-fffab570a252", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ "station_series_name = [i for i in time_series.keys() if i.startswith(\"station\")][0]\n", "\n", "df1 = time_series[coverage_identifier]\n", @@ -609,35 +626,35 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 9, "id": "73ba59d8-9c20-4b17-8678-2cbb088ce315", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 3, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ab1283ec93864bc5858cb247941da7ec", + "model_id": "03918bdfef5a4581ac1ac187280d5d6c", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -652,111 +669,30 @@ "source": [ "fig, ax = plt.subplots()\n", "\n", - "tas_line, = ax.plot(df1[coverage_identifier], label=coverage_identifier)\n", - "station_line, = ax.plot(df2[coverage_configuration.related_observation_variable.name], label=station_series_name)\n", + "tas_line, = ax.plot(df1[f\"{coverage_identifier}__NO_SMOOTHING\"], label=coverage_identifier)\n", + "station_line, = ax.plot(df2[f\"{coverage_configuration.related_observation_variable.name}__NO_SMOOTHING\"], label=station_series_name)\n", "tas_line.set_linestyle(\":\")\n", "tas_line.set_marker(\".\")\n", "station_line.set_linestyle(\":\")\n", "station_line.set_marker(\".\")\n", "\n", - "smoothed_tas_line, = ax.plot(df1[f\"smoothed_{coverage_identifier}\"], label=f\"smoothed_{coverage_identifier}_LOESS\")\n", + "loess_smoothed_tas_line, = ax.plot(df1[f\"{coverage_identifier}__LOESS_SMOOTHING\"], label=f\"{coverage_identifier}_LOESS\")\n", + "ma11_smoothed_tas_line, = ax.plot(df1[f\"{coverage_identifier}__MOVING_AVERAGE_11_YEARS\"], label=f\"{coverage_identifier}_ma11\")\n", "\n", - "smoothed_station_line = ax.plot(df2[f\"smoothed_{coverage_configuration.related_observation_variable.name}\"], label=\"smoothed station data\")\n", + "mma5_smoothed_station_line = ax.plot(df2[f\"{coverage_configuration.related_observation_variable.name}__MOVING_AVERAGE_5_YEARS\"], label=\"smoothed station data ma5\")\n", "\n", "ax.legend()" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "414bda58-fbac-4bb3-9057-8de8d3dd53be", "metadata": {}, "outputs": [], "source": [ "ax.clear()" ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "c2ea1b9f-0377-4e16-9e69-ed3871c01483", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ax.legend()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "61dd07f7-24a8-46d1-88bf-ff8c289a173f", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:arpav_ppcv.operations:sorted_stations=[Station(id=UUID('d0e32657-3e6b-454c-8e51-ceb69d78e0ce'), active_since=datetime.date(1989, 1, 10), altitude_m=6.0, type_='agro', geom=, code='96', active_until=None, name='Bagnolo di Po - Pellizzare'), Station(id=UUID('608efa75-0148-4ba8-88b3-12a521b6eb18'), active_since=datetime.date(1989, 1, 17), altitude_m=6.0, type_='agro', geom=, code='99', active_until=None, name='San Bellino')]\n", - "DEBUG:arpav_ppcv.operations:Processing station d0e32657-3e6b-454c-8e51-ceb69d78e0ce...\n" - ] - } - ], - "source": [ - "time_series2 = operations.get_coverage_time_series(\n", - " settings,\n", - " session,\n", - " http_client,\n", - " coverage_configuration=coverage_configuration,\n", - " coverage_identifier=coverage_identifier,\n", - " point_geom=POINT_GEOMS[\"near\"],\n", - " temporal_range=temporal_range,\n", - " include_coverage_data=True,\n", - " include_observation_data=True,\n", - " coverage_data_smoothing=CoverageDataSmoothingStrategy.MOVING_AVERAGE_11_YEARS,\n", - " observation_data_smoothing=ObservationDataSmoothingStrategy.MOVING_AVERAGE_5_YEARS,\n", - " include_coverage_uncertainty=False,\n", - " include_coverage_related_data=False\n", - ")\n", - "\n", - "station_series_name2 = [i for i in time_series.keys() if i.startswith(\"station\")][0]\n", - "\n", - "df21 = time_series2[coverage_identifier]\n", - "df22 = time_series2[station_series_name]" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "2fc9328e-54f0-47d0-8b59-698898d45572", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ax.plot(df21[f\"smoothed_{coverage_identifier}\"], label=f\"smoothed_{coverage_identifier}_(MA)\")" - ] } ], "metadata": { diff --git a/tests/notebooks/timeseries_via_api.ipynb b/tests/notebooks/timeseries_via_api.ipynb index f5b95831..de8d3e18 100644 --- a/tests/notebooks/timeseries_via_api.ipynb +++ b/tests/notebooks/timeseries_via_api.ipynb @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 2, "id": "ff511e0b-ab32-49a6-add1-28f5423929c9", "metadata": {}, "outputs": [], @@ -29,17 +29,9 @@ "api_url = f\"http://webapp:5001/api/v2/coverages/time-series/{coverage_identifier}\"" ] }, - { - "cell_type": "markdown", - "id": "ca5e2e86-8f69-469f-aac7-fab0632fbe40", - "metadata": {}, - "source": [ - "### Time series without smoothing" - ] - }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 8, "id": "d983c33d-f903-45e4-a5f2-930bcbe8b246", "metadata": {}, "outputs": [], @@ -51,72 +43,44 @@ " \"datetime\": date_range,\n", " \"include_coverage_data\": True,\n", " \"include_observation_data\": True,\n", - " \"coverage_data_smoothing\": \"NO_SMOOTHING\",\n", - " \"observation_data_smoothing\": \"NO_SMOOTHING\",\n", + " \"coverage_data_smoothing\": [\n", + " \"NO_SMOOTHING\",\n", + " \"MOVING_AVERAGE_11_YEARS\",\n", + " \"LOESS_SMOOTHING\",\n", + " ],\n", + " \"observation_data_smoothing\": [\n", + " \"NO_SMOOTHING\",\n", + " \"MOVING_AVERAGE_5_YEARS\",\n", + " ],\n", " \"include_coverage_uncertainty\": False,\n", " \"include_coverage_related_data\": False,\n", " }\n", ")\n", "raw_response.raise_for_status()\n", "\n", - "raw_series = {}\n", - "for measurement in raw_response.json()[\"values\"]:\n", - " series_name = measurement[\"series\"]\n", - " measurement_series = raw_series.setdefault(series_name, list())\n", - " measurement_series.append({\"value\": measurement[\"value\"], \"datetime\": measurement[\"datetime\"]})\n", + "raw_series = raw_response.json()[\"series\"]\n", "\n", - "raw_coverage_df = pd.DataFrame.from_dict(raw_series[coverage_identifier])\n", - "raw_station_df = pd.DataFrame.from_dict(raw_series[\"TDd\"])\n", + "series = {s[\"name\"]: s for s in raw_series}\n", "\n", + "raw_coverage_df = pd.DataFrame.from_records(series[f\"{coverage_identifier}__NO_SMOOTHING\"][\"values\"])\n", "raw_coverage_df[\"datetime\"] = pd.to_datetime(raw_coverage_df[\"datetime\"])\n", "raw_coverage_df.set_index(\"datetime\", inplace=True)\n", - "raw_station_df[\"datetime\"] = pd.to_datetime(raw_station_df[\"datetime\"])\n", - "raw_station_df.set_index(\"datetime\", inplace=True)" - ] - }, - { - "cell_type": "markdown", - "id": "c572ff75-6f0b-4f37-b5d5-16621ee12b61", - "metadata": {}, - "source": [ - "### Time series with smoothing" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "81ae9c67-5619-45bb-aa5b-1eb553b31388", - "metadata": {}, - "outputs": [], - "source": [ - "smoothed_response = httpx.get(\n", - " api_url,\n", - " params={\n", - " \"coords\": point_coords,\n", - " \"datetime\": date_range,\n", - " \"include_coverage_data\": True,\n", - " \"include_observation_data\": True,\n", - " \"coverage_data_smoothing\": \"MOVING_AVERAGE_11_YEARS\",\n", - " \"observation_data_smoothing\": \"MOVING_AVERAGE_5_YEARS\",\n", - " \"include_coverage_uncertainty\": False,\n", - " \"include_coverage_related_data\": False,\n", - " }\n", - ")\n", - "smoothed_response.raise_for_status()\n", "\n", - "smoothed_series = {}\n", - "for measurement in smoothed_response.json()[\"values\"]:\n", - " series_name = measurement[\"series\"]\n", - " measurement_series = smoothed_series.setdefault(series_name, list())\n", - " measurement_series.append({\"value\": measurement[\"value\"], \"datetime\": measurement[\"datetime\"]})\n", + "smoothed_ma11_coverage_df = pd.DataFrame.from_records(series[f\"{coverage_identifier}__MOVING_AVERAGE_11_YEARS\"][\"values\"])\n", + "smoothed_ma11_coverage_df[\"datetime\"] = pd.to_datetime(smoothed_ma11_coverage_df[\"datetime\"])\n", + "smoothed_ma11_coverage_df.set_index(\"datetime\", inplace=True)\n", "\n", - "smoothed_coverage_df = pd.DataFrame.from_dict(smoothed_series[coverage_identifier])\n", - "smoothed_station_df = pd.DataFrame.from_dict(smoothed_series[\"TDd\"])\n", + "smoothed_loess_coverage_df = pd.DataFrame.from_records(series[f\"{coverage_identifier}__LOESS_SMOOTHING\"][\"values\"])\n", + "smoothed_loess_coverage_df[\"datetime\"] = pd.to_datetime(smoothed_loess_coverage_df[\"datetime\"])\n", + "smoothed_loess_coverage_df.set_index(\"datetime\", inplace=True)\n", + "\n", + "raw_station_df = pd.DataFrame.from_records(series[\"TDd__NO_SMOOTHING\"][\"values\"])\n", + "raw_station_df[\"datetime\"] = pd.to_datetime(raw_station_df[\"datetime\"])\n", + "raw_station_df.set_index(\"datetime\", inplace=True)\n", "\n", - "smoothed_coverage_df[\"datetime\"] = pd.to_datetime(smoothed_coverage_df[\"datetime\"])\n", - "smoothed_coverage_df.set_index(\"datetime\", inplace=True)\n", - "smoothed_station_df[\"datetime\"] = pd.to_datetime(smoothed_station_df[\"datetime\"])\n", - "smoothed_station_df.set_index(\"datetime\", inplace=True)" + "smoothed_ma5_station_df = pd.DataFrame.from_records(series[\"TDd__MOVING_AVERAGE_5_YEARS\"][\"values\"])\n", + "smoothed_ma5_station_df[\"datetime\"] = pd.to_datetime(smoothed_ma5_station_df[\"datetime\"])\n", + "smoothed_ma5_station_df.set_index(\"datetime\", inplace=True)\n" ] }, { @@ -129,35 +93,35 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 10, "id": "9b1ddd10-6e0e-478f-babe-464e16dc07d3", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 28, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e2e3dfa581204303bda7565fe2094952", + "model_id": "8c9e53dd71264883b97771e771c792b4", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -178,8 +142,9 @@ "raw_station_line.set_linestyle(\":\")\n", "raw_station_line.set_marker(\".\")\n", "\n", - "smoothed_tas_line, = ax.plot(smoothed_coverage_df, label=f\"smoothed_{coverage_identifier}\")\n", - "smoothed_station_line, = ax.plot(smoothed_station_df, label=\"smoothed_TDd\")\n", + "smoothed_ma11_tas_line, = ax.plot(smoothed_ma11_coverage_df, label=f\"smoothed_{coverage_identifier}_ma11\")\n", + "smoothed_loess_tas_line, = ax.plot(smoothed_loess_coverage_df, label=f\"smoothed_{coverage_identifier}_loess\")\n", + "smoothed_ma5_station_line, = ax.plot(smoothed_ma5_station_df, label=\"smoothed_TDd_ma5\")\n", "ax.legend()" ] }, From 2dc4620bd3e3a6aa5be5e87ccc8e19190ed0a061 Mon Sep 17 00:00:00 2001 From: Ricardo Garcia Silva Date: Fri, 17 May 2024 12:46:22 +0100 Subject: [PATCH 11/11] Fixed bugs in bootstrapper --- arpav_ppcv/bootstrapper/cliapp.py | 3 ++- arpav_ppcv/database.py | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/arpav_ppcv/bootstrapper/cliapp.py b/arpav_ppcv/bootstrapper/cliapp.py index e195c61b..fef937dc 100644 --- a/arpav_ppcv/bootstrapper/cliapp.py +++ b/arpav_ppcv/bootstrapper/cliapp.py @@ -6,6 +6,7 @@ from .. import database from ..schemas import ( + base, coverages, observations, ) @@ -194,7 +195,7 @@ def bootstrap_coverage_configurations( ), ], observation_variable_id=v.id if (v := variables.get("TDd")) is not None else None, - observation_variable_aggregation_type=coverages.ObservationAggregationType.SEASONAL + observation_variable_aggregation_type=base.ObservationAggregationType.SEASONAL ), ] for cov_conf_create in coverage_configurations: diff --git a/arpav_ppcv/database.py b/arpav_ppcv/database.py index 59fcd200..511b84a5 100644 --- a/arpav_ppcv/database.py +++ b/arpav_ppcv/database.py @@ -845,7 +845,7 @@ def create_coverage_configuration( palette=coverage_configuration_create.palette, color_scale_min=coverage_configuration_create.color_scale_min, color_scale_max=coverage_configuration_create.color_scale_max, - related_observation_variable=coverage_configuration_create.related_observation_variable, + observation_variable_id=coverage_configuration_create.observation_variable_id, observation_variable_aggregation_type=coverage_configuration_create.observation_variable_aggregation_type, ) session.add(db_coverage_configuration)