polyaxon 2.0.0rc49__py3-none-any.whl → 2.4.0rc1__py3-none-any.whl

polyaxon/_sdk/api/users_v1_api.py

@@ -15,8 +15,8 @@ class UsersV1Api(BaseApi):
     @validate_arguments
     def create_token(
         self, body: Annotated[V1Token, Field(..., description="Token body")], **kwargs
-    ) -> V1Token:
-        """Create token
+    ) -> V1Token:  # noqa: E501
+        """Create token  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
@@ -42,13 +42,13 @@ class UsersV1Api(BaseApi):
         :rtype: V1Token
         """
         kwargs["_return_http_data_only"] = True
-        return self.create_token_with_http_info(body, **kwargs)
+        return self.create_token_with_http_info(body, **kwargs)  # noqa: E501
 
     @validate_arguments
     def create_token_with_http_info(
         self, body: Annotated[V1Token, Field(..., description="Token body")], **kwargs
-    ):
-        """Create token
+    ):  # noqa: E501
+        """Create token  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
@@ -114,14 +114,11 @@ class UsersV1Api(BaseApi):
 
         # process the query parameters
         _query_params = []
-
         # process the header parameters
         _header_params = dict(_params.get("_headers", {}))
-
         # process the form parameters
         _form_params = []
         _files = {}
-
         # process the body parameter
         _body_params = None
         if _params["body"]:
@@ -130,7 +127,7 @@ class UsersV1Api(BaseApi):
         # set the HTTP header `Accept`
         _header_params["Accept"] = self.api_client.select_header_accept(
             ["application/json"]
-        )
+        )  # noqa: E501
 
         # set the HTTP header `Content-Type`
         _content_types_list = _params.get(
@@ -141,7 +138,7 @@ class UsersV1Api(BaseApi):
             _header_params["Content-Type"] = _content_types_list
 
         # authentication setting
-        _auth_settings = ["ApiKey"]
+        _auth_settings = ["ApiKey"]  # noqa: E501
 
         _response_types_map = {
             "200": "V1Token",
@@ -162,7 +159,7 @@ class UsersV1Api(BaseApi):
             response_types_map=_response_types_map,
             auth_settings=_auth_settings,
             async_req=_params.get("async_req"),
-            _return_http_data_only=_params.get("_return_http_data_only"),
+            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
             _preload_content=_params.get("_preload_content", True),
             _request_timeout=_params.get("_request_timeout"),
             collection_formats=_collection_formats,
@@ -174,8 +171,8 @@ class UsersV1Api(BaseApi):
         self,
         uuid: Annotated[StrictStr, Field(..., description="UUid of the namespace")],
         **kwargs
-    ) -> None:
-        """Delete token
+    ) -> None:  # noqa: E501
+        """Delete token  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
@@ -201,15 +198,15 @@ class UsersV1Api(BaseApi):
         :rtype: None
         """
         kwargs["_return_http_data_only"] = True
-        return self.delete_token_with_http_info(uuid, **kwargs)
+        return self.delete_token_with_http_info(uuid, **kwargs)  # noqa: E501
 
     @validate_arguments
     def delete_token_with_http_info(
         self,
         uuid: Annotated[StrictStr, Field(..., description="UUid of the namespace")],
         **kwargs
-    ):
-        """Delete token
+    ):  # noqa: E501
+        """Delete token  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
@@ -277,24 +274,20 @@ class UsersV1Api(BaseApi):
 
         # process the query parameters
         _query_params = []
-
         # process the header parameters
         _header_params = dict(_params.get("_headers", {}))
-
         # process the form parameters
         _form_params = []
         _files = {}
-
         # process the body parameter
         _body_params = None
-
         # set the HTTP header `Accept`
         _header_params["Accept"] = self.api_client.select_header_accept(
             ["application/json"]
-        )
+        )  # noqa: E501
 
         # authentication setting
-        _auth_settings = ["ApiKey"]
+        _auth_settings = ["ApiKey"]  # noqa: E501
 
         _response_types_map = {}
 
@@ -310,7 +303,7 @@ class UsersV1Api(BaseApi):
             response_types_map=_response_types_map,
             auth_settings=_auth_settings,
             async_req=_params.get("async_req"),
-            _return_http_data_only=_params.get("_return_http_data_only"),
+            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
             _preload_content=_params.get("_preload_content", True),
             _request_timeout=_params.get("_request_timeout"),
             collection_formats=_collection_formats,
@@ -332,8 +325,8 @@ class UsersV1Api(BaseApi):
         ] = None,
         no_page: Annotated[Optional[bool], Field(description="No pagination.")] = None,
         **kwargs
-    ) -> V1ListActivitiesResponse:
-        """User History
+    ) -> V1ListActivitiesResponse:  # noqa: E501
+        """User History  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
@@ -369,7 +362,7 @@ class UsersV1Api(BaseApi):
         kwargs["_return_http_data_only"] = True
         return self.get_history_with_http_info(
             offset, limit, sort, query, no_page, **kwargs
-        )
+        )  # noqa: E501
 
     @validate_arguments
     def get_history_with_http_info(
@@ -463,25 +456,26 @@ class UsersV1Api(BaseApi):
         _query_params = []
         if _params.get("offset") is not None:  # noqa: E501
             _query_params.append(("offset", _params["offset"]))
+
         if _params.get("limit") is not None:  # noqa: E501
             _query_params.append(("limit", _params["limit"]))
+
         if _params.get("sort") is not None:  # noqa: E501
             _query_params.append(("sort", _params["sort"]))
+
         if _params.get("query") is not None:  # noqa: E501
             _query_params.append(("query", _params["query"]))
+
         if _params.get("no_page") is not None:  # noqa: E501
             _query_params.append(("no_page", _params["no_page"]))
 
         # process the header parameters
         _header_params = dict(_params.get("_headers", {}))
-
         # process the form parameters
         _form_params = []
         _files = {}
-
         # process the body parameter
         _body_params = None
-
         # set the HTTP header `Accept`
         _header_params["Accept"] = self.api_client.select_header_accept(
             ["application/json"]
@@ -662,25 +656,26 @@ class UsersV1Api(BaseApi):
         _query_params = []
         if _params.get("offset") is not None:  # noqa: E501
             _query_params.append(("offset", _params["offset"]))
+
         if _params.get("limit") is not None:  # noqa: E501
             _query_params.append(("limit", _params["limit"]))
+
         if _params.get("sort") is not None:  # noqa: E501
             _query_params.append(("sort", _params["sort"]))
+
         if _params.get("query") is not None:  # noqa: E501
             _query_params.append(("query", _params["query"]))
+
         if _params.get("no_page") is not None:  # noqa: E501
             _query_params.append(("no_page", _params["no_page"]))
 
         # process the header parameters
         _header_params = dict(_params.get("_headers", {}))
-
         # process the form parameters
         _form_params = []
         _files = {}
-
         # process the body parameter
         _body_params = None
-
         # set the HTTP header `Accept`
         _header_params["Accept"] = self.api_client.select_header_accept(
             ["application/json"]
@@ -823,17 +818,13 @@ class UsersV1Api(BaseApi):
 
         # process the query parameters
         _query_params = []
-
         # process the header parameters
         _header_params = dict(_params.get("_headers", {}))
-
         # process the form parameters
         _form_params = []
         _files = {}
-
         # process the body parameter
         _body_params = None
-
         # set the HTTP header `Accept`
         _header_params["Accept"] = self.api_client.select_header_accept(
             ["application/json"]
@@ -962,17 +953,13 @@ class UsersV1Api(BaseApi):
 
         # process the query parameters
         _query_params = []
-
         # process the header parameters
         _header_params = dict(_params.get("_headers", {}))
-
         # process the form parameters
         _form_params = []
         _files = {}
-
         # process the body parameter
         _body_params = None
-
         # set the HTTP header `Accept`
         _header_params["Accept"] = self.api_client.select_header_accept(
             ["application/json"]
@@ -1007,6 +994,206 @@ class UsersV1Api(BaseApi):
             _request_auth=_params.get("_request_auth"),
         )
 
+    @validate_arguments
+    def get_workspaces(
+        self,
+        offset: Annotated[
+            Optional[StrictInt], Field(description="Pagination offset.")
+        ] = None,
+        limit: Annotated[Optional[StrictInt], Field(description="Limit size.")] = None,
+        sort: Annotated[
+            Optional[StrictStr], Field(description="Sort to order the search.")
+        ] = None,
+        query: Annotated[
+            Optional[StrictStr], Field(description="Query filter the search.")
+        ] = None,
+        no_page: Annotated[Optional[bool], Field(description="No pagination.")] = None,
+        **kwargs
+    ) -> object:  # noqa: E501
+        """User workspaces  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.get_workspaces(offset, limit, sort, query, no_page, async_req=True)
+        >>> result = thread.get()
+
+        :param offset: Pagination offset.
+        :type offset: int
+        :param limit: Limit size.
+        :type limit: int
+        :param sort: Sort to order the search.
+        :type sort: str
+        :param query: Query filter the search.
+        :type query: str
+        :param no_page: No pagination.
+        :type no_page: bool
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :type _preload_content: bool, optional
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: object
+        """
+        kwargs["_return_http_data_only"] = True
+        return self.get_workspaces_with_http_info(
+            offset, limit, sort, query, no_page, **kwargs
+        )  # noqa: E501
+
+    @validate_arguments
+    def get_workspaces_with_http_info(
+        self,
+        offset: Annotated[
+            Optional[StrictInt], Field(description="Pagination offset.")
+        ] = None,
+        limit: Annotated[Optional[StrictInt], Field(description="Limit size.")] = None,
+        sort: Annotated[
+            Optional[StrictStr], Field(description="Sort to order the search.")
+        ] = None,
+        query: Annotated[
+            Optional[StrictStr], Field(description="Query filter the search.")
+        ] = None,
+        no_page: Annotated[Optional[bool], Field(description="No pagination.")] = None,
+        **kwargs
+    ):  # noqa: E501
+        """User workspaces  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.get_workspaces_with_http_info(offset, limit, sort, query, no_page, async_req=True)
+        >>> result = thread.get()
+
+        :param offset: Pagination offset.
+        :type offset: int
+        :param limit: Limit size.
+        :type limit: int
+        :param sort: Sort to order the search.
+        :type sort: str
+        :param query: Query filter the search.
+        :type query: str
+        :param no_page: No pagination.
+        :type no_page: bool
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _return_http_data_only: response data without head status code
+                                       and headers
+        :type _return_http_data_only: bool, optional
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :type _preload_content: bool, optional
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the authentication
+                              in the spec for a single request.
+        :type _request_auth: dict, optional
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: tuple(object, status_code(int), headers(HTTPHeaderDict))
+        """
+
+        _params = locals()
+
+        _all_params = ["offset", "limit", "sort", "query", "no_page"]
+        _all_params.extend(
+            [
+                "async_req",
+                "_return_http_data_only",
+                "_preload_content",
+                "_request_timeout",
+                "_request_auth",
+                "_content_type",
+                "_headers",
+            ]
+        )
+
+        # validate the arguments
+        for _key, _val in _params["kwargs"].items():
+            if _key not in _all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method get_workspaces" % _key
+                )
+            _params[_key] = _val
+        del _params["kwargs"]
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+
+        # process the query parameters
+        _query_params = []
+        if _params.get("offset") is not None:  # noqa: E501
+            _query_params.append(("offset", _params["offset"]))
+
+        if _params.get("limit") is not None:  # noqa: E501
+            _query_params.append(("limit", _params["limit"]))
+
+        if _params.get("sort") is not None:  # noqa: E501
+            _query_params.append(("sort", _params["sort"]))
+
+        if _params.get("query") is not None:  # noqa: E501
+            _query_params.append(("query", _params["query"]))
+
+        if _params.get("no_page") is not None:  # noqa: E501
+            _query_params.append(("no_page", _params["no_page"]))
+
+        # process the header parameters
+        _header_params = dict(_params.get("_headers", {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        # set the HTTP header `Accept`
+        _header_params["Accept"] = self.api_client.select_header_accept(
+            ["application/json"]
+        )  # noqa: E501
+
+        # authentication setting
+        _auth_settings = ["ApiKey"]  # noqa: E501
+
+        _response_types_map = {
+            "200": "object",
+            "204": "object",
+            "403": "object",
+            "404": "object",
+        }
+
+        return self.api_client.call_api(
+            "/api/v1/users/workspaces",
+            "GET",
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get("async_req"),
+            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
+            _preload_content=_params.get("_preload_content", True),
+            _request_timeout=_params.get("_request_timeout"),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get("_request_auth"),
+        )
+
     @validate_arguments
     def list_tokens(
         self,
@@ -1153,25 +1340,26 @@ class UsersV1Api(BaseApi):
         _query_params = []
         if _params.get("offset") is not None:  # noqa: E501
             _query_params.append(("offset", _params["offset"]))
+
         if _params.get("limit") is not None:  # noqa: E501
             _query_params.append(("limit", _params["limit"]))
+
         if _params.get("sort") is not None:  # noqa: E501
             _query_params.append(("sort", _params["sort"]))
+
         if _params.get("query") is not None:  # noqa: E501
             _query_params.append(("query", _params["query"]))
+
         if _params.get("no_page") is not None:  # noqa: E501
             _query_params.append(("no_page", _params["no_page"]))
 
         # process the header parameters
         _header_params = dict(_params.get("_headers", {}))
-
         # process the form parameters
         _form_params = []
         _files = {}
-
         # process the body parameter
         _body_params = None
-
         # set the HTTP header `Accept`
         _header_params["Accept"] = self.api_client.select_header_accept(
             ["application/json"]
@@ -1320,14 +1508,11 @@ class UsersV1Api(BaseApi):
 
         # process the query parameters
         _query_params = []
-
         # process the header parameters
         _header_params = dict(_params.get("_headers", {}))
-
         # process the form parameters
         _form_params = []
         _files = {}
-
         # process the body parameter
         _body_params = None
         if _params["body"]:
@@ -1473,14 +1658,11 @@ class UsersV1Api(BaseApi):
 
         # process the query parameters
         _query_params = []
-
         # process the header parameters
         _header_params = dict(_params.get("_headers", {}))
-
         # process the form parameters
         _form_params = []
         _files = {}
-
         # process the body parameter
         _body_params = None
         if _params["body"]:
@@ -1644,14 +1826,11 @@ class UsersV1Api(BaseApi):
 
         # process the query parameters
         _query_params = []
-
         # process the header parameters
         _header_params = dict(_params.get("_headers", {}))
-
         # process the form parameters
         _form_params = []
         _files = {}
-
         # process the body parameter
         _body_params = None
         if _params["body"]:
@@ -1797,14 +1976,11 @@ class UsersV1Api(BaseApi):
 
         # process the query parameters
         _query_params = []
-
         # process the header parameters
         _header_params = dict(_params.get("_headers", {}))
-
         # process the form parameters
         _form_params = []
         _files = {}
-
         # process the body parameter
         _body_params = None
         if _params["body"]:

polyaxon/_sdk/async_client/api_client.py

@@ -1,4 +1,5 @@
 import atexit
+import logging
 import re
 
 from urllib.parse import quote
@@ -6,6 +7,9 @@ from urllib.parse import quote
 from polyaxon._sdk.sync_client.api_client import ApiClient
 from polyaxon.exceptions import ApiException
 
+aiohttp_logger = logging.getLogger("aiohttp")
+aiohttp_logger.setLevel(logging.ERROR)
+
 
 class AsyncApiClient(ApiClient):
     """Generic Async API client for OpenAPI client library builds.

polyaxon/_sdk/schemas/__init__.py

@@ -1,5 +1,8 @@
 from polyaxon._sdk.schemas.v1_activity import V1Activity
 from polyaxon._sdk.schemas.v1_agent import V1Agent
+from polyaxon._sdk.schemas.v1_agent_reconcile_body_request import (
+    V1AgentReconcileBodyRequest,
+)
 from polyaxon._sdk.schemas.v1_agent_state_response import V1AgentStateResponse
 from polyaxon._sdk.schemas.v1_agent_state_response_agent_state import (
     V1AgentStateResponseAgentState,
@@ -19,7 +22,10 @@ from polyaxon._sdk.schemas.v1_entity_stage_body_request import V1EntityStageBody
 from polyaxon._sdk.schemas.v1_entity_status_body_request import (
     V1EntityStatusBodyRequest,
 )
-from polyaxon._sdk.schemas.v1_events_response import V1EventsResponse
+from polyaxon._sdk.schemas.v1_events_response import (
+    V1EventsResponse,
+    V1MultiEventsResponse,
+)
 from polyaxon._sdk.schemas.v1_list_activities_response import V1ListActivitiesResponse
 from polyaxon._sdk.schemas.v1_list_agents_response import V1ListAgentsResponse
 from polyaxon._sdk.schemas.v1_list_bookmarks_response import V1ListBookmarksResponse
@@ -63,12 +69,13 @@ from polyaxon._sdk.schemas.v1_pipeline import V1Pipeline
 from polyaxon._sdk.schemas.v1_preset import V1Preset
 from polyaxon._sdk.schemas.v1_project import V1Project
 from polyaxon._sdk.schemas.v1_project_settings import V1ProjectSettings
-from polyaxon._sdk.schemas.v1_project_user_access import V1ProjectUserAccess
 from polyaxon._sdk.schemas.v1_project_version import V1ProjectVersion
 from polyaxon._sdk.schemas.v1_queue import V1Queue
 from polyaxon._sdk.schemas.v1_run import V1Run
 from polyaxon._sdk.schemas.v1_run_connection import V1RunConnection
 from polyaxon._sdk.schemas.v1_run_edge import V1RunEdge
+from polyaxon._sdk.schemas.v1_run_edge_lineage import V1RunEdgeLineage
+from polyaxon._sdk.schemas.v1_run_edges_graph import V1RunEdgesGraph
 from polyaxon._sdk.schemas.v1_run_reference_catalog import V1RunReferenceCatalog
 from polyaxon._sdk.schemas.v1_run_settings import V1RunSettings
 from polyaxon._sdk.schemas.v1_search import V1Search
@@ -83,6 +90,7 @@ from polyaxon._sdk.schemas.v1_team_settings import V1TeamSettings
 from polyaxon._sdk.schemas.v1_token import V1Token
 from polyaxon._sdk.schemas.v1_trial_start import V1TrialStart
 from polyaxon._sdk.schemas.v1_user import V1User
+from polyaxon._sdk.schemas.v1_user_access import V1UserAccess
 from polyaxon._sdk.schemas.v1_user_email import V1UserEmail
 from polyaxon._sdk.schemas.v1_user_singup import V1UserSingup
 from polyaxon._sdk.schemas.v1_uuids import V1Uuids

polyaxon/_sdk/schemas/v1_agent.py

@@ -6,7 +6,7 @@ from clipped.compact.pydantic import StrictStr
 from clipped.config.schema import BaseAllowSchemaModel
 from clipped.types.uuids import UUIDStr
 
-from polyaxon._schemas.lifecycle import V1Statuses
+from polyaxon._schemas.lifecycle import V1StatusCondition, V1Statuses
 
 
 class V1Agent(BaseAllowSchemaModel):
@@ -22,6 +22,7 @@ class V1Agent(BaseAllowSchemaModel):
     created_at: Optional[datetime.datetime]
     updated_at: Optional[datetime.datetime]
     status: Optional[V1Statuses]
+    status_conditions: Optional[List[V1StatusCondition]]
     is_replica: Optional[bool]
     is_ui_managed: Optional[bool]
     settings: Optional[Dict[str, Any]]

polyaxon/_sdk/schemas/v1_agent_reconcile_body_request.py

@@ -0,0 +1,14 @@
+from typing import Any, Dict, Optional
+
+from clipped.compact.pydantic import StrictStr
+from clipped.config.schema import BaseAllowSchemaModel
+
+
+class V1AgentReconcileBodyRequest(BaseAllowSchemaModel):
+    """
+    V1AgentReconcileBodyRequest
+    """
+
+    owner: Optional[StrictStr] = None
+    uuid: Optional[StrictStr] = None
+    reconcile: Optional[Dict[str, Any]] = None

polyaxon/_sdk/schemas/v1_artifact_tree.py

@@ -5,6 +5,6 @@ from clipped.config.schema import BaseAllowSchemaModel
 
 
 class V1ArtifactTree(BaseAllowSchemaModel):
-    files: Optional[Dict[str, StrictStr]]
+    files: Optional[Dict[str, int]]
     dirs: Optional[List[StrictStr]]
     is_done: Optional[bool]

polyaxon/_sdk/schemas/v1_dashboard_spec.py

@@ -6,4 +6,8 @@ from polyaxon._sdk.schemas.v1_section_spec import V1SectionSpec
 
 
 class V1DashboardSpec(BaseAllowSchemaModel):
+    xaxis: Optional[str]
+    smoothing: Optional[int]
+    ignore_outliers: Optional[bool]
+    sample_size: Optional[int]
     sections: Optional[List[V1SectionSpec]]

polyaxon/_sdk/schemas/v1_events_response.py

@@ -5,3 +5,7 @@ from clipped.config.schema import BaseAllowSchemaModel
 
 class V1EventsResponse(BaseAllowSchemaModel):
     data: Optional[List[Dict[str, Any]]]
+
+
+class V1MultiEventsResponse(BaseAllowSchemaModel):
+    data: Optional[Dict[str, Any]]

polyaxon/_sdk/schemas/v1_organization.py

@@ -20,6 +20,7 @@ class V1Organization(BaseAllowSchemaModel):
     queue: Optional[StrictStr]
     preset: Optional[StrictStr]
     is_cloud_viewable: Optional[bool]
+    archived_deletion_interval: Optional[int]
     auth: Optional[Dict[str, Any]]
     plan: Optional[Dict[str, Any]]
     usage: Optional[Dict[str, Any]]