appwrite 24.1.0__tar.gz → 24.3.0__tar.gz

{appwrite-24.1.0 → appwrite-24.3.0}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: appwrite
-Version: 24.1.0
+Version: 24.3.0
 Summary: Appwrite is an open-source self-hosted backend server that abstracts and simplifies complex and repetitive development tasks behind a very simple REST API
 Home-page: https://appwrite.io/support
-Download-URL: https://github.com/appwrite/sdk-for-python/archive/24.1.0.tar.gz
+Download-URL: https://github.com/appwrite/sdk-for-python/archive/24.3.0.tar.gz
 Author: Appwrite Team
 Author-email: Appwrite Team <team@appwrite.io>
 Maintainer: Appwrite Team

{appwrite-24.1.0 → appwrite-24.3.0}/appwrite/client.py

@@ -18,11 +18,11 @@ class Client:
         self._endpoint = 'https://cloud.appwrite.io/v1'
         self._global_headers = {
             'content-type': '',
-            'user-agent': f'AppwritePythonSDK/24.1.0 ({platform.uname().system}; {platform.uname().version}; {platform.uname().machine})',
+            'user-agent': f'AppwritePythonSDK/24.3.0 ({platform.uname().system}; {platform.uname().version}; {platform.uname().machine})',
             'x-sdk-name': 'Python',
             'x-sdk-platform': 'server',
             'x-sdk-language': 'python',
-            'x-sdk-version': '24.1.0',
+            'x-sdk-version': '24.3.0',
             'X-Appwrite-Response-Format': '2.0.0',
         }
         self._config = {}

{appwrite-24.1.0 → appwrite-24.3.0}/appwrite/models/__init__.py

@@ -208,6 +208,10 @@ from .proxy_rule import ProxyRule
 from .email_template import EmailTemplate
 from .mfa_challenge import MfaChallenge
 from .mfa_challenge_secret import MfaChallengeSecret
+from .token_secret import TokenSecret
+from .passkey import Passkey
+from .passkey_challenge import PasskeyChallenge
+from .passkey_list import PasskeyList
 from .mfa_recovery_codes import MfaRecoveryCodes
 from .mfa_type import MfaType
 from .mfa_factors import MfaFactors
@@ -511,6 +515,10 @@ __all__ = [
     'EmailTemplate',
     'MfaChallenge',
     'MfaChallengeSecret',
+    'TokenSecret',
+    'Passkey',
+    'PasskeyChallenge',
+    'PasskeyList',
     'MfaRecoveryCodes',
     'MfaType',
     'MfaFactors',

{appwrite-24.1.0 → appwrite-24.3.0}/appwrite/models/billing_plan.py

@@ -149,6 +149,8 @@ class BillingPlan(AppwriteModel):
         Maximum function and site deployment size in MB
     buildsize : float
         Maximum function and site deployment size in MB
+    functionsintervalminimum : float
+        Shortest function schedule interval allowed, in minutes. 0 allows every interval.
     databasesallowencrypt : bool
         Does the plan support encrypted string attributes or not.
     limits : Optional[BillingPlanLimits]
@@ -229,6 +231,7 @@ class BillingPlan(AppwriteModel):
     backuppolicies: Optional[float] = Field(default=None, alias='backupPolicies')
     deploymentsize: float = Field(..., alias='deploymentSize')
     buildsize: float = Field(..., alias='buildSize')
+    functionsintervalminimum: float = Field(..., alias='functionsIntervalMinimum')
     databasesallowencrypt: bool = Field(..., alias='databasesAllowEncrypt')
     limits: Optional[BillingPlanLimits] = Field(default=None, alias='limits')
     group: BillingPlanGroup = Field(..., alias='group')

{appwrite-24.1.0 → appwrite-24.3.0}/appwrite/models/function.py

@@ -49,6 +49,8 @@ class Function(AppwriteModel):
         Function trigger events.
     schedule : str
         Function execution schedule in CRON format.
+    interval : Optional[float]
+        Minutes between scheduled executions. 0 when the function has no interval.
     timeout : float
         Function execution timeout in seconds.
     entrypoint : str
@@ -96,6 +98,7 @@ class Function(AppwriteModel):
     vars: List[Variable] = Field(..., alias='vars')
     events: List[Any] = Field(..., alias='events')
     schedule: str = Field(..., alias='schedule')
+    interval: Optional[float] = Field(default=None, alias='interval')
     timeout: float = Field(..., alias='timeout')
     entrypoint: str = Field(..., alias='entrypoint')
     commands: str = Field(..., alias='commands')

appwrite-24.3.0/appwrite/models/passkey.py

@@ -0,0 +1,29 @@
+from typing import Any, Dict, List, Optional, Union, cast
+from pydantic import Field, PrivateAttr
+
+from .base_model import AppwriteModel
+
+
+class Passkey(AppwriteModel):
+    """
+    Passkey
+
+    Attributes
+    ----------
+    id : str
+        Passkey ID.
+    createdat : str
+        Passkey creation date in ISO 8601 format.
+    updatedat : str
+        Passkey update date in ISO 8601 format.
+    name : str
+        Passkey name.
+    accessedat : str
+        Most recent sign-in with this passkey in ISO 8601 format. Empty until the passkey is used to sign in.
+    """
+
+    id: str = Field(..., alias='$id')
+    createdat: str = Field(..., alias='$createdAt')
+    updatedat: str = Field(..., alias='$updatedAt')
+    name: str = Field(..., alias='name')
+    accessedat: str = Field(..., alias='accessedAt')

appwrite-24.3.0/appwrite/models/passkey_challenge.py

@@ -0,0 +1,29 @@
+from typing import Any, Dict, List, Optional, Union, cast
+from pydantic import Field, PrivateAttr
+
+from .base_model import AppwriteModel
+
+
+class PasskeyChallenge(AppwriteModel):
+    """
+    Passkey Challenge
+
+    Attributes
+    ----------
+    id : str
+        Challenge ID. When signing in, pass it back with the credential to receive a token.
+    createdat : str
+        Challenge creation date in ISO 8601 format.
+    passkeyid : str
+        ID of the passkey being registered. Empty for sign-in challenges.
+    expire : str
+        Challenge expiration date in ISO 8601 format.
+    publickey : Dict[str, Any]
+        WebAuthn options in JSON form. Pass them to `PublicKeyCredential.parseCreationOptionsFromJSON()` when registering, or `PublicKeyCredential.parseRequestOptionsFromJSON()` when signing in.
+    """
+
+    id: str = Field(..., alias='$id')
+    createdat: str = Field(..., alias='$createdAt')
+    passkeyid: str = Field(..., alias='passkeyId')
+    expire: str = Field(..., alias='expire')
+    publickey: Dict[str, Any] = Field(..., alias='publicKey')

appwrite-24.3.0/appwrite/models/passkey_list.py

@@ -0,0 +1,21 @@
+from typing import Any, Dict, List, Optional, Union, cast
+from pydantic import Field, PrivateAttr
+
+from .base_model import AppwriteModel
+from .passkey import Passkey
+
+
+class PasskeyList(AppwriteModel):
+    """
+    Passkeys List
+
+    Attributes
+    ----------
+    total : float
+        Total number of passkeys that matched your query.
+    passkeys : List[Passkey]
+        List of passkeys.
+    """
+
+    total: float = Field(..., alias='total')
+    passkeys: List[Passkey] = Field(..., alias='passkeys')

appwrite-24.3.0/appwrite/models/token_secret.py

@@ -0,0 +1,32 @@
+from typing import Any, Dict, List, Optional, Union, cast
+from pydantic import Field, PrivateAttr
+
+from .base_model import AppwriteModel
+
+
+class TokenSecret(AppwriteModel):
+    """
+    Token Secret
+
+    Attributes
+    ----------
+    id : str
+        Token ID.
+    createdat : str
+        Token creation date in ISO 8601 format.
+    userid : str
+        User ID.
+    secret : str
+        Token secret key. Exchange it for a session with the create session endpoint.
+    expire : str
+        Token expiration date in ISO 8601 format.
+    phrase : str
+        Security phrase of a token. Empty if security phrase was not requested when creating a token. It includes randomly generated phrase which is also sent in the external resource such as email.
+    """
+
+    id: str = Field(..., alias='$id')
+    createdat: str = Field(..., alias='$createdAt')
+    userid: str = Field(..., alias='userId')
+    secret: str = Field(..., alias='secret')
+    expire: str = Field(..., alias='expire')
+    phrase: str = Field(..., alias='phrase')

{appwrite-24.1.0 → appwrite-24.3.0}/appwrite/services/account.py

@@ -17,10 +17,14 @@ from ..models.mfa_challenge import MfaChallenge
 from ..models.session import Session
 from ..models.mfa_factors import MfaFactors
 from ..models.mfa_recovery_codes import MfaRecoveryCodes
+from ..models.passkey_list import PasskeyList
+from ..models.passkey_challenge import PasskeyChallenge
+from ..models.passkey import Passkey
 from ..models.preferences import Preferences
 from ..models.token import Token
 from ..models.session_list import SessionList
 from ..enums.o_auth_provider import OAuthProvider
+from ..models.token_secret import TokenSecret
 
 T = TypeVar('T')
 
@@ -1014,6 +1018,270 @@ class Account(Service):
 
         return User.with_data(response, model_type)
 
+    def list_passkeys(
+        self,
+        queries: Optional[List[str]] = None,
+        total: Optional[bool] = None,
+    ) -> PasskeyList:
+        """
+        Get the list of verified passkeys registered by the currently logged in user.
+
+        Parameters
+        ----------
+        queries : Optional[List[str]]
+            Array of query strings generated using the Query class provided by the SDK. [Learn more about queries](https://appwrite.io/docs/queries). Maximum of 100 queries are allowed, each 4096 characters long. You may filter and order on the following attributes: $id, $createdAt, $updatedAt, name, accessedAt
+        total : Optional[bool]
+            When set to false, the total count returned will be 0 and will not be calculated.
+        Returns
+        -------
+        PasskeyList
+            API response as a typed Pydantic model
+
+        Raises
+        ------
+        AppwriteException
+            If API request fails
+        """
+
+        api_path = '/account/passkeys'
+        api_params = {}
+        if queries is not None:
+            api_params['queries'] = self._normalize_value(queries)
+        if total is not None:
+            api_params['total'] = self._normalize_value(total)
+
+        response = self.client.call(
+            'get',
+            api_path,
+            {
+                'X-Appwrite-Project': self.client.get_config('project'),
+                'accept': 'application/json',
+            },
+            api_params,
+        )
+
+        return self._parse_response(response, model=PasskeyList)
+
+    def create_passkey(
+        self,
+        passkey_id: Optional[str] = None,
+        name: Optional[str] = None,
+    ) -> PasskeyChallenge:
+        """
+        Start registering a passkey for the currently logged in user. The session must have signed in or completed an MFA challenge within the last 10 minutes. Pass the returned `publicKey` options to `navigator.credentials.create()`, then complete the registration with [Update passkey verification](/docs/references/cloud/client-web/account#updatePasskeyVerification). The passkey stays pending until verified, and the challenge expires after 5 minutes.
+
+        Parameters
+        ----------
+        passkey_id : Optional[str]
+            Passkey ID. Choose a custom ID or generate a random ID with `ID.unique()`. Valid chars are a-z, A-Z, 0-9, period, hyphen, and underscore. Can't start with a special char. Max length is 36 chars.
+        name : Optional[str]
+            Passkey name, shown when listing passkeys. Max length: 128 chars.
+        Returns
+        -------
+        PasskeyChallenge
+            API response as a typed Pydantic model
+
+        Raises
+        ------
+        AppwriteException
+            If API request fails
+        """
+
+        api_path = '/account/passkeys'
+        api_params = {}
+        if passkey_id is not None:
+            api_params['passkeyId'] = self._normalize_value(passkey_id)
+        if name is not None:
+            api_params['name'] = self._normalize_value(name)
+
+        response = self.client.call(
+            'post',
+            api_path,
+            {
+                'X-Appwrite-Project': self.client.get_config('project'),
+                'content-type': 'application/json',
+                'accept': 'application/json',
+            },
+            api_params,
+        )
+
+        return self._parse_response(response, model=PasskeyChallenge)
+
+    def get_passkey(
+        self,
+        passkey_id: str,
+    ) -> Passkey:
+        """
+        Get a verified passkey of the currently logged in user by its unique ID.
+
+        Parameters
+        ----------
+        passkey_id : str
+            Passkey ID.
+        Returns
+        -------
+        Passkey
+            API response as a typed Pydantic model
+
+        Raises
+        ------
+        AppwriteException
+            If API request fails
+        """
+
+        api_path = '/account/passkeys/{passkeyId}'
+        api_params = {}
+        if passkey_id is None or passkey_id == '':
+            raise AppwriteException('Missing required parameter: "passkey_id"')
+        api_path = api_path.replace('{passkeyId}', str(self._normalize_value(passkey_id)))
+
+        response = self.client.call(
+            'get',
+            api_path,
+            {
+                'X-Appwrite-Project': self.client.get_config('project'),
+                'accept': 'application/json',
+            },
+            api_params,
+        )
+
+        return self._parse_response(response, model=Passkey)
+
+    def update_passkey(
+        self,
+        passkey_id: str,
+        name: str,
+    ) -> Passkey:
+        """
+        Rename a passkey of the currently logged in user.
+
+        Parameters
+        ----------
+        passkey_id : str
+            Passkey ID.
+        name : str
+            Passkey name. Max length: 128 chars.
+        Returns
+        -------
+        Passkey
+            API response as a typed Pydantic model
+
+        Raises
+        ------
+        AppwriteException
+            If API request fails
+        """
+
+        api_path = '/account/passkeys/{passkeyId}'
+        api_params = {}
+        if passkey_id is None or passkey_id == '':
+            raise AppwriteException('Missing required parameter: "passkey_id"')
+        if name is None:
+            raise AppwriteException('Missing required parameter: "name"')
+        api_path = api_path.replace('{passkeyId}', str(self._normalize_value(passkey_id)))
+        api_params['name'] = self._normalize_value(name)
+
+        response = self.client.call(
+            'patch',
+            api_path,
+            {
+                'X-Appwrite-Project': self.client.get_config('project'),
+                'content-type': 'application/json',
+                'accept': 'application/json',
+            },
+            api_params,
+        )
+
+        return self._parse_response(response, model=Passkey)
+
+    def delete_passkey(
+        self,
+        passkey_id: str,
+    ) -> Dict[str, Any]:
+        """
+        Delete a passkey from the currently logged in user. The passkey can no longer be used to sign in, although it may remain stored on the user's device. The session must have signed in or completed an MFA challenge within the last 10 minutes.
+
+        Parameters
+        ----------
+        passkey_id : str
+            Passkey ID.
+        Returns
+        -------
+        Dict[str, Any]
+            API response as a dictionary
+
+        Raises
+        ------
+        AppwriteException
+            If API request fails
+        """
+
+        api_path = '/account/passkeys/{passkeyId}'
+        api_params = {}
+        if passkey_id is None or passkey_id == '':
+            raise AppwriteException('Missing required parameter: "passkey_id"')
+        api_path = api_path.replace('{passkeyId}', str(self._normalize_value(passkey_id)))
+
+        response = self.client.call(
+            'delete',
+            api_path,
+            {
+                'X-Appwrite-Project': self.client.get_config('project'),
+                'content-type': 'application/json',
+                'accept': 'application/json',
+            },
+            api_params,
+        )
+
+        return response
+
+    def update_passkey_verification(
+        self,
+        passkey_id: str,
+        credential: Dict[str, Any],
+    ) -> Passkey:
+        """
+        Complete a passkey registration started with [Create passkey](/docs/references/cloud/client-web/account#createPasskey). Pass the JSON form of the credential returned by `navigator.credentials.create()`, for example `credential.toJSON()`. Each registration can be verified once; a failed attempt requires starting it again.
+
+        Parameters
+        ----------
+        passkey_id : str
+            Passkey ID.
+        credential : Dict[str, Any]
+            Registration credential returned by the authenticator, in the JSON form produced by `PublicKeyCredential.toJSON()`.
+        Returns
+        -------
+        Passkey
+            API response as a typed Pydantic model
+
+        Raises
+        ------
+        AppwriteException
+            If API request fails
+        """
+
+        api_path = '/account/passkeys/{passkeyId}/verification'
+        api_params = {}
+        if passkey_id is None or passkey_id == '':
+            raise AppwriteException('Missing required parameter: "passkey_id"')
+        if credential is None:
+            raise AppwriteException('Missing required parameter: "credential"')
+        api_path = api_path.replace('{passkeyId}', str(self._normalize_value(passkey_id)))
+        api_params['credential'] = self._normalize_value(credential)
+
+        response = self.client.call(
+            'put',
+            api_path,
+            {
+                'X-Appwrite-Project': self.client.get_config('project'),
+                'content-type': 'application/json',
+                'accept': 'application/json',
+            },
+            api_params,
+        )
+
+        return self._parse_response(response, model=Passkey)
+
     def update_password(
         self,
         password: str,
@@ -1928,6 +2196,85 @@ class Account(Service):
 
         return response
 
+    def create_passkey_token(
+        self,
+    ) -> PasskeyChallenge:
+        """
+        Start signing in with a passkey. No email or user ID is needed: pass the returned `publicKey` options to `navigator.credentials.get()` and the user picks one of their passkeys. Then call [Update passkey token](/docs/references/cloud/client-web/account#updatePasskeyToken) with the credential to receive a token, and exchange it with [Create session](/docs/references/cloud/client-web/account#createSession). The challenge expires after 5 minutes.
+        Returns
+        -------
+        PasskeyChallenge
+            API response as a typed Pydantic model
+
+        Raises
+        ------
+        AppwriteException
+            If API request fails
+        """
+
+        api_path = '/account/tokens/passkey'
+        api_params = {}
+
+        response = self.client.call(
+            'post',
+            api_path,
+            {
+                'X-Appwrite-Project': self.client.get_config('project'),
+                'content-type': 'application/json',
+                'accept': 'application/json',
+            },
+            api_params,
+        )
+
+        return self._parse_response(response, model=PasskeyChallenge)
+
+    def update_passkey_token(
+        self,
+        challenge_id: str,
+        credential: Dict[str, Any],
+    ) -> TokenSecret:
+        """
+        Complete a passkey sign-in started with [Create passkey token](/docs/references/cloud/client-web/account#createPasskeyToken). Pass the challenge ID and the JSON form of the credential returned by `navigator.credentials.get()`, for example `credential.toJSON()`. The returned token includes its secret and expires after 1 minute: exchange it for a session with [Create session](/docs/references/cloud/client-web/account#createSession). Passkeys require user verification, so the session also satisfies MFA. Each challenge can only be used once.
+
+        Parameters
+        ----------
+        challenge_id : str
+            Challenge ID returned by createPasskeyToken.
+        credential : Dict[str, Any]
+            Authentication credential returned by the authenticator, in the JSON form produced by `PublicKeyCredential.toJSON()`.
+        Returns
+        -------
+        TokenSecret
+            API response as a typed Pydantic model
+
+        Raises
+        ------
+        AppwriteException
+            If API request fails
+        """
+
+        api_path = '/account/tokens/passkey'
+        api_params = {}
+        if challenge_id is None:
+            raise AppwriteException('Missing required parameter: "challenge_id"')
+        if credential is None:
+            raise AppwriteException('Missing required parameter: "credential"')
+        api_params['challengeId'] = self._normalize_value(challenge_id)
+        api_params['credential'] = self._normalize_value(credential)
+
+        response = self.client.call(
+            'put',
+            api_path,
+            {
+                'X-Appwrite-Project': self.client.get_config('project'),
+                'content-type': 'application/json',
+                'accept': 'application/json',
+            },
+            api_params,
+        )
+
+        return self._parse_response(response, model=TokenSecret)
+
     def create_phone_token(
         self,
         user_id: str,

{appwrite-24.1.0 → appwrite-24.3.0}/appwrite/services/functions.py

@@ -100,6 +100,7 @@ class Functions(Service):
         build_specification: Optional[str] = None,
         runtime_specification: Optional[str] = None,
         deployment_retention: Optional[float] = None,
+        interval: Optional[float] = None,
     ) -> Function:
         """
         Create a new function. You can pass a list of [permissions](https://appwrite.io/docs/permissions) to allow different project users or team with access to execute the function using the client API.
@@ -117,7 +118,7 @@ class Functions(Service):
         events : Optional[List[str]]
             Events list. Maximum of 100 events are allowed.
         schedule : Optional[str]
-            Schedule CRON syntax.
+            Schedule CRON syntax. Cannot be combined with interval.
         timeout : Optional[float]
             Function maximum execution time in seconds.
         enabled : Optional[bool]
@@ -150,6 +151,8 @@ class Functions(Service):
             Runtime specification for the function executions.
         deployment_retention : Optional[float]
             Days to keep non-active deployments before deletion. Value 0 means all deployments will be kept.
+        interval : Optional[float]
+            Minutes between scheduled executions. Appwrite picks when within each interval the function runs. Use 0 to disable. Cannot be combined with schedule.
         Returns
         -------
         Function
@@ -210,6 +213,8 @@ class Functions(Service):
             api_params['runtimeSpecification'] = self._normalize_value(runtime_specification)
         if deployment_retention is not None:
             api_params['deploymentRetention'] = self._normalize_value(deployment_retention)
+        if interval is not None:
+            api_params['interval'] = self._normalize_value(interval)
 
         response = self.client.call(
             'post',
@@ -358,6 +363,7 @@ class Functions(Service):
         build_specification: Optional[str] = None,
         runtime_specification: Optional[str] = None,
         deployment_retention: Optional[float] = None,
+        interval: Optional[float] = None,
     ) -> Function:
         """
         Update function by its unique ID.
@@ -375,7 +381,7 @@ class Functions(Service):
         events : Optional[List[str]]
             Events list. Maximum of 100 events are allowed.
         schedule : Optional[str]
-            Schedule CRON syntax.
+            Schedule CRON syntax. Cannot be combined with interval.
         timeout : Optional[float]
             Maximum execution time in seconds.
         enabled : Optional[bool]
@@ -408,6 +414,8 @@ class Functions(Service):
             Runtime specification for the function executions.
         deployment_retention : Optional[float]
             Days to keep non-active deployments before deletion. Value 0 means all deployments will be kept.
+        interval : Optional[float]
+            Minutes between scheduled executions. Appwrite picks when within each interval the function runs. Use 0 to disable. Cannot be combined with schedule. When omitted, the current interval is kept unless schedule is set.
         Returns
         -------
         Function
@@ -467,6 +475,8 @@ class Functions(Service):
             api_params['runtimeSpecification'] = self._normalize_value(runtime_specification)
         if deployment_retention is not None:
             api_params['deploymentRetention'] = self._normalize_value(deployment_retention)
+        if interval is not None:
+            api_params['interval'] = self._normalize_value(interval)
 
         response = self.client.call(
             'put',