Update neptune retrieval API

Re-generate retrieval api using swagger taken from
neptune staging environment (which I think at this point
should match last release)

Author: Maciek Pytel

src/neptune_retrieval_api/api/default/__init__.py

@@ -12,3 +12,4 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+

src/neptune_retrieval_api/models/__init__.py

@@ -246,6 +246,7 @@
 from .signal_body import SignalBody
 from .single_custom_time_series_view import SingleCustomTimeSeriesView
 from .single_time_series_view import SingleTimeSeriesView
+from .single_time_series_view_bucket import SingleTimeSeriesViewBucket
 from .steps import Steps
 from .string_attribute_dto import StringAttributeDTO
 from .string_point_value_dto import StringPointValueDTO
@@ -498,6 +499,7 @@
     "SignalBody",
     "SingleCustomTimeSeriesView",
     "SingleTimeSeriesView",
+    "SingleTimeSeriesViewBucket",
     "Steps",
     "StringAttributeDTO",
     "StringPointValueDTO",

src/neptune_retrieval_api/models/attribute_name_filter_dto.py

@@ -38,17 +38,30 @@
 class AttributeNameFilterDTO:
     """
     Attributes:
+        must_match_any (Union[Unset, List['AttributeNameFilterDTO']]): A list of filters representing disjunctions of
+            conjunctive simple filters. The implementation is currently limited to 1 level of nesting. E.g. `(a AND b AND
+            NOT c) OR (d AND e) OR (f AND g)` is supported, but `(a OR (b OR c))` is not supported. The latter should be
+            expressed as `(a OR b OR c)`. `(a AND (b OR c))` is also not supported. Mutually exclusive with
+            `mustMatchRegexes` and `mustNotMatchRegexes`.
         must_match_regexes (Union[Unset, List[str]]): An attribute must match all of the regexes from the list to be
-            returned
+            returned. Mutually exclusive with `mustMatchAny`
         must_not_match_regexes (Union[Unset, List[str]]): An attribute must match none of the regexes from the list to
-            be returned
+            be returned. Mutually exclusive with `mustMatchAny`
     """
 
+    must_match_any: Union[Unset, List["AttributeNameFilterDTO"]] = UNSET
     must_match_regexes: Union[Unset, List[str]] = UNSET
     must_not_match_regexes: Union[Unset, List[str]] = UNSET
     additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> Dict[str, Any]:
+        must_match_any: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.must_match_any, Unset):
+            must_match_any = []
+            for must_match_any_item_data in self.must_match_any:
+                must_match_any_item = must_match_any_item_data.to_dict()
+                must_match_any.append(must_match_any_item)
+
         must_match_regexes: Union[Unset, List[str]] = UNSET
         if not isinstance(self.must_match_regexes, Unset):
             must_match_regexes = self.must_match_regexes
@@ -60,6 +73,8 @@ def to_dict(self) -> Dict[str, Any]:
         field_dict: Dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update({})
+        if must_match_any is not UNSET:
+            field_dict["mustMatchAny"] = must_match_any
         if must_match_regexes is not UNSET:
             field_dict["mustMatchRegexes"] = must_match_regexes
         if must_not_match_regexes is not UNSET:
@@ -70,11 +85,19 @@ def to_dict(self) -> Dict[str, Any]:
     @classmethod
     def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
         d = src_dict.copy()
+        must_match_any = []
+        _must_match_any = d.pop("mustMatchAny", UNSET)
+        for must_match_any_item_data in _must_match_any or []:
+            must_match_any_item = AttributeNameFilterDTO.from_dict(must_match_any_item_data)
+
+            must_match_any.append(must_match_any_item)
+
         must_match_regexes = cast(List[str], d.pop("mustMatchRegexes", UNSET))
 
         must_not_match_regexes = cast(List[str], d.pop("mustNotMatchRegexes", UNSET))
 
         attribute_name_filter_dto = cls(
+            must_match_any=must_match_any,
             must_match_regexes=must_match_regexes,
             must_not_match_regexes=must_not_match_regexes,
         )

src/neptune_retrieval_api/models/dashboard_config_dto.py

@@ -47,6 +47,7 @@ class DashboardConfigDTO:
         smoothing (Union[Unset, int]):
         xaxis_metric (Union[Unset, AttributeDefinitionDTO]):
         xaxis_mode (Union[Unset, str]):
+        xaxis_range (Union[Unset, OpenRangeDTO]):
         xaxis_scale (Union[Unset, str]):
         yaxis_scale (Union[Unset, str]):
     """
@@ -55,6 +56,7 @@ class DashboardConfigDTO:
     smoothing: Union[Unset, int] = UNSET
     xaxis_metric: Union[Unset, "AttributeDefinitionDTO"] = UNSET
     xaxis_mode: Union[Unset, str] = UNSET
+    xaxis_range: Union[Unset, "OpenRangeDTO"] = UNSET
     xaxis_scale: Union[Unset, str] = UNSET
     yaxis_scale: Union[Unset, str] = UNSET
     additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
@@ -72,6 +74,10 @@ def to_dict(self) -> Dict[str, Any]:
 
         xaxis_mode = self.xaxis_mode
 
+        xaxis_range: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.xaxis_range, Unset):
+            xaxis_range = self.xaxis_range.to_dict()
+
         xaxis_scale = self.xaxis_scale
 
         yaxis_scale = self.yaxis_scale
@@ -87,6 +93,8 @@ def to_dict(self) -> Dict[str, Any]:
             field_dict["xaxisMetric"] = xaxis_metric
         if xaxis_mode is not UNSET:
             field_dict["xaxisMode"] = xaxis_mode
+        if xaxis_range is not UNSET:
+            field_dict["xaxisRange"] = xaxis_range
         if xaxis_scale is not UNSET:
             field_dict["xaxisScale"] = xaxis_scale
         if yaxis_scale is not UNSET:
@@ -118,6 +126,13 @@ def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
 
         xaxis_mode = d.pop("xaxisMode", UNSET)
 
+        _xaxis_range = d.pop("xaxisRange", UNSET)
+        xaxis_range: Union[Unset, OpenRangeDTO]
+        if isinstance(_xaxis_range, Unset):
+            xaxis_range = UNSET
+        else:
+            xaxis_range = OpenRangeDTO.from_dict(_xaxis_range)
+
         xaxis_scale = d.pop("xaxisScale", UNSET)
 
         yaxis_scale = d.pop("yaxisScale", UNSET)
@@ -127,6 +142,7 @@ def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
             smoothing=smoothing,
             xaxis_metric=xaxis_metric,
             xaxis_mode=xaxis_mode,
+            xaxis_range=xaxis_range,
             xaxis_scale=xaxis_scale,
             yaxis_scale=yaxis_scale,
         )

src/neptune_retrieval_api/models/dependency_on_inaccessible_projects_error_dto_error_type.py

@@ -46,6 +46,7 @@ class DependencyOnInaccessibleProjectsErrorDTOErrorType(str, Enum):
     INVALID_GROUPING_PARAMS = "INVALID_GROUPING_PARAMS"
     INVALID_OFFSET = "INVALID_OFFSET"
     INVALID_SORT_PARAMS = "INVALID_SORT_PARAMS"
+    JWT_VALIDATION_ERROR = "JWT_VALIDATION_ERROR"
     LEADERBOARD_ENTRY_NOT_FOUND = "LEADERBOARD_ENTRY_NOT_FOUND"
     MALFORMED_JSON_REQUEST = "MALFORMED_JSON_REQUEST"
     NOTEBOOK_NOT_FOUND = "NOTEBOOK_NOT_FOUND"

src/neptune_retrieval_api/models/point.py

@@ -14,6 +14,7 @@
 # limitations under the License.
 
 from typing import (
+    TYPE_CHECKING,
     Any,
     Dict,
     List,
@@ -30,6 +31,10 @@
     Unset,
 )
 
+if TYPE_CHECKING:
+    from ..models.single_time_series_view_bucket import SingleTimeSeriesViewBucket
+
+
 T = TypeVar("T", bound="Point")
 
 
@@ -39,15 +44,13 @@ class Point:
     Attributes:
         interpolation (bool):
         x (float):
-        max_y (Union[Unset, float]):
-        min_y (Union[Unset, float]):
+        bucket (Union[Unset, SingleTimeSeriesViewBucket]):
         y (Union[Unset, float]):
     """
 
     interpolation: bool
     x: float
-    max_y: Union[Unset, float] = UNSET
-    min_y: Union[Unset, float] = UNSET
+    bucket: Union[Unset, "SingleTimeSeriesViewBucket"] = UNSET
     y: Union[Unset, float] = UNSET
     additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
 
@@ -56,9 +59,9 @@ def to_dict(self) -> Dict[str, Any]:
 
         x = self.x
 
-        max_y = self.max_y
-
-        min_y = self.min_y
+        bucket: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.bucket, Unset):
+            bucket = self.bucket.to_dict()
 
         y = self.y
 
@@ -70,33 +73,35 @@ def to_dict(self) -> Dict[str, Any]:
                 "x": x,
             }
         )
-        if max_y is not UNSET:
-            field_dict["maxY"] = max_y
-        if min_y is not UNSET:
-            field_dict["minY"] = min_y
+        if bucket is not UNSET:
+            field_dict["bucket"] = bucket
         if y is not UNSET:
             field_dict["y"] = y
 
         return field_dict
 
     @classmethod
     def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.single_time_series_view_bucket import SingleTimeSeriesViewBucket
+
         d = src_dict.copy()
         interpolation = d.pop("interpolation")
 
         x = d.pop("x")
 
-        max_y = d.pop("maxY", UNSET)
-
-        min_y = d.pop("minY", UNSET)
+        _bucket = d.pop("bucket", UNSET)
+        bucket: Union[Unset, SingleTimeSeriesViewBucket]
+        if isinstance(_bucket, Unset):
+            bucket = UNSET
+        else:
+            bucket = SingleTimeSeriesViewBucket.from_dict(_bucket)
 
         y = d.pop("y", UNSET)
 
         point = cls(
             interpolation=interpolation,
             x=x,
-            max_y=max_y,
-            min_y=min_y,
+            bucket=bucket,
             y=y,
         )
 

src/neptune_retrieval_api/models/report_node_grid_dto.py

@@ -20,12 +20,18 @@
     List,
     Type,
     TypeVar,
+    Union,
     cast,
 )
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
+from ..types import (
+    UNSET,
+    Unset,
+)
+
 if TYPE_CHECKING:
     from ..models.colors_config_dto import ColorsConfigDTO
     from ..models.dashboard_config_dto import DashboardConfigDTO
@@ -51,6 +57,7 @@ class ReportNodeGridDTO:
         selected_run_groups (List[str]):
         widget_layouts (List['WidgetLayoutDTO']):
         widgets (List['WidgetDTO']):
+        preset_colors (Union[Unset, List[str]]):
     """
 
     aggregate_by_group: bool
@@ -63,6 +70,7 @@ class ReportNodeGridDTO:
     selected_run_groups: List[str]
     widget_layouts: List["WidgetLayoutDTO"]
     widgets: List["WidgetDTO"]
+    preset_colors: Union[Unset, List[str]] = UNSET
     additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> Dict[str, Any]:
@@ -95,6 +103,10 @@ def to_dict(self) -> Dict[str, Any]:
             widgets_item = widgets_item_data.to_dict()
             widgets.append(widgets_item)
 
+        preset_colors: Union[Unset, List[str]] = UNSET
+        if not isinstance(self.preset_colors, Unset):
+            preset_colors = self.preset_colors
+
         field_dict: Dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
@@ -111,6 +123,8 @@ def to_dict(self) -> Dict[str, Any]:
                 "widgets": widgets,
             }
         )
+        if preset_colors is not UNSET:
+            field_dict["presetColors"] = preset_colors
 
         return field_dict
 
@@ -158,6 +172,8 @@ def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
 
             widgets.append(widgets_item)
 
+        preset_colors = cast(List[str], d.pop("presetColors", UNSET))
+
         report_node_grid_dto = cls(
             aggregate_by_group=aggregate_by_group,
             charts_config=charts_config,
@@ -169,6 +185,7 @@ def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
             selected_run_groups=selected_run_groups,
             widget_layouts=widget_layouts,
             widgets=widgets,
+            preset_colors=preset_colors,
         )
 
         report_node_grid_dto.additional_properties = d