Merge branch 'main' into v1.5974.0

.github/workflows/checks.yml

@@ -104,7 +104,7 @@ jobs:
   #     - name: Set up Python
   #       uses: actions/setup-python@v5
   #       with:
-  #         python-version: 3.8
+  #         python-version: "3.10"
   #     - name: Install poetry
   #       run: |
   #         pip install poetry

scaleway-async/scaleway_async/account/v3/__init__.py

@@ -1,23 +1,47 @@
 # This file was automatically generated. DO NOT EDIT.
 # If you have any remark or suggestion do not hesitate to open an issue.
+from .types import ContractType
+from .types import ListContractSignaturesRequestOrderBy
 from .types import ListProjectsRequestOrderBy
+from .types import Contract
+from .types import ContractSignature
 from .types import Project
+from .types import CheckContractSignatureResponse
+from .types import ContractApiCheckContractSignatureRequest
+from .types import ContractApiCreateContractSignatureRequest
+from .types import ContractApiDownloadContractSignatureRequest
+from .types import ContractApiListContractSignaturesRequest
+from .types import ContractApiValidateContractSignatureRequest
+from .types import ListContractSignaturesResponse
 from .types import ListProjectsResponse
 from .types import ProjectApiCreateProjectRequest
 from .types import ProjectApiDeleteProjectRequest
 from .types import ProjectApiGetProjectRequest
 from .types import ProjectApiListProjectsRequest
 from .types import ProjectApiUpdateProjectRequest
+from .api import AccountV3ContractAPI
 from .api import AccountV3ProjectAPI
 
 __all__ = [
+    "ContractType",
+    "ListContractSignaturesRequestOrderBy",
     "ListProjectsRequestOrderBy",
+    "Contract",
+    "ContractSignature",
     "Project",
+    "CheckContractSignatureResponse",
+    "ContractApiCheckContractSignatureRequest",
+    "ContractApiCreateContractSignatureRequest",
+    "ContractApiDownloadContractSignatureRequest",
+    "ContractApiListContractSignaturesRequest",
+    "ContractApiValidateContractSignatureRequest",
+    "ListContractSignaturesResponse",
     "ListProjectsResponse",
     "ProjectApiCreateProjectRequest",
     "ProjectApiDeleteProjectRequest",
     "ProjectApiGetProjectRequest",
     "ProjectApiListProjectsRequest",
     "ProjectApiUpdateProjectRequest",
+    "AccountV3ContractAPI",
     "AccountV3ProjectAPI",
 ]

scaleway-async/scaleway_async/account/v3/api.py

@@ -4,24 +4,266 @@
 from typing import List, Optional
 
 from scaleway_core.api import API
+from scaleway_core.bridge import (
+    ScwFile,
+    unmarshal_ScwFile,
+)
 from scaleway_core.utils import (
     random_name,
     validate_path_param,
     fetch_all_pages_async,
 )
 from .types import (
+    ContractType,
+    ListContractSignaturesRequestOrderBy,
     ListProjectsRequestOrderBy,
+    CheckContractSignatureResponse,
+    ContractApiCheckContractSignatureRequest,
+    ContractApiCreateContractSignatureRequest,
+    ContractSignature,
+    ListContractSignaturesResponse,
     ListProjectsResponse,
     Project,
     ProjectApiCreateProjectRequest,
     ProjectApiUpdateProjectRequest,
 )
 from .marshalling import (
+    unmarshal_ContractSignature,
     unmarshal_Project,
+    unmarshal_CheckContractSignatureResponse,
+    unmarshal_ListContractSignaturesResponse,
     unmarshal_ListProjectsResponse,
+    marshal_ContractApiCheckContractSignatureRequest,
+    marshal_ContractApiCreateContractSignatureRequest,
     marshal_ProjectApiCreateProjectRequest,
     marshal_ProjectApiUpdateProjectRequest,
 )
+from ...std.types import (
+    LanguageCode as StdLanguageCode,
+)
+
+
+class AccountV3ContractAPI(API):
+    """
+    The Contract API allows you to manage contracts.
+    """
+
+    async def download_contract_signature(
+        self,
+        *,
+        contract_signature_id: str,
+        locale: Optional[StdLanguageCode] = None,
+    ) -> ScwFile:
+        """
+        Download a contract content.
+        :param contract_signature_id: The contract signature ID.
+        :param locale: The locale requested for the content of the contract.
+        :return: :class:`ScwFile <ScwFile>`
+
+        Usage:
+        ::
+
+            result = await api.download_contract_signature(
+                contract_signature_id="example",
+            )
+        """
+
+        param_contract_signature_id = validate_path_param(
+            "contract_signature_id", contract_signature_id
+        )
+
+        res = self._request(
+            "GET",
+            f"/account/v3/contract-signatures/{param_contract_signature_id}/download",
+            params={
+                "locale": locale,
+            },
+        )
+
+        self._throw_on_error(res)
+        return unmarshal_ScwFile(res.json())
+
+    async def create_contract_signature(
+        self,
+        *,
+        contract_name: str,
+        validated: bool,
+        contract_type: Optional[ContractType] = None,
+        organization_id: Optional[str] = None,
+    ) -> ContractSignature:
+        """
+        Create a signature for your Organization for the latest version of the requested contract.
+        :param contract_name: The name of the contract.
+        :param validated: Whether the contract is validated at creation.
+        :param contract_type: The type of the contract.
+        :param organization_id: ID of the Organization.
+        :return: :class:`ContractSignature <ContractSignature>`
+
+        Usage:
+        ::
+
+            result = await api.create_contract_signature(
+                contract_name="example",
+                validated=False,
+            )
+        """
+
+        res = self._request(
+            "POST",
+            "/account/v3/contract-signatures",
+            body=marshal_ContractApiCreateContractSignatureRequest(
+                ContractApiCreateContractSignatureRequest(
+                    contract_name=contract_name,
+                    validated=validated,
+                    contract_type=contract_type,
+                    organization_id=organization_id,
+                ),
+                self.client,
+            ),
+        )
+
+        self._throw_on_error(res)
+        return unmarshal_ContractSignature(res.json())
+
+    async def validate_contract_signature(
+        self,
+        *,
+        contract_signature_id: str,
+    ) -> ContractSignature:
+        """
+        Sign a contract for your Organization.
+        :param contract_signature_id: The contract linked to your Organization you want to sign.
+        :return: :class:`ContractSignature <ContractSignature>`
+
+        Usage:
+        ::
+
+            result = await api.validate_contract_signature(
+                contract_signature_id="example",
+            )
+        """
+
+        param_contract_signature_id = validate_path_param(
+            "contract_signature_id", contract_signature_id
+        )
+
+        res = self._request(
+            "POST",
+            f"/account/v3/contract-signatures/{param_contract_signature_id}/validate",
+            body={},
+        )
+
+        self._throw_on_error(res)
+        return unmarshal_ContractSignature(res.json())
+
+    async def check_contract_signature(
+        self,
+        *,
+        contract_name: str,
+        organization_id: Optional[str] = None,
+        contract_type: Optional[ContractType] = None,
+    ) -> CheckContractSignatureResponse:
+        """
+        Check if a contract is signed for your Organization.
+        :param contract_name: Filter on contract name.
+        :param organization_id: ID of the Organization to check the contract signature for.
+        :param contract_type: Filter on contract type.
+        :return: :class:`CheckContractSignatureResponse <CheckContractSignatureResponse>`
+
+        Usage:
+        ::
+
+            result = await api.check_contract_signature(
+                contract_name="example",
+            )
+        """
+
+        res = self._request(
+            "POST",
+            "/account/v3/contract-signatures/check",
+            body=marshal_ContractApiCheckContractSignatureRequest(
+                ContractApiCheckContractSignatureRequest(
+                    contract_name=contract_name,
+                    organization_id=organization_id,
+                    contract_type=contract_type,
+                ),
+                self.client,
+            ),
+        )
+
+        self._throw_on_error(res)
+        return unmarshal_CheckContractSignatureResponse(res.json())
+
+    async def list_contract_signatures(
+        self,
+        *,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        order_by: Optional[ListContractSignaturesRequestOrderBy] = None,
+        organization_id: Optional[str] = None,
+    ) -> ListContractSignaturesResponse:
+        """
+        List contract signatures for an Organization.
+        :param page: The page number for the returned contracts.
+        :param page_size: The maximum number of contracts per page.
+        :param order_by: How the contracts are ordered in the response.
+        :param organization_id: Filter on Organization ID.
+        :return: :class:`ListContractSignaturesResponse <ListContractSignaturesResponse>`
+
+        Usage:
+        ::
+
+            result = await api.list_contract_signatures()
+        """
+
+        res = self._request(
+            "GET",
+            "/account/v3/contract-signatures",
+            params={
+                "order_by": order_by,
+                "organization_id": organization_id
+                or self.client.default_organization_id,
+                "page": page,
+                "page_size": page_size or self.client.default_page_size,
+            },
+        )
+
+        self._throw_on_error(res)
+        return unmarshal_ListContractSignaturesResponse(res.json())
+
+    async def list_contract_signatures_all(
+        self,
+        *,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        order_by: Optional[ListContractSignaturesRequestOrderBy] = None,
+        organization_id: Optional[str] = None,
+    ) -> List[ContractSignature]:
+        """
+        List contract signatures for an Organization.
+        :param page: The page number for the returned contracts.
+        :param page_size: The maximum number of contracts per page.
+        :param order_by: How the contracts are ordered in the response.
+        :param organization_id: Filter on Organization ID.
+        :return: :class:`List[ContractSignature] <List[ContractSignature]>`
+
+        Usage:
+        ::
+
+            result = await api.list_contract_signatures_all()
+        """
+
+        return await fetch_all_pages_async(
+            type=ListContractSignaturesResponse,
+            key="contract_signatures",
+            fetcher=self.list_contract_signatures,
+            args={
+                "page": page,
+                "page_size": page_size,
+                "order_by": order_by,
+                "organization_id": organization_id,
+            },
+        )
 
 
 class AccountV3ProjectAPI(API):