Référence du SDK Python | Frame.io API Documentation

Installation

pip install frameio

Utilisation

Instanciez et utilisez le client comme suit :

from frameio import (
    Frameio,
    SelectDefinitionParamsFieldConfiguration,
    SelectDefinitionParamsFieldConfigurationOptionsItem,
)
from frameio.metadata_fields import CreateFieldDefinitionParamsData_Select
client = Frameio(
    token="YOUR_TOKEN",
)
client.metadata_fields.metadata_field_definitions_create(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=CreateFieldDefinitionParamsData_Select(
        field_configuration=SelectDefinitionParamsFieldConfiguration(
            enable_add_new=False,
            options=[
                SelectDefinitionParamsFieldConfigurationOptionsItem(
                    display_name="Option 1",
                ),
                SelectDefinitionParamsFieldConfigurationOptionsItem(
                    display_name="Option 2",
                ),
            ],
        ),
        name="Fields definition name",
    ),
)

Client asynchrone

Le SDK fournit également un client asynchrone qui vous permet d’effectuer des appels non bloquants vers notre API. Notez que si vous créez une classe de client httpx asynchrone à passer à ce client, préférez httpx.AsyncClient() à httpx.Client() (par exemple, pour le paramètre httpx_client de ce client).

import asyncio
from frameio import (
    AsyncFrameio,
    SelectDefinitionParamsFieldConfiguration,
    SelectDefinitionParamsFieldConfigurationOptionsItem,
)
from frameio.metadata_fields import CreateFieldDefinitionParamsData_Select
client = AsyncFrameio(
    token="YOUR_TOKEN",
)
async def main() -> None:
    await client.metadata_fields.metadata_field_definitions_create(
        account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
        data=CreateFieldDefinitionParamsData_Select(
            field_configuration=SelectDefinitionParamsFieldConfiguration(
                enable_add_new=False,
                options=[
                    SelectDefinitionParamsFieldConfigurationOptionsItem(
                        display_name="Option 1",
                    ),
                    SelectDefinitionParamsFieldConfigurationOptionsItem(
                        display_name="Option 2",
                    ),
                ],
            ),
            name="Fields definition name",
        ),
    )
asyncio.run(main())

Gestion des exceptions

Lorsque l’API renvoie un code d’état indiquant un échec (réponse 4xx ou 5xx), une sous-classe de l’erreur suivante sera levée.

from frameio.core.api_error import ApiError
try:
    client.metadata_fields.metadata_field_definitions_create(...)
except ApiError as e:
    print(e.status_code)
    print(e.body)

Pagination

Les requêtes paginées renvoient un SyncPager ou un AsyncPager, qui peuvent servir de générateurs pour l’objet sous-jacent.

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
response = client.project_permissions.index(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    project_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    page_size=10,
    include_total_count=False,
)
for item in response:
    yield item
# alternatively, you can paginate page-by-page
for page in response.iter_pages():
    yield page

Avancé

Accéder aux données brutes de réponse

Le SDK permet d’accéder aux données brutes de la réponse, y compris les en-têtes, via la propriété .with_raw_response. La propriété .with_raw_response renvoie un client « brut » qui permet d’accéder aux attributs .headers et .data.

from frameio import Frameio
client = Frameio(
    ...,
)
response = (
    client.metadata_fields.with_raw_response.metadata_field_definitions_create(
        ...
    )
)
print(response.headers)  # access the response headers
print(response.data)  # access the underlying object
pager = client.project_permissions.index(...)
print(pager.response.headers)  # access the response headers for the first page
for item in pager:
    print(item)  # access the underlying object(s)
for page in pager.iter_pages():
    print(page.response.headers)  # access the response headers for each page
    for item in page:
        print(item)  # access the underlying object(s)

Tentatives

Le SDK est configuré pour effectuer des tentatives de reconnexion automatiques avec un délai d’attente exponentiel. Une requête sera retentée tant qu’elle est considérée comme pouvant faire l’objet d’une nouvelle tentative et que le nombre de tentatives n’a pas dépassé la limite configurée (par défaut : 2).

Une requête est considérée comme pouvant faire l’objet d’une nouvelle tentative lorsque l’un des codes d’état HTTP suivants est renvoyé :

408 (Délai d’attente de la requête)
429 (Trop de requêtes)
5XX (Erreur interne du serveur)

Utilisez l’option de requête max_retries pour configurer ce comportement.

client.metadata_fields.metadata_field_definitions_create(..., request_options={
    "max_retries": 1
})

Délais d’expiration

Le SDK utilise par défaut un délai d’expiration de 60 secondes. Vous pouvez configurer cette option à l’aide d’un délai d’expiration au niveau du client ou de la requête.

from frameio import Frameio
client = Frameio(
    ...,
    timeout=20.0,
)
# Override timeout for a specific method
client.metadata_fields.metadata_field_definitions_create(..., request_options={
    "timeout_in_seconds": 1
})

Client personnalisé

Vous pouvez modifier le client httpx afin de l’adapter à votre cas d’utilisation. Parmi les cas d’utilisation courants, on peut citer la prise en charge des proxys et des protocoles de transport.

import httpx
from frameio import Frameio
client = Frameio(
    ...,
    httpx_client=httpx.Client(
        proxy="http://my.test.proxy.example.com",
        transport=httpx.HTTPTransport(local_address="0.0.0.0"),
    ),
)

Référence

Authentification

frameio.auth.ServerToServerAuth(*, client_id, client_secret, ...)

S’authentifier à l’aide de client_credentials grant OAuth 2.0. Ce flux n’implique aucun utilisateur et ne renvoie pas de jeton d’actualisation. Lorsque le jeton d’accès expire, le SDK envoie automatiquement une requête pour en demander un nouveau à l’aide des informations d’identification du client. Pour une utilisation asynchrone, choisissez AsyncServerToServerAuth.

usage

from frameio import Frameio
from frameio.auth import ServerToServerAuth
auth = ServerToServerAuth(client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET")
client = Frameio(token=auth.get_token)

Paramètres

client_id : str – ID client OAuth Adobe IMS.

client_secret : str – Secret client OAuth Adobe IMS.

scopes : str – Portées séparées par des espaces (OAuth 2.0 RFC 6749). Valeurs par défaut : openid AdobeID frame.s2s.all.

ims_base_url : str – URL de base IMS pour les environnements d’évaluation/de secours. Par défaut : production.

http_client : typing.Optional[httpx.Client] – httpx facultatif.Client pour proxy, TLS ou mise en pool des connexions.

on_token_refreshed : typing.Optional[typing.Callable[[dict[str, Any]], None]] – Rappel facultatif déclenché après chaque récupération de jeton.

timeout : float – Délai d’expiration de la requête HTTP en secondes. Par défaut : 30.

max_retries : int – Nombre maximal de tentatives en cas de défaillances temporaires. Par défaut : 2.

refresh_buffer : int – Nombre de secondes avant l’expiration pour déclencher une actualisation proactive. Par défaut : 60. Méthodes get_token() -> str – Renvoyer un jeton d’accès valide, en le renouvelant si nécessaire. Transmettre cette référence de méthode (et non un appel) au SDK : Frameio(token=auth.get_token). authenticate() -> dict[str, Any] – Récupérer explicitement un nouveau jeton d’accès. Renvoie le dictionnaire de réponse du jeton avec access_token, expires_in, etc. revoke() -> None – Révoquer les deux jetons côté serveur et efface l’état local. export_tokens() -> dict[str, Any] – Exporter l’état actuel du jeton à des fins de persistance. import_tokens(data: dict[str, Any]) -> None – Restaurer l’état du jeton à partir d’un dictionnaire précédemment exporté.

frameio.auth.WebAppAuth(*, client_id, client_secret, redirect_uri, ...)

Se connecter à l’aide de authorization_code grant OAuth 2.0. Utilisez cette option pour les applications côté serveur capables de stocker en toute sécurité un secret client. Pour une utilisation asynchrone, choisissez AsyncWebAppAuth.

usage

import secrets
from frameio import Frameio
from frameio.auth import WebAppAuth
auth = WebAppAuth(
    client_id="YOUR_CLIENT_ID",
    client_secret="YOUR_CLIENT_SECRET",
    redirect_uri="https://myapp.com/callback",
)
url = auth.get_authorization_url(state=secrets.token_urlsafe(32))
# redirect user to url ...
auth.exchange_code(code="CODE_FROM_CALLBACK")
client = Frameio(token=auth.get_token)

Paramètres

client_id : str – ID client OAuth Adobe IMS.

client_secret : str – Secret client OAuth Adobe IMS.

redirect_uri : str – URI de redirection enregistré.

scopes : str – Portées séparées par des espaces (OAuth 2.0 RFC 6749).

ims_base_url : str – URL de base IMS pour les environnements d’évaluation/de secours. Par défaut : production.

http_client : typing.Optional[httpx.Client] – httpx facultatif.Client pour proxy, TLS ou mise en pool des connexions.

on_token_refreshed : typing.Optional[typing.Callable[[dict[str, Any]], None]] – Rappel facultatif déclenché après chaque récupération de jeton.

timeout : float – Délai d’expiration de la requête HTTP en secondes. Par défaut : 30.

max_retries : int – Nombre maximal de tentatives en cas de défaillances temporaires. Par défaut : 2.

refresh_buffer : int – Nombre de secondes avant l’expiration pour déclencher une actualisation proactive. Par défaut : 60. Méthodes get_token() -> str – Renvoyer un jeton d’accès valide, en le renouvelant si nécessaire. Transmettre cette référence de méthode au SDK : Frameio(token=auth.get_token). get_authorization_url(state: str) -> str – Créer l’URL d’autorisation Adobe IMS. Transmettre une valeur CSRF/état opaque qui sera renvoyée. exchange_code(code: str) -> dict[str, Any] – Échanger un code d’autorisation contre des jetons d’accès et d’actualisation. refresh() -> dict[str, Any] – Déclencher manuellement une actualisation du jeton. revoke() -> None – Révoquer les deux jetons côté serveur et efface l’état local. export_tokens() -> dict[str, Any] – Exporter l’état actuel du jeton à des fins de persistance. import_tokens(data: dict[str, Any]) -> None – Restaurer l’état du jeton à partir d’un dictionnaire précédemment exporté.

frameio.auth.SPAAuth(*, client_id, redirect_uri, ...)

S’authentifier à l’aide de authorization_code + PKCE (pas de secret client). Utilisez cette option pour les applications web ou natives qui ne peuvent pas stocker un secret client en toute sécurité. Pour une utilisation asynchrone, choisissez AsyncSPAAuth.

usage

import secrets
from frameio import Frameio
from frameio.auth import SPAAuth
auth = SPAAuth(client_id="YOUR_CLIENT_ID", redirect_uri="https://myapp.com/cb")
result = auth.get_authorization_url(state=secrets.token_urlsafe(32))
# redirect user to result.url, store result.code_verifier
auth.exchange_code(code="CODE_FROM_CALLBACK", code_verifier=result.code_verifier)
client = Frameio(token=auth.get_token)

Paramètres

client_id : str – ID client OAuth Adobe IMS.

redirect_uri : str – URI de redirection enregistré.

scopes : str – Portées séparées par des espaces (OAuth 2.0 RFC 6749).

ims_base_url : str – URL de base IMS pour les environnements d’évaluation/de secours. Par défaut : production.

http_client : typing.Optional[httpx.Client] – httpx facultatif.Client pour proxy, TLS ou mise en pool des connexions.

on_token_refreshed : typing.Optional[typing.Callable[[dict[str, Any]], None]] – Rappel facultatif déclenché après chaque récupération de jeton.

timeout : float – Délai d’expiration de la requête HTTP en secondes. Par défaut : 30.

max_retries : int – Nombre maximal de tentatives en cas de défaillances temporaires. Par défaut : 2.

refresh_buffer : int – Nombre de secondes avant l’expiration pour déclencher une actualisation proactive. Par défaut : 60. Méthodes get_token() -> str – Renvoyer un jeton d’accès valide, en le renouvelant si nécessaire. Transmettre cette référence de méthode au SDK : Frameio(token=auth.get_token). get_authorization_url(state: str) -> AuthorizationUrlResult – Créer l’URL d’autorisation Adobe IMS avec un défi PKCE. Renvoie un AuthorizationUrlResult avec les attributs url et code_verifier. exchange_code(code: str, code_verifier : str) -> dict[str, Any] – Échange un code d’autorisation et un vérificateur PKCE contre des jetons. refresh() -> dict[str, Any] – Déclencher manuellement une actualisation du jeton. revoke() -> None – Révoquer les deux jetons côté serveur et efface l’état local. export_tokens() -> dict[str, Any] – Exporter l’état actuel du jeton à des fins de persistance. import_tokens(data: dict[str, Any]) -> None – Restaurer l’état du jeton à partir d’un dictionnaire précédemment exporté.

frameio.auth.AuthorizationUrlResult

Classe de données figée, renvoyée par SPAAuth.get_authorization_url() et AsyncSPAAuth.get_authorization_url(). Contient l’URL d’autorisation et le vérificateur de code PKCE. Attributs url : str – L’URL d’autorisation complète vers laquelle rediriger l’utilisateur.

code_verifier : str – Le vérificateur de code PKCE permettant de stocker et de transmettre à exchange_code().

frameio.auth.close_clients() / aclose_clients()

Fermez les clients HTTP au niveau du module utilisés par le module d’authentification. Appelez la fonction close_clients() dans le code synchrone ou utilisez await close_clients() dans le code asynchrone lors de l’arrêt de l’application afin de libérer les connexions.

usage

from frameio.auth import close_clients
# During application shutdown
close_clients()

Exceptions relatives aux authentifications

Toutes les exceptions d’authentification proviennent de FrameioAuthError.

Exception	Description
`FrameioAuthError`	Exception de base pour toutes les erreurs `frameio.auth`.
`AuthenticationError`	L’échange ou l’actualisation du jeton a échoué. A les attributs `error_code` et `error_description`.
`TokenExpiredError`	Le jeton d’actualisation a expiré ; une nouvelle authentification est requise.
`ConfigurationError`	La configuration requise est manquante ou non valide.
`NetworkError`	Échec de la requête réseau (délai d’expiration dépassé, erreur de connexion, etc.).
`RateLimitError`	L’API a renvoyé le code 429 et le nombre de tentatives est épuisé. A l’attribut `retry_after`.
`PKCEError`	Échec de la vérification PKCE.

Métadonnées

client.metadata.bulk_update(...) -> AsyncHttpResponse[None]

Mise à jour des valeurs des métadonnées sur plusieurs fichiers.

Limites de débit : 10 appels par minute et par account_user

usage

from frameio import Frameio
from frameio.metadata import (
    BulkUpdateMetadataParamsData,
    BulkUpdateMetadataParamsDataValuesItem,
)
client = Frameio(
    token="YOUR_TOKEN",
)
client.metadata.bulk_update(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    project_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=BulkUpdateMetadataParamsData(
        file_ids=[
            "09b31c2a-04de-464a-a593-643a36ef0d98",
            "b967fc36-4e18-4b48-a3ab-c790100e2baa",
        ],
        values=[
            BulkUpdateMetadataParamsDataValuesItem(
                field_definition_id="ff41ce50-269b-4624-8306-aac10e28ab94",
                value=[
                    {
                        "id": "e60f47b4-cf8e-4273-96d5-3258a830a0aa",
                        "type": "user",
                    },
                    {
                        "id": "24eeaf7e-ce27-4555-bc77-cce39900626d",
                        "type": "account_user_group",
                    },
                ],
            )
        ],
    ),
)

Paramètres

account_id : Uuid

project_id : Uuid

data : BulkUpdateMetadataParamsData

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.metadata.show(...) -> AsyncHttpResponse[MetadataResponse]

Afficher les métadonnées d’un fichier.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.metadata.show(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    file_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    show_null=True,
)

Paramètres

account_id : Uuid

file_id : Uuid

show_null : typing.Optional[bool]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

Champs de métadonnées

client.metadata_fields.metadata_field_definitions_delete(...) -> AsyncHttpResponse[None]

Supprimer les définitions des champs personnalisés au niveau du compte.

Limites de débit : 60 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.metadata_fields.metadata_field_definitions_delete(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    field_definition_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
)

Paramètres

account_id : Uuid

field_definition_id : Uuid

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.metadata_fields.metadata_field_definitions_update(...) -> AsyncHttpResponse[FieldDefinitionResponse]

Mise à jour des définitions de champs personnalisés au niveau du compte.

Limites de débit : 10 appels par minute et par account_user

usage

from frameio import (
    Frameio,
    UpdateSelectDefinitionParamsFieldConfiguration,
    UpdateSelectDefinitionParamsFieldConfigurationOptionsItem,
)
from frameio.metadata_fields import UpdateFieldDefinitionParamsData_Select
client = Frameio(
    token="YOUR_TOKEN",
)
client.metadata_fields.metadata_field_definitions_update(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    field_definition_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=UpdateFieldDefinitionParamsData_Select(
        field_configuration=UpdateSelectDefinitionParamsFieldConfiguration(
            enable_add_new=False,
            options=[
                UpdateSelectDefinitionParamsFieldConfigurationOptionsItem(
                    display_name="Option 1",
                ),
                UpdateSelectDefinitionParamsFieldConfigurationOptionsItem(
                    display_name="Option 2",
                ),
            ],
        ),
        name="Updated-Field-Name",
    ),
)

Paramètres

account_id : Uuid

field_definition_id : Uuid

data : typing.Optional[UpdateFieldDefinitionParamsData]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.metadata_fields.metadata_field_definitions_index(...) -> AsyncHttpResponse[FieldDefinitionsWithIncludesResponse]

Liste des définitions de champs au niveau du compte.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.metadata_fields.metadata_field_definitions_index(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    after="<opaque_cursor>",
    page_size=10,
    include_total_count=False,
)

Paramètres

account_id : Uuid –

include: typing.Optional[typing.Literal[“creator”]]

after : typing.Optional[RequestAfterOpaqueCursor]

Paramètre de requête Opaque Cursor pour les requêtes renvoyant des résultats paginés.

Cette valeur est générée automatiquement et incluse dans les liens d’une réponse précédente. Elle n’est pas destinée à être lisible par un humain.

page_size : typing.Optional[RequestPageSize]

include_total_count : typing.Optional[IncludeTotalCount]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.metadata_fields.metadata_field_definitions_create(...) -> AsyncHttpResponse[FieldDefinitionResponse]

Créer des définitions de champ au niveau du compte.

Limites de débit : 10 appels par minute et par account_user

usage

from frameio import (
    Frameio,
    SelectDefinitionParamsFieldConfiguration,
    SelectDefinitionParamsFieldConfigurationOptionsItem,
)
from frameio.metadata_fields import CreateFieldDefinitionParamsData_Select
client = Frameio(
    token="YOUR_TOKEN",
)
client.metadata_fields.metadata_field_definitions_create(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=CreateFieldDefinitionParamsData_Select(
        field_configuration=SelectDefinitionParamsFieldConfiguration(
            enable_add_new=False,
            options=[
                SelectDefinitionParamsFieldConfigurationOptionsItem(
                    display_name="Option 1",
                ),
                SelectDefinitionParamsFieldConfigurationOptionsItem(
                    display_name="Option 2",
                ),
            ],
        ),
        name="Fields definition name",
    ),
)

Paramètres

account_id : Uuid

data : typing.Optional[CreateFieldDefinitionParamsData]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

Autorisations sur le projet

client.project_permissions.index(...) -> AsyncPager[UserRole, UserRolesResponse]

Répertorier les rôles d’utilisateur pour un projet donné.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
response = client.project_permissions.index(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    project_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    include_deactivated=True,
    after="<opaque_cursor>",
    page_size=10,
    include_total_count=False,
)
for item in response:
    yield item
# alternatively, you can paginate page-by-page
for page in response.iter_pages():
    yield page

Paramètres

account_id : Uuid

project_id : Uuid

include_deactivated : typing.Optional[bool] – Permet d’inclure les utilisateurs désactivés dans la réponse. La valeur par défaut est faux.

after : typing.Optional[RequestAfterOpaqueCursor]

Paramètre de requête Opaque Cursor pour les requêtes renvoyant des résultats paginés.

REMARQUE : cette valeur est générée automatiquement et incluse dans les liens d’une réponse précédente. Elle n’est pas destinée à être lisible par un humain.

page_size : typing.Optional[RequestPageSize]

include_total_count : typing.Optional[IncludeTotalCount]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.project_permissions.delete(...) -> AsyncHttpResponse[None]

Supprimer un utilisateur du projet spécifié.

Limites de débit : 60 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.project_permissions.delete(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    project_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    user_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
)

Paramètres

account_id : Uuid

project_id : Uuid

user_id : Uuid

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.project_permissions.project_user_roles_update(...) -> AsyncHttpResponse[UpdateUserRolesResponse]

Mettre à jour les rôles des utilisateurs pour le projet spécifié si celui-ci a déjà été ajouté au projet. Si l’utilisateur n’est pas encore ajouté au projet, il sera ajouté avec le rôle indiqué.

Limites de débit : 10 appels par minute et par account_user

usage

from frameio import Frameio, UpdateUserRolesParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.project_permissions.project_user_roles_update(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    project_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    user_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=UpdateUserRolesParamsData(
        role="editor",
    ),
)

Paramètres

account_id : Uuid

project_id : Uuid

user_id : Uuid

data : UpdateUserRolesParamsData

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

Projets

client.projects.show(...) -> AsyncHttpResponse[ProjectWithIncludesResponse]

Afficher les détails du projet.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.projects.show(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    project_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
)

Paramètres

account_id : Uuid

project_id : Uuid

include : typing.Optional[typing.Literal["owner"]]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.projects.delete(...) -> AsyncHttpResponse[None]

Supprimer un projet.

Limites de débit : 60 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.projects.delete(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    project_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
)

Paramètres

account_id : Uuid

project_id : Uuid

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.projects.update(...) -> AsyncHttpResponse[ProjectResponse]

Mettre à jour les détails du projet.

Limites de débit : 10 appels par minute et par account_user

usage

from frameio import Frameio
from frameio.projects import ProjectUpdateParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.projects.update(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    project_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=ProjectUpdateParamsData(
        name="Project Name",
        restricted=True,
        status="active",
    ),
)

Paramètres

account_id : Uuid

project_id : Uuid

data : ProjectUpdateParamsData

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.projects.index(...) -> AsyncPager[ProjectWithIncludes, ProjectsWithIncludesResponse]

Répertorier des projets dans un espace de travail donné.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
response = client.projects.index(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    workspace_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    after="<opaque_cursor>",
    page_size=10,
    include_total_count=False,
)
for item in response:
    yield item
# alternatively, you can paginate page-by-page
for page in response.iter_pages():
    yield page

Paramètres

account_id : Uuid

workspace_id : Uuid

include : typing.Optional[typing.Literal["owner"]]

after : typing.Optional[RequestAfterOpaqueCursor]

Paramètre de requête Opaque Cursor pour les requêtes renvoyant des résultats paginés.

Cette valeur est générée automatiquement et incluse dans les liens d’une réponse précédente. Elle n’est pas destinée à être lisible par un humain.

page_size : typing.Optional[RequestPageSize] –

include_total_count : typing.Optional[IncludeTotalCount]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.projects.create(...) -> AsyncHttpResponse[ProjectResponse]

Créer un projet dans un espace de travail donné.

Limites de débit : 10 appels par minute et par account_user

usage

from frameio import Frameio
from frameio.projects import ProjectParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.projects.create(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    workspace_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=ProjectParamsData(
        name="Project Name",
        restricted=True,
    ),
)

Paramètres

account_id : Uuid

workspace_id : Uuid

data : ProjectParamsData

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

Dossiers

client.folders.show(...) -> AsyncHttpResponse[FolderWithIncludesResponse]

Afficher les détails du dossier.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.folders.show(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    folder_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    include="creator",
)

Paramètres

account_id : Uuid

folder_id : Uuid

include : typing.Optional[AssetInclude]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.folders.delete(...) -> AsyncHttpResponse[None]

Supprimer un dossier par son identifiant.

Limites de débit : 60 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.folders.delete(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    folder_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
)

Paramètres

account_id : Uuid

folder_id : Uuid

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.folders.update(...) -> AsyncHttpResponse[FolderResponse]

Mettre à jour les détails du dossier.

Limites de débit : 10 appels par minute et par account_user

usage

from frameio import Frameio
from frameio.folders import FolderUpdateParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.folders.update(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    folder_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=FolderUpdateParamsData(
        name="Folder name",
    ),
)

Paramètres

account_id : Uuid

folder_id : Uuid

data : FolderUpdateParamsData

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.folders.index(...) -> AsyncHttpResponse[AssetsWithIncludesResponse]

Répertorier les enfants dans un dossier donné.

Utilisez le paramètre de requête « include » pour inclure de manière sélective des propriétés supplémentaires dans la réponse.

Si vous incluez media_links.original et que l’utilisateur n’est pas autorisé à télécharger des fichiers dans le projet correspondant, ce point d’entrée renverra une erreur 403 Interdit. Si le contenu est inaccessible parce qu’un filigrane est requis pour cet utilisateur et n’est pas pris en charge par les liens de médias demandés, la requête aboutira, mais les liens de médias non pris en charge seront définis sur « null ». De même, si le lien de transcodage demandé n’existe pas pour un fichier donné (par exemple, media_links.video_h264_180 pour un fichier image statique) ou si le processus de transcodage n’est pas terminé (c’est-à-dire que le statut du fichier est « chargé » et non « transcodé »,) le lien de médias sera également défini sur « null » dans la payload de la réponse. En résumé, le client doit gérer correctement les liens de médias nuls.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.folders.index(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    folder_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    include="media_links",
    type="file,folder,version_stack",
    after="<opaque_cursor>",
    page_size=10,
    include_total_count=False,
)

Paramètres

account_id : Uuid

folder_id : Uuid

include : typing.Optional[FileWithMediaLinksInclude]

type : typing.Optional[ChildrenType]

after : typing.Optional[RequestAfterOpaqueCursor]

Paramètre de requête Opaque Cursor pour les requêtes renvoyant des résultats paginés.

Cette valeur est générée automatiquement et incluse dans les liens d’une réponse précédente. Elle n’est pas destinée à être lisible par un humain.

page_size : typing.Optional[RequestPageSize]

include_total_count : typing.Optional[IncludeTotalCount]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.folders.copy(...) -> AsyncHttpResponse[FolderCopyResponse]

Copier le dossier.

Limites de débit : 10 appels par minute et par account_user

usage

from frameio import Frameio
from frameio.folders import FolderCopyParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.folders.copy(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    folder_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    copy_metadata=True,
    data=FolderCopyParamsData(
        parent_id="2e426fe0-f965-4594-8b2b-b4dff1dc00ec",
    ),
)

Paramètres

account_id : Uuid

folder_id : Uuid

copy_metadata : typing.Optional[bool] – Whether to copy metadata values along with the folder

data : typing.Optional[FolderCopyParamsData]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.folders.list(...) -> AsyncHttpResponse[FoldersWithIncludesResponse]

Répertorier des dossiers au sein d’un dossier donné.

Limites de débit : 5 appels par seconde et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.folders.list(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    folder_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    include="creator",
    after="<opaque_cursor>",
    page_size=10,
    include_total_count=False,
)

Paramètres

account_id : Uuid

folder_id : Uuid

include : typing.Optional[AssetInclude]

after : typing.Optional[RequestAfterOpaqueCursor]

Paramètre de requête Opaque Cursor pour les requêtes renvoyant des résultats paginés.

Cette valeur est générée automatiquement et incluse dans les liens d’une réponse précédente. Elle n’est pas destinée à être lisible par un humain.

page_size : typing.Optional[RequestPageSize]

include_total_count : typing.Optional[IncludeTotalCount]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.folders.create(...) -> AsyncHttpResponse[FolderResponse]

Créer un nouveau dossier à l’intérieur du chemin spécifié par le paramètre de chemin d’accès folder_id.

Limites de débit : 3 appels par seconde et par account_user

usage

from frameio import Frameio
from frameio.folders import FolderCreateParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.folders.create(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    folder_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=FolderCreateParamsData(
        name="Folder name",
    ),
)

Paramètres

account_id : Uuid

folder_id : Uuid

data : FolderCreateParamsData

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.folders.move(...) -> AsyncHttpResponse[FolderResponse]

Déplacer le dossier vers un autre dossier.

Limites de débit : 10 appels par minute et par account_user

usage

from frameio import Frameio
from frameio.folders import FolderMoveParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.folders.move(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    folder_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=FolderMoveParamsData(
        parent_id="2e426fe0-f965-4594-8b2b-b4dff1dc00ec",
    ),
)

Paramètres

account_id : Uuid

folder_id : Uuid

data : FolderMoveParamsData

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

Piles de versions

client.version_stacks.index(...) -> AsyncHttpResponse[AssetsWithIncludesResponse]

Répertorier les éléments enfants (fichiers) d’une pile de versions donnée.

Utilisez le paramètre de requête « include » pour inclure de manière sélective des propriétés supplémentaires dans la réponse.

Si vous incluez media_links.original et que l’utilisateur n’est pas autorisé à télécharger des fichiers dans le projet correspondant, ce point d’entrée renverra une erreur 403 Interdit. Si le contenu est inaccessible parce qu’un filigrane est requis pour cet utilisateur et n’est pas pris en charge par les liens de médias demandés, la requête aboutira, mais les liens de médias non pris en charge seront définis sur « null ». De même, si le lien de transcodage demandé n’existe pas pour un fichier donné (par exemple, media_links.video_h264_180 pour un fichier image statique) ou si le processus de transcodage n’est pas terminé (c’est-à-dire que le statut du fichier est « chargé » et non « transcodé »,) le lien de médias sera également défini sur « null » dans la payload de la réponse. En résumé, le client doit gérer correctement les liens de médias nuls.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.version_stacks.index(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    version_stack_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    include="media_links",
    after="<opaque_cursor>",
    page_size=10,
    include_total_count=False,
)

Paramètres

account_id : Uuid

version_stack_id : Uuid

include : typing.Optional[FileWithMediaLinksInclude]

after : typing.Optional[RequestAfterOpaqueCursor]

Paramètre de requête Opaque Cursor pour les requêtes renvoyant des résultats paginés.

Cette valeur est générée automatiquement et incluse dans les liens d’une réponse précédente. Elle n’est pas destinée à être lisible par un humain.

page_size : typing.Optional[RequestPageSize]

include_total_count : typing.Optional[IncludeTotalCount]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.version_stacks.show(...) -> AsyncHttpResponse[VersionStackWithIncludesResponse]

Afficher les détails de la pile de versions.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.version_stacks.show(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    version_stack_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    include="media_links",
)

Paramètres

account_id : Uuid

version_stack_id : Uuid

include : typing.Optional[VersionStacksShowRequestInclude]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.version_stacks.copy(...) -> AsyncHttpResponse[VersionStackCopyResponse]

Copier une pile de versions.

Limites de débit : 10 appels par minute et par account_user

usage

from frameio import Frameio
from frameio.version_stacks import VersionStackCopyParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.version_stacks.copy(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    version_stack_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    copy_metadata=True,
    data=VersionStackCopyParamsData(
        parent_id="2e426fe0-f965-4594-8b2b-b4dff1dc00ec",
    ),
)

Paramètres

account_id : Uuid

version_stack_id : Uuid

copy_metadata : typing.Optional[bool] – Whether to copy metadata values along with the version stack

data : typing.Optional[VersionStackCopyParamsData]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.version_stacks.list(...) -> AsyncHttpResponse[VersionStacksWithIncludesResponse]

Répertorier des piles de versions au sein d’un dossier donné.

Limites de débit : 5 appels par seconde et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.version_stacks.list(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    folder_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    include="media_links",
    after="<opaque_cursor>",
    page_size=10,
    include_total_count=False,
)

Paramètres

account_id : Uuid

folder_id : Uuid

include : typing.Optional[FileWithMediaLinksInclude]

after : typing.Optional[RequestAfterOpaqueCursor]

Paramètre de requête Opaque Cursor pour les requêtes renvoyant des résultats paginés.

Cette valeur est générée automatiquement et incluse dans les liens d’une réponse précédente. Elle n’est pas destinée à être lisible par un humain.

page_size : typing.Optional[RequestPageSize]

include_total_count : typing.Optional[IncludeTotalCount]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.version_stacks.create(...) -> AsyncHttpResponse[VersionStackWithIncludesResponse]

Créer une nouvelle pile de versions dans le dossier parent.

Limites de débit : 10 appels par minute et par account_user

usage

from frameio import Frameio
from frameio.version_stacks import VersionStackCreateParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.version_stacks.create(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    folder_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=VersionStackCreateParamsData(
        file_ids=[
            "dd2a3cdd-fc90-41bd-a7b8-8a0447aec6d4",
            "79fed48a-8372-496e-8dcb-5e959b9b9fcf",
        ],
    ),
)

Paramètres

account_id : Uuid

folder_id : Uuid

data : VersionStackCreateParamsData

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.version_stacks.move(...) -> AsyncHttpResponse[VersionStackResponse]

Déplacer la pile de versions vers un dossier.

Limites de débit : 10 appels par minute et par account_user

usage

from frameio import Frameio
from frameio.version_stacks import VersionStackMoveParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.version_stacks.move(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    version_stack_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=VersionStackMoveParamsData(
        parent_id="2e426fe0-f965-4594-8b2b-b4dff1dc00ec",
    ),
)

Paramètres

account_id : Uuid

version_stack_id : Uuid

data : VersionStackMoveParamsData

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

Autorisations du compte

client.account_permissions.index(...) -> AsyncPager[AccountUserRole, AccountUserRolesResponse]

Répertorier les rôles d’utilisateur pour un compte donné.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
response = client.account_permissions.index(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    include_deactivated=True,
    after="<opaque_cursor>",
    page_size=10,
    include_total_count=False,
)
for item in response:
    yield item
# alternatively, you can paginate page-by-page
for page in response.iter_pages():
    yield page

Paramètres

account_id : Uuid

include_deactivated : typing.Optional[bool] – Permet d’inclure les utilisateurs désactivés dans la réponse. La valeur par défaut est faux.

after : typing.Optional[RequestAfterOpaqueCursor]

Paramètre de requête Opaque Cursor pour les requêtes renvoyant des résultats paginés.

Cette valeur est générée automatiquement et incluse dans les liens d’une réponse précédente. Elle n’est pas destinée à être lisible par un humain.

page_size : typing.Optional[RequestPageSize]

include_total_count : typing.Optional[IncludeTotalCount]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

Comptes

client.accounts.index(...) -> AsyncPager[Account, AccountsResponse]

Répertorier les comptes de l’utilisateur actuel.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
response = client.accounts.index(
    after="<opaque_cursor>",
    page_size=10,
    include_total_count=False,
)
for item in response:
    yield item
# alternatively, you can paginate page-by-page
for page in response.iter_pages():
    yield page

Paramètres

after : typing.Optional[RequestAfterOpaqueCursor]

Paramètre de requête Opaque Cursor pour les requêtes renvoyant des résultats paginés.

Cette valeur est générée automatiquement et incluse dans les liens d’une réponse précédente. Elle n’est pas destinée à être lisible par un humain.

page_size : typing.Optional[RequestPageSize]

include_total_count : typing.Optional[IncludeTotalCount]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

Commentaires

client.comments.show(...) -> AsyncHttpResponse[CommentWithIncludesResponse]

Afficher un seul commentaire sur un fichier.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.comments.show(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    comment_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    include="owner",
)

Paramètres

account_id : Uuid

comment_id : Uuid

include : typing.Optional[CommentsShowRequestInclude]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.comments.delete(...) -> AsyncHttpResponse[None]

Supprimer un commentaire d’une ressource.

Limites de débit : 60 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.comments.delete(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    comment_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
)

Paramètres

account_id : Uuid

folder_id : Uuid

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.comments.update(...) -> AsyncHttpResponse[CommentResponse]

Mettre à jour le commentaire sur une ressource donnée.

Limites de débit : 10 appels par minute et par account_user

usage

from frameio import Frameio
from frameio.comments import UpdateCommentParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.comments.update(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    comment_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    timestamp_as_timecode=True,
    data=UpdateCommentParamsData(
        annotation='[{"tool":"rect","color":"#F22237","size":8,"x":0.277726001863933,"y":0.12909555568499534,"w":0.3153168321877913,"h":0.5308131407269339,"ix":0.277726001863933,"iy":0.12909555568499534,"radius":8}]',
        completed=False,
        page=4,
        text="This is great!",
    ),
)

Paramètres

account_id : Uuid

comment_id : Uuid

data : UpdateCommentParamsData

timestamp_as_timecode : typing.Optional[bool]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.comments.index(...) -> AsyncPager[CommentWithIncludes, CommentsWithIncludesResponse]

Répertorier les commentaires d’une ressource donnée.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
response = client.comments.index(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    file_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    include="owner",
    after="<opaque_cursor>",
    page_size=10,
    include_total_count=False,
)
for item in response:
    yield item
# alternatively, you can paginate page-by-page
for page in response.iter_pages():
    yield page

Paramètres

account_id : Uuid

file_id : Uuid

include : typing.Optional[CommentInclude]

after : typing.Optional[RequestAfterOpaqueCursor]

Paramètre de requête Opaque Cursor pour les requêtes renvoyant des résultats paginés.

Cette valeur est générée automatiquement et incluse dans les liens d’une réponse précédente. Elle n’est pas destinée à être lisible par un humain.

page_size : typing.Optional[RequestPageSize]

include_total_count : typing.Optional[IncludeTotalCount]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.comments.create(...) -> AsyncHttpResponse[CommentResponse]

Créer un commentaire sur un fichier.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
from frameio.comments import CreateCommentParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.comments.create(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    file_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    timestamp_as_timecode=True,
    data=CreateCommentParamsData(
        annotation='[{"tool":"rect","color":"#F22237","size":8,"x":0.277726001863933,"y":0.12909555568499534,"w":0.3153168321877913,"h":0.5308131407269339,"ix":0.277726001863933,"iy":0.12909555568499534,"radius":8}]',
        completed=False,
        page=4,
        text="This is great!",
        timestamp="00:00:02:12",
    ),
)

Paramètres

account_id : Uuid

file_id : Uuid

data : CreateCommentParamsData

timestamp_as_timecode : typing.Optional[bool]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

Webhooks

client.webhooks.index(...) -> AsyncPager[WebhookWithIncludes, WebhooksWithIncludesResponse]

Répertorier les webhooks pour un espace de travail donné.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
response = client.webhooks.index(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    workspace_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    after="<opaque_cursor>",
    page_size=10,
    include_total_count=False,
)
for item in response:
    yield item
# alternatively, you can paginate page-by-page
for page in response.iter_pages():
    yield page

Paramètres

account_id : Uuid

workspace_id : Uuid

include : typing.Optional[typing.Literal[“creator”]]

after : typing.Optional[RequestAfterOpaqueCursor]

Paramètre de requête Opaque Cursor pour les requêtes renvoyant des résultats paginés.

Cette valeur est générée automatiquement et incluse dans les liens d’une réponse précédente. Elle n’est pas destinée à être lisible par un humain.

page_size : typing.Optional[RequestPageSize]

include_total_count : typing.Optional[IncludeTotalCount]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.webhooks.create(...) -> AsyncHttpResponse[WebhookCreateResponse]

Crée un seul webhook avec un secret.

Événements valides :

file.created, file.deleted, file.ready, file.updated, file.upload.completed, file.versioned, file.copied, folder.created, folder.deleted, folder.updated, folder.copied, comment.completed, comment.created, comment.deleted, comment.uncompleted, comment.updated, customfield.created, customfield.updated, customfield.deleted, metadata.value.updated, project.created, project.deleted, project.updated, collection.created, collection.updated, collection.deleted, share.created, share.updated, share.deleted, share.viewed.

Limites de débit : 10 appels par minute et par account

usage

from frameio import Frameio
from frameio.webhooks import WebhookCreateParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.webhooks.create(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    workspace_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=WebhookCreateParamsData(
        events=[
            "file.created",
            "file.deleted",
            "file.ready",
            "file.updated",
            "file.upload.completed",
            "file.versioned",
            "file.copied",
            "folder.created",
            "folder.deleted",
            "folder.updated",
            "folder.copied",
            "comment.completed",
            "comment.created",
            "comment.deleted",
            "comment.uncompleted",
            "comment.updated",
            "customfield.created",
            "customfield.updated",
            "customfield.deleted",
            "metadata.value.updated",
            "project.created",
            "project.deleted",
            "project.updated",
            "collection.created",
            "collection.updated",
            "collection.deleted",
            "share.created",
            "share.updated",
            "share.deleted",
            "share.viewed",
        ],
        name="New Webhook",
        url="https://url.example.com",
    ),
)

Paramètres

account_id : Uuid

workspace_id : Uuid

data : WebhookCreateParamsData

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.webhooks.show(...) -> AsyncHttpResponse[WebhookWithIncludesResponse]

Afficher les détails du webhook.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.webhooks.show(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    webhook_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
)

Paramètres

account_id : Uuid

webhook_id : Uuid

include : typing.Optional[typing.Literal[“creator”]]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.webhooks.delete(...) -> AsyncHttpResponse[None]

Supprimer un webhook.

Limites de débit : 60 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.webhooks.delete(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    webhook_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
)

Paramètres

account_id : Uuid

folder_id : Uuid

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.webhooks.update(...) -> AsyncHttpResponse[WebhookResponse]

Mettre à jour les détails du webhook.

Limites de débit : 10 appels par minute et par account_user

usage

from frameio import Frameio
from frameio.webhooks import WebhookUpdateParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.webhooks.update(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    webhook_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=WebhookUpdateParamsData(
        active=True,
        events=[
            "file.created",
            "file.deleted",
            "file.ready",
            "file.updated",
            "file.upload.completed",
            "file.versioned",
            "file.copied",
            "folder.created",
            "folder.deleted",
            "folder.updated",
            "folder.copied",
            "comment.completed",
            "comment.created",
            "comment.deleted",
            "comment.uncompleted",
            "comment.updated",
            "customfield.created",
            "customfield.updated",
            "customfield.deleted",
            "metadata.value.updated",
            "project.created",
            "project.deleted",
            "project.updated",
            "collection.created",
            "collection.updated",
            "collection.deleted",
            "share.created",
            "share.updated",
            "share.deleted",
            "share.viewed",
        ],
        name="Updated Webhook",
        url="https://url.example.com",
    ),
)

Paramètres

account_id : Uuid

webhook_id : Uuid

data : WebhookUpdateParamsData

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

Autorisations de l’espace de travail

client.workspace_permissions.index(...) -> AsyncPager[UserRole, UserRolesResponse]

Répertorier les rôles d’utilisateur pour un espace de travail donné.

Limites de débit : 100 appels par 1.00 minute(s) par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
response = client.workspace_permissions.index(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    workspace_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    include_deactivated=True,
    after="<opaque_cursor>",
    page_size=10,
    include_total_count=False,
)
for item in response:
    yield item
# alternatively, you can paginate page-by-page
for page in response.iter_pages():
    yield page

Paramètres

account_id : Uuid

workspace_id : Uuid

includ_deactivated : typing.Optional[bool] – Permet d’inclure les utilisateurs désactivés dans la réponse. La valeur par défaut est faux.

after : typing.Optional[RequestAfterOpaqueCursor]

Paramètre de requête Opaque Cursor pour les requêtes renvoyant des résultats paginés.

Cette valeur est générée automatiquement et incluse dans les liens d’une réponse précédente. Elle n’est pas destinée à être lisible par un humain.

page_size : typing.Optional[RequestPageSize]

include_total_count : typing.Optional[IncludeTotalCount]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.workspace_permissions.workspace_user_roles_delete(...) -> AsyncHttpResponse[None]

Supprimer un utilisateur d’un espace de travail donné.

Limites de débit : 60 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.workspace_permissions.workspace_user_roles_delete(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    workspace_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    user_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
)

Paramètres

account_id : Uuid

workspace_id : Uuid

user_id : Uuid

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.workspace_permissions.workspace_user_roles_update(...) -> AsyncHttpResponse[UpdateUserRolesResponse]

Mettre à jour les rôles des utilisateurs pour l’espace de travail spécifié si l’utilisateur est déjà ajouté à l’espace de travail. Si l’utilisateur n’est pas encore ajouté à l’espace de travail, il sera ajouté avec le rôle indiqué.

Limites de débit : 10 appels par minute et par account_user

usage

from frameio import Frameio, UpdateUserRolesParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.workspace_permissions.workspace_user_roles_update(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    workspace_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    user_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=UpdateUserRolesParamsData(
        role="editor",
    ),
)

Paramètres

account_id : Uuid

workspace_id : Uuid

user_id : Uuid

data : UpdateUserRolesParamsData

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

Espaces de travail

client.workspaces.show(...) -> AsyncHttpResponse[WorkspaceWithIncludesResponse]

Afficher les détails de l’espace de travail.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.workspaces.show(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    workspace_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
)

Paramètres

account_id : Uuid

workspace_id : Uuid

include : typing.Optional[typing.Literal[“creator”]]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.workspaces.delete(...) -> AsyncHttpResponse[None]

Supprimer l’espace de travail du compte.

Limites de débit : 60 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.workspaces.delete(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    workspace_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
)

Paramètres

account_id : Uuid

workspace_id : Uuid

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.workspaces.update(...) -> AsyncHttpResponse[WorkspaceResponse]

Mettre à jour un espace de travail.

Limites de débit : 10 appels par minute et par account_user

usage

from frameio import Frameio, WorkspaceParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.workspaces.update(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    workspace_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=WorkspaceParamsData(
        name="My Workspace",
    ),
)

Paramètres

account_id : Uuid

workspace_id : Uuid

data : WorkspaceParamsData

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.workspaces.index(...) -> AsyncPager[WorkspaceWithIncludes, WorkspacesWithIncludesResponse]

Répertorier les espaces de travail pour un compte donné.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
response = client.workspaces.index(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    after="<opaque_cursor>",
    page_size=10,
    include_total_count=False,
)
for item in response:
    yield item
# alternatively, you can paginate page-by-page
for page in response.iter_pages():
    yield page

Paramètres

account_id : Uuid

workspace_id : Uuid

include : typing.Optional[typing.Literal[“owner”]] –

after : typing.Optional[RequestAfterOpaqueCursor]

Paramètre de requête Opaque Cursor pour les requêtes renvoyant des résultats paginés.

Cette valeur est générée automatiquement et incluse dans les liens d’une réponse précédente. Elle n’est pas destinée à être lisible par un humain.

page_size: typing.Optional[RequestPageSize]

include_total_count : typing.Optional[IncludeTotalCount]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.workspaces.create(...) -> AsyncHttpResponse[WorkspaceResponse]

Créer un espace de travail à partir d’un compte.

Limites de débit : 10 appels par minute et par account_user

usage

from frameio import Frameio, WorkspaceParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.workspaces.create(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=WorkspaceParamsData(
        name="My Workspace",
    ),
)

Paramètres

account_id : Uuid

data : WorkspaceParamsData

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

Partages

client.shares.show(...) -> AsyncHttpResponse[ShareResponse]

Afficher un seul partage.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.shares.show(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    share_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
)

Paramètres

account_id : Uuid

share_id : Uuid

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.shares.delete(...) -> AsyncHttpResponse[None]

Supprimer un partage.

Limites de débit : 60 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.shares.delete(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    share_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
)

Paramètres

account_id : Uuid

share_id : Uuid

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.shares.update(...) -> AsyncHttpResponse[ShareResponse]

Mettre à jour un partage.

Limites de débit : 10 appels par minute et par account_user

usage

import datetime
from frameio import Frameio
from frameio.shares import UpdateShareParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.shares.update(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    share_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=UpdateShareParamsData(
        access="public",
        description="A descriptive summary of the share",
        downloading_enabled=True,
        expiration=datetime.datetime.fromisoformat(
            "2026-01-22 17:04:53+00:00",
        ),
        name="Share Name",
        passphrase="as!dfj39sd(*",
    ),
)

Paramètres

account_id : Uuid

share_id : Uuid

data : UpdateShareParamsData

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.shares.list_reviewers(...) -> AsyncPager[User, ShareReviewersResponse]

Répertorier les réviseurs du partage.

Limites de débit : 10 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
response = client.shares.list_reviewers(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    share_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    after="<opaque_cursor>",
    page_size=10,
    include_total_count=False,
)
for item in response:
    yield item
# alternatively, you can paginate page-by-page
for page in response.iter_pages():
    yield page

Paramètres

account_id : Uuid

share_id : Uuid

after : typing.Optional[RequestAfterOpaqueCursor]

Paramètre de requête Opaque Cursor pour les requêtes renvoyant des résultats paginés.

Cette valeur est générée automatiquement et incluse dans les liens d’une réponse précédente. Elle n’est pas destinée à être lisible par un humain.

page_size : typing.Optional[RequestPageSize]

include_total_count : typing.Optional[IncludeTotalCount]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.shares.add_reviewers(...) -> AsyncHttpResponse[None]

Ajouter des réviseurs à un partage sécurisé selon trois types d’identificateurs : adobe_user_id, email et user_id.

Une requête ne peut inclure qu’un seul paramètre de type identifiant.

email est le seul identifiant permettant d’ajouter des réviseurs à un partage qui ne disposent pas d’un compte Frame sur le compte auquel appartient ce partage.

Limites de débit : 10 appels par minute et par account_user

usage

from frameio import Frameio
from frameio.shares import (
    AddReviewersToShareParamsData,
    AddReviewersToShareParamsDataReviewers,
)
client = Frameio(
    token="YOUR_TOKEN",
)
client.shares.add_reviewers(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    share_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=AddReviewersToShareParamsData(
        message="Please join my share!",
        reviewers=AddReviewersToShareParamsDataReviewers(
            emails=["email1@domain.com", "email2@domain.com"],
        ),
    ),
)

Paramètres

account_id : Uuid

share_id : Uuid

data : AddReviewersToShareParamsData

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.shares.remove_reviewers(...) -> AsyncHttpResponse[None]

Supprimer des réviseurs du partage sécurisé selon trois types d’identificateurs : adobe_user_id, email et user_id.

Une requête ne peut inclure qu’un seul paramètre de type identifiant.

Limites de débit : 10 appels par minute et par account_user

usage

from frameio import Frameio
from frameio.shares import (
    RemoveReviewerParamsData,
    RemoveReviewerParamsDataReviewers,
)
client = Frameio(
    token="YOUR_TOKEN",
)
client.shares.remove_reviewers(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    share_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=RemoveReviewerParamsData(
        reviewers=RemoveReviewerParamsDataReviewers(
            adobe_user_ids=[
                "2A3C1A3D66C621B20A494021@176719f5667c82b4499999.e"
            ],
        ),
    ),
)

Paramètres

account_id : Uuid

share_id : Uuid

data : RemoveReviewerParamsData

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.shares.remove_asset(...) -> AsyncHttpResponse[RemoveAssetResponse]

Supprimer un élément actuellement présent dans le partage de ce dossier.

Limites de débit : 10 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.shares.remove_asset(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    share_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    asset_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
)

Paramètres

account_id : Uuid

share_id : Uuid

asset_id : Uuid

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.shares.add_asset(...) -> AsyncHttpResponse[AddAssetResponse]

Ajouter un nouveau partage de ressources.

Limites de débit : 10 appels par minute et par account_user

usage

from frameio import Frameio
from frameio.shares import AddAssetParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.shares.add_asset(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    share_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=AddAssetParamsData(
        asset_id="0cc1cb59-1d7c-4176-8532-afe099897318",
    ),
)

Paramètres

account_id : Uuid

share_id : Uuid

data : AddAssetParamsData

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.shares.index(...) -> AsyncPager[Share, SharesResponse]

Répertorier les partages d’un projet.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
response = client.shares.index(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    project_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    after="<opaque_cursor>",
    page_size=10,
    include_total_count=False,
)
for item in response:
    yield item
# alternatively, you can paginate page-by-page
for page in response.iter_pages():
    yield page

Paramètres

account_id : Uuid

project_id : Uuid

after : typing.Optional[RequestAfterOpaqueCursor]

Paramètre de requête Opaque Cursor pour les requêtes renvoyant des résultats paginés.

Cette valeur est générée automatiquement et incluse dans les liens d’une réponse précédente. Elle n’est pas destinée à être lisible par un humain.

page_size : typing.Optional[RequestPageSize]

include_total_count : typing.Optional[IncludeTotalCount]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.shares.create(...) -> AsyncHttpResponse[ShareResponse]

Créer un partage.

Limites de débit : 10 appels par minute et par account_user

usage

import datetime
from frameio import Frameio
from frameio.shares import CreateShareParamsData_Asset
client = Frameio(
    token="YOUR_TOKEN",
)
client.shares.create(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    project_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=CreateShareParamsData_Asset(
        access="public",
        asset_ids=[
            "12eb1446-5736-4f93-85fc-3b636f156211",
            "f23a3b3e-7b1f-4655-b91a-acf0566e5bb9",
        ],
        downloading_enabled=True,
        expiration=datetime.datetime.fromisoformat(
            "2026-01-22 17:04:53+00:00",
        ),
        name="Share Name",
        passphrase="as!dfj39sd(*",
    ),
)

Paramètres

account_id : Uuid

project_id : Uuid

data : CreateShareParamsData

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

Fichiers

client.files.list(...) -> AsyncHttpResponse[AssetsWithIncludesResponse]

Répertorier les fichiers d’un dossier donné.

Limites de débit : 5 appels par seconde et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.files.list(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    folder_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    include="media_links",
    after="<opaque_cursor>",
    page_size=10,
    include_total_count=False,
)

Paramètres

account_id : Uuid

folder_id : Uuid

include : typing.Optional[FileWithMediaLinksInclude]

after : typing.Optional[RequestAfterOpaqueCursor]

Paramètre de requête Opaque Cursor pour les requêtes renvoyant des résultats paginés.

Cette valeur est générée automatiquement et incluse dans les liens d’une réponse précédente. Elle n’est pas destinée à être lisible par un humain.

page_size : typing.Optional[RequestPageSize]

include_total_count : typing.Optional[IncludeTotalCount]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.files.create(...) -> AsyncHttpResponse[FileWithUploadUrlsResponse]

Créer un nouveau fichier dans le dossier parent. Créer un fichier (chargement local) et Créer un fichier (chargement à distance) ont remplacé ce point d’entrée.

Limites de débit : 5 appels par seconde et par account_user

usage

from frameio import Frameio
from frameio.files import FileCreateParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.files.create(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    folder_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=FileCreateParamsData(
        file_size=1137444,
        media_type="image/png",
        name="asset.png",
    ),
)

Paramètres

account_id : Uuid

folder_id : Uuid

data : FileCreateParamsData

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.files.show(...) -> AsyncHttpResponse[FileWithIncludesResponse]

Afficher les détails du fichier.

Utilisez le paramètre de requête « include » pour inclure de manière sélective des propriétés supplémentaires dans la réponse.

Si vous incluez media_links.original et que l’utilisateur n’est pas autorisé à télécharger le fichier, ce point d’entrée renverra une erreur 403 Interdit. Si le contenu est inaccessible parce qu’un filigrane est requis pour cet utilisateur et n’est pas pris en charge par les liens de médias demandés, la requête aboutira, mais les liens de médias non pris en charge seront définis sur « null ». De même, si le lien de transcodage demandé n’existe pas pour un fichier donné (par exemple, media_links.video_h264_180 pour un fichier image statique) ou si le processus de transcodage n’est pas terminé (c’est-à-dire que le statut du fichier est « chargé » et non « transcodé »,) le lien de médias sera également défini sur « null » dans la payload de la réponse. En résumé, le client doit gérer correctement les liens de médias nuls.

Limites de débit : 5 appels par seconde et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.files.show(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    file_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    include="media_links",
)

Paramètres

account_id : Uuid

file_id : Uuid

include : typing.Optional[FileWithMediaLinksInclude]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.files.delete(...) -> AsyncHttpResponse[None]

Supprimer un fichier par son identifiant.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.files.delete(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    file_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
)

Paramètres

account_id : Uuid

file_id : Uuid

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.files.update(...) -> AsyncHttpResponse[FileResponse]

Mettre à jour les détails du fichier.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
from frameio.files import FileUpdateParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.files.update(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    file_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=FileUpdateParamsData(
        name="asset.png",
    ),
)

Paramètres

account_id : Uuid

file_id : Uuid

data : FileUpdateParamsData

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.files.copy(...) -> AsyncHttpResponse[FileCopyResponse]

Copier le fichier.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
from frameio.files import FileCopyParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.files.copy(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    file_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    copy_metadata=True,
    copy_comments="none",
    data=FileCopyParamsData(
        parent_id="2e426fe0-f965-4594-8b2b-b4dff1dc00ec",
    ),
)

Paramètres

account_id : Uuid

file_id : Uuid

copy_metadata : typing.Optional[bool] – Whether to copy metadata values along with the file

copy_comments : typing.Optional[FilesCopyRequestCopyComments] – Which comments to copy along with the file

data : typing.Optional[FileCopyParamsData]

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.files.create_remote_upload(...) -> AsyncHttpResponse[FileRemoteUploadResponse]

Créer un nouveau fichier dans le dossier parent par le biais d’un chargement à distance.

Limites de débit : 5 appels par seconde et par account_user

usage

from frameio import Frameio
from frameio.files import FileCreateRemoteUploadParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.files.create_remote_upload(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    folder_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=FileCreateRemoteUploadParamsData(
        name="asset.png",
        source_url="https://upload.wikimedia.org/wikipedia/commons/e/e1/White_Pixel_1x1.png",
    ),
)

Paramètres

account_id : Uuid

folder_id : Uuid

data : FileCreateRemoteUploadParamsData

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.files.move(...) -> AsyncHttpResponse[FileResponse]

Déplacer le fichier vers un dossier ou version_stack.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
from frameio.files import FileMoveParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.files.move(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    file_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=FileMoveParamsData(
        parent_id="2e426fe0-f965-4594-8b2b-b4dff1dc00ec",
    ),
)

Paramètres

account_id : Uuid

file_id : Uuid

data : FileMoveParamsData

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.files.create_local_upload(...) -> AsyncHttpResponse[FileWithUploadUrlsResponse]

Créer un nouveau fichier dans le dossier parent par le biais d’un chargement local.

Limites de débit : 5 appels par seconde et par account_user

usage

from frameio import Frameio
from frameio.files import FileCreateLocalUploadParamsData
client = Frameio(
    token="YOUR_TOKEN",
)
client.files.create_local_upload(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    folder_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    data=FileCreateLocalUploadParamsData(
        file_size=1137444,
        name="asset.png",
    ),
)

Paramètres

account_id : Uuid

file_id : Uuid

data : FileCreateLocalUploadParamsData

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

client.files.create_local_upload(...) -> AsyncHttpResponse[FileWithUploadUrlsResponse]

Afficher les détails du statut de chargement du fichier.

Limites de débit : 5 appels par seconde et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.files.show_file_upload_status(
    account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
    file_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b",
)

Paramètres

account_id : Uuid

file_id : Uuid

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

Utilisateurs et utilisatrices

client.users.show() -> AsyncHttpResponse[ProfileResponse]

Consulter les informations relatives à l’utilisateur associé au jeton du porteur.

Limites de débit : 100 appels par minute et par account_user

usage

from frameio import Frameio
client = Frameio(
    token="YOUR_TOKEN",
)
client.users.show()

Paramètres

request_options : typing.Optional[RequestOptions] – Configuration spécifique à la requête.

PyPI

Afficher sur PyPI