> This page is for Piattaforma, version V4 (default). > For other versions, use one of these documentation indexes: > - V4 (default): https://next.developer.frame.io/platform/v4/llms.txt > - V4 sperimentale: https://next.developer.frame.io/platform/v4-experimental/llms.txt > - Versione precedente: https://next.developer.frame.io/platform/v2/llms.txt > For clean Markdown of any page, append .md to the page URL. > For a complete documentation index, see https://next.developer.frame.io/llms.txt. > For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://next.developer.frame.io/_mcp/server. # Riferimento SDK Python ### Installazione ```curl pip install frameio ``` --- ### Utilizzo Crea un'istanza e utilizza il client con quanto segue: ```python 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 asincrono L'SDK esporta anche un client asincrono per effettuare chiamate non bloccanti alla nostra API. Tieni presente che, se stai creando una classe client Async httpx da passare a questo client, devi utilizzare httpx.AsyncClient() invece di httpx.Client() (ad esempio per il parametro httpx\_client di questo client). ```python 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()) ``` --- ### Gestione delle eccezioni Quando l'API restituisce un codice di stato diverso da quello di successo (risposta 4xx o 5xx), viene generata una sottoclasse del seguente errore. ```python 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) ``` --- ### Paginazione Le richieste paginate restituiranno un SyncPager o AsyncPager, che possono essere utilizzati come generatori per l'oggetto sottostante. ```python 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 ``` --- ### Avanzate #### Accesso ai dati di risposta non elaborati L'SDK fornisce l'accesso ai dati di risposta non elaborati, comprese le intestazioni, attraverso la proprietà .with\_raw\_response. La proprietà .with\_raw\_response restituisce un client "non elaborato" che può essere utilizzato per accedere agli attributi .headers e .data. ```python 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) ``` --- #### Nuovi tentativi L'SDK può eseguire nuovi tentativi automatici con backoff esponenziale. Una richiesta viene ripetuta finché è considerata ripetibile e il numero di tentativi non supera il limite configurato (predefinito: 2). Una richiesta è considerata ripetibile quando viene restituito uno dei seguenti codici di stato HTTP: * 408 (Timeout) * 429 (Too Many Requests) * 5XX (Internal Server Errors) \ Utilizza l'opzione di richiesta `max_retries` per configurare questo comportamento. ```python client.metadata_fields.metadata_field_definitions_create(..., request_options={ "max_retries": 1 }) ``` --- #### Timeout L'SDK utilizza per impostazione predefinita un timeout di 60 secondi. Puoi configurarlo con un'opzione di timeout a livello di client o di richiesta. ```python 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 }) ``` --- #### Cliente personalizzato Puoi sostituire il client httpx in modo da personalizzarlo in base al tuo caso d'uso. Alcuni casi d'uso comuni includono il supporto per proxy e trasporti. ```python 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"), ), ) ``` --- ### Riferimento #### Autorizzazioni account #### client.account\_permissions.index(...) -> AsyncPager\[AccountUserRole, AccountUserRolesResponse] Elenca i ruoli utente per un account specifico. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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="", 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 ``` **Parametri** `account_id`: Uuid — `include_deactivated`: typing.Optional\[bool] — Supporta l'inclusione di utenti disattivati nella risposta.Il valore predefinito è false. `after`: typing.Optional\[RequestAfterOpaqueCursor] Parametro di richiesta del cursore opaco per le richieste che restituiscono risultati impaginati. > **Tip** > > Questo valore è generato automaticamente e incluso come nei link provenienti da una risposta precedente. Non è destinato a essere leggibile. `page_size`: typing.Optional\[RequestPageSize] — `include_total_count`: typing.Optional\[IncludeTotalCount] — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### Account #### client.accounts.index(...) -> AsyncPager\[Account, AccountsResponse] Elenca gli account per l'utente corrente. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python usage from frameio import Frameio client = Frameio( token="YOUR_TOKEN", ) response = client.accounts.index( after="", 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 ``` **Parametri** `after`: typing.Optional\[RequestAfterOpaqueCursor] Parametro di richiesta del cursore opaco per le richieste che restituiscono risultati impaginati. > **Tip** > > Questo valore è generato automaticamente e incluso come nei link provenienti da una risposta precedente. Non è destinato a essere leggibile. `page_size`: typing.Optional\[RequestPageSize] — `include_total_count`: typing.Optional\[IncludeTotalCount] — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.accounts.auditlog\_index(...) -> AsyncPager\[AuditLog, AuditLogsWithIncludesResponse] Elenca i registri di controllo con alcune funzionalità di filtro tramite parametri di query. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python usage from frameio import Frameio client = Frameio( token="YOUR_TOKEN", ) response = client.accounts.auditlog_index( account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", include="user", after="", page_size=10, include_total_count=False, api_version="4.0", ) for item in response: yield item # alternatively, you can paginate page-by-page for page in response.iter_pages(): yield page ``` **Parametri** `account_id`: `Uuid` — `api_version`: `typing.Literal["4.0"]` — `include`: `typing.Optional[typing.Literal["user"]]` — `filters`: `typing.Optional[Filters]` — `after`: `typing.Optional[RequestAfterOpaqueCursor]` Parametro di richiesta del cursore opaco per le richieste che restituiscono risultati impaginati. > **Tip** > > Questo valore è generato automaticamente e incluso come nei link provenienti da una risposta precedente. Non è destinato a essere leggibile. `page_size`: `typing.Optional[RequestPageSize]` — `include_total_count`: `typing.Optional[IncludeTotalCount]` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### Autenticazione #### frameio.auth.ServerToServerAuth(\*, client\_id, client\_secret, ...) Autenticati utilizzando la concessione client\_credentials OAuth 2.0. Questo flusso non coinvolge un utente e non restituisce un token di aggiornamento. Quando il token di accesso scade, l'SDK ne richiede automaticamente uno nuovo utilizzando le credenziali client. Per l'utilizzo asincrono, usa `AsyncServerToServerAuth`. **`usage`** ```python 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) ``` **Parametri** `client_id`: `str` — ID cliente OAuth di Adobe IMS. `client_secret`: `str` — Secret del client OAuth di Adobe IMS. `scopes`: `str` — Ambiti separati da spazi (OAuth 2.0 RFC 6749). Il valore predefinito è `openid AdobeID frame.s2s.all`. `ims_base_url`: `str` — URL di base IMS per ambienti temporanei/alternativi. Il valore predefinito è production. `http_client`: `typing.Optional[httpx.Client]` — httpx opzionale.Client per proxy, TLS o pool di connessioni. `on_token_refreshed`: `typing.Optional[typing.Callable[[dict[str, Any]], None]]` — Callback opzionale attivato dopo ogni recupero di token. `timeout`: `float` — Timeout della richiesta HTTP in secondi. Il valore predefinito è 30. `max_retries`: `int` — Numero massimo di nuovi tentativi per errori transitori. Il valore predefinito è 2. `refresh_buffer`: `int` — Secondi prima della scadenza per attivare l'aggiornamento proattivo. Il valore predefinito è 60. **Metodi** `get_token() -> str` — Restituisce un token di accesso valido, aggiornandolo se necessario. Passa questo riferimento del metodo (non una chiamata) all'SDK: `Frameio(token=auth.get_token)`. `authenticate() -> dict[str, Any]` — Recupera esplicitamente un nuovo token di accesso. Restituisce il dict di risposta del token con `access_token`, `expires_in` ecc. `revoke() -> None` — Revoca entrambi i token lato server e cancella lo stato locale. `export_tokens() -> dict[str, Any]` — Esporta lo stato corrente del token per la persistenza. `import_tokens(data: dict[str, Any]) -> None` — Ripristina lo stato del token da un dict esportato in precedenza. #### frameio.auth.WebAppAuth(\*, client\_id, client\_secret, redirect\_uri, ...) Autenticati utilizzando la concessione authorization\_code OAuth 2.0. Usa questo metodo per applicazioni sul lato server che possono archiviare in modo sicuro un secret del client. Per l'utilizzo asincrono, usa `AsyncWebAppAuth`. **`usage`** ```python 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) ``` **Parametri** `client_id`: `str` — ID cliente OAuth di Adobe IMS. `client_secret`: `str` — Secret del client OAuth di Adobe IMS. `redirect_uri`: `str` — URI di reindirizzamento registrato. `scopes`: `str` — Ambiti separati da spazi (OAuth 2.0 RFC 6749). `ims_base_url`: `str` — URL di base IMS per ambienti temporanei/alternativi. Il valore predefinito è production. `http_client`: `typing.Optional[httpx.Client]` — httpx opzionale.Client per proxy, TLS o pool di connessioni. `on_token_refreshed`: `typing.Optional[typing.Callable[[dict[str, Any]], None]]` — Callback opzionale attivato dopo ogni aggiornamento del token. `timeout`: `float` — Timeout della richiesta HTTP in secondi. Il valore predefinito è 30. `max_retries`: `int` — Numero massimo di nuovi tentativi per errori transitori. Il valore predefinito è 2. `refresh_buffer`: `int` — Secondi prima della scadenza per attivare l'aggiornamento proattivo. Il valore predefinito è 60. **Metodi** `get_token() -> str` — Restituisce un token di accesso valido, aggiornandolo se necessario. Passa questo riferimento del metodo all'SDK: `Frameio(token=auth.get_token)`. `get_authorization_url(state: str) -> str` — Crea l'URL di autorizzazione di Adobe IMS. Passa un valore CSRF/state opaco che sarà restituito. `exchange_code(code: str) -> dict[str, Any]` — Scambia un codice di autorizzazione con token di accesso e aggiornamento. `refresh() -> dict[str, Any]` — Attiva manualmente un aggiornamento del token. `revoke() -> None` — Revoca entrambi i token lato server e cancella lo stato locale. `export_tokens() -> dict[str, Any]` — Esporta lo stato corrente del token per la persistenza. `import_tokens(data: dict[str, Any]) -> None` — Ripristina lo stato del token da un dict esportato in precedenza. #### frameio.auth.SPAAuth(\*, client\_id, redirect\_uri, ...) Autenticati utilizzando authorization\_code + PKCE (senza secret del client). Utilizza questa opzione per applicazioni basate su browser o native che non possono archiviare in sicurezza un secret del client. Per l'utilizzo asincrono, usa `AsyncSPAAuth`. **`usage`** ```python 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) ``` **Parametri** `client_id`: `str` — ID cliente OAuth di Adobe IMS. `redirect_uri`: `str` — URI di reindirizzamento registrato. `scopes`: `str` — Ambiti separati da spazi (OAuth 2.0 RFC 6749). `ims_base_url`: `str` — URL di base IMS per ambienti temporanei/alternativi. Il valore predefinito è production. `http_client`: `typing.Optional[httpx.Client]` — httpx opzionale.Client per proxy, TLS o pool di connessioni. `on_token_refreshed`: `typing.Optional[typing.Callable[[dict[str, Any]], None]]` — Callback opzionale attivato dopo ogni aggiornamento del token. `timeout`: `float` — Timeout della richiesta HTTP in secondi. Il valore predefinito è 30. `max_retries`: `int` — Numero massimo di nuovi tentativi per errori transitori. Il valore predefinito è 2. `refresh_buffer`: `int` — Secondi prima della scadenza per attivare l'aggiornamento proattivo. Il valore predefinito è 60. **Metodi** `get_token() -> str` — Restituisce un token di accesso valido, aggiornandolo se necessario. Passa questo riferimento del metodo all'SDK: `Frameio(token=auth.get_token)`. `get_authorization_url(state: str) -> AuthorizationUrlResult` — Crea l'URL di autorizzazione di Adobe IMS con challenge PKCE. Restituisce un `AuthorizationUrlResult` con gli attributi `url` e `code_verifier`. `exchange_code(code: str, code_verifier: str) -> dict[str, Any]` — Scambia un codice di autorizzazione + verificatore PKCE per i token. `refresh() -> dict[str, Any]` — Attiva manualmente un aggiornamento del token. `revoke() -> None` — Revoca entrambi i token lato server e cancella lo stato locale. `export_tokens() -> dict[str, Any]` — Esporta lo stato corrente del token per la persistenza. `import_tokens(data: dict[str, Any]) -> None` — Ripristina lo stato del token da un dict esportato in precedenza. #### frameio.auth.AuthorizationUrlResult Classe di dati bloccata restituita da `SPAAuth.get_authorization_url()` e `AsyncSPAAuth.get_authorization_url()`. Contiene l'URL di autorizzazione e il verificatore del codice PKCE. **Attributi** `url`: `str` — L'URL di autorizzazione completo verso cui reindirizzare l'utente. `code_verifier`: `str` — Il verificatore del codice PKCE da memorizzare e passare a `exchange_code()`. #### frameio.auth.close\_clients() / aclose\_clients() Chiudi i client HTTP a livello di modulo utilizzati dal modulo di autenticazione. Chiama `close_clients()` nel codice sincrono o `await aclose_clients()` nel codice asincrono durante la chiusura dell'applicazione per rilasciare le connessioni. **`usage`** ```python usage from frameio.auth import close_clients # During application shutdown close_clients() ``` #### Eccezioni di autenticazione Tutte le eccezioni di autenticazione ereditano da `FrameioAuthError`. | Eccezione | Descrizione | | --------------------- | ---------------------------------------------------------------------------------------------------- | | `FrameioAuthError` | Eccezione di base per tutti gli errori di `frameio.auth`. | | `AuthenticationError` | Scambio o aggiornamento del token non riuscito. Ha gli attributi `error_code` e `error_description`. | | `TokenExpiredError` | Il token di aggiornamento è scaduto; è richiesta una nuova autenticazione. | | `ConfigurationError` | La configurazione richiesta è mancante o non valida. | | `NetworkError` | Richiesta di rete non riuscita (timeout, errore di connessione ecc.). | | `RateLimitError` | L'API ha restituito un errore 429 e i nuovi tentativi sono esauriti. Ha l'attributo `retry_after`. | | `PKCEError` | Verifica PKCE non riuscita. | #### Raccolte #### client.collections.index(...) -> AsyncHttpResponse\[CollectionsResponse] Elenca le raccolte per un progetto. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python usage from frameio import Frameio client = Frameio( token="YOUR_TOKEN", ) client.collections.index( account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", project_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", include="creator,project", after="", page_size=10, include_total_count=False, ) ``` **Parametri** `account_id`: `Uuid` — `project_id`: `Uuid` — `include`: `typing.Optional[CollectionInclude]` — `after`: `typing.Optional[RequestAfterOpaqueCursor]` Parametro di richiesta del cursore opaco per le richieste che restituiscono risultati impaginati. > **Tip** > > Questo valore è generato automaticamente e incluso come nei link provenienti da una risposta precedente. Non è destinato a essere leggibile. `page_size`: `typing.Optional[RequestPageSize]` — `include_total_count`: `typing.Optional[IncludeTotalCount]` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.collections.show(...) -> AsyncHttpResponse\[CollectionResponse] Mostra i dettagli della raccolta. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python usage from frameio import Frameio client = Frameio( token="YOUR_TOKEN", ) client.collections.show( account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", collection_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", include="creator,project", ) ``` **Parametri** `account_id`: `Uuid` — `collection_id`: `Uuid` — `include`: `typing.Optional[CollectionInclude]` — `request_options`: `typing.Optional[RequestOptions]` — Request-specific configuration. #### Commenti #### client.comments.show(...) -> AsyncHttpResponse\[CommentWithIncludesResponse] Visualizza un singolo commento su un file. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ) ``` **Parametri** `account_id`: Uuid — `comment_id`: Uuid — `include`: typing.Optional\[CommentsShowRequestInclude] — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.comments.delete(...) -> AsyncHttpResponse\[None] Elimina il commento da una risorsa. Limiti di frequenza: 60 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ) ``` **Parametri** `account_id`: Uuid — `comment_id`: Uuid — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.comments.update(...) -> AsyncHttpResponse\[CommentResponse] Aggiorna il commento sulla risorsa specificata. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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!", ), ) ``` **Parametri** `account_id`: Uuid — `comment_id`: Uuid — `data`: UpdateCommentParamsData `timestamp_as_timecode`: typing.Optional\[bool] — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.comments.index(...) -> AsyncPager\[CommentWithIncludes, CommentsWithIncludesResponse] Elenca i commenti sulla risorsa specificata. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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="", 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 ``` **Parametri** `account_id`: Uuid — `file_id`: Uuid — `include`: typing.Optional\[CommentInclude] — `after`: typing.Optional\[RequestAfterOpaqueCursor] Parametro di richiesta del cursore opaco per le richieste che restituiscono risultati impaginati. > **Tip** > > Questo valore è generato automaticamente e incluso come nei link provenienti da una risposta precedente. Non è destinato a essere leggibile. `page_size`: typing.Optional\[RequestPageSize] — `include_total_count`: typing.Optional\[IncludeTotalCount] — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.comments.create(...) -> AsyncHttpResponse\[CommentResponse] Crea un commento su un file. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ), ) ``` **Parametri** `account_id`: Uuid — `file_id`: Uuid — `data`: CreateCommentParamsData `timestamp_as_timecode`: typing.Optional\[bool] — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.comments.create\_attachment(...) -> AsyncHttpResponse\[CommentAttachmentResponse] Crea un allegato per un commento esistente. Limiti di frequenza: 60 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python usage from frameio import AttachmentInput, Frameio client = Frameio( token="YOUR_TOKEN", ) client.comments.create_attachment( account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", comment_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", data=AttachmentInput( file_size=1024000, media_type="image/png", name="screenshot.png", ), ) ``` **Parametri** `account_id`: `Uuid` — `comment_id`: `Uuid` — `data`: `AttachmentInput` `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.comments.delete\_attachment(...) -> AsyncHttpResponse\[None] Elimina un allegato da un commento. Limiti di frequenza: 60 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python usage from frameio import Frameio client = Frameio( token="YOUR_TOKEN", ) client.comments.delete_attachment( account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", comment_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", attachment_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", ) ``` **Parametri** `account_id`: `Uuid` — `comment_id`: `Uuid` — `attachment_id`: `Uuid` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### Azioni personalizzate #### client.custom\_actions.actions\_index(...) -> AsyncHttpResponse\[ActionsWithIncludesResponse] Elenca le azioni in un'area di lavoro specifica. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python usage from frameio import Frameio client = Frameio( token="YOUR_TOKEN", ) client.custom_actions.actions_index( account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", workspace_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", include="creator", after="", page_size=10, include_total_count=False, ) ``` **Parametri** `account_id`: `Uuid` — `workspace_id`: `Uuid` — `include`: `typing.Optional[typing.Literal["creator"]]` — `after`: `typing.Optional[RequestAfterOpaqueCursor]` Parametro di richiesta del cursore opaco per le richieste che restituiscono risultati impaginati. > **Tip** > > Questo valore è generato automaticamente e incluso come nei link provenienti da una risposta precedente. Non è destinato a essere leggibile. `page_size`: `typing.Optional[RequestPageSize]` — `include_total_count`: `typing.Optional[IncludeTotalCount]` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.custom\_actions.actions\_show(...) -> AsyncHttpResponse\[ActionWithIncludesResponse] Mostra i dettagli dell’azione personalizzata. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python usage from frameio import Frameio client = Frameio( token="YOUR_TOKEN", ) client.custom_actions.actions_show( account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", action_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", include="creator", ) ``` **Parametri** `account_id`: `Uuid` — `action_id`: `Uuid` — `include`: `typing.Optional[typing.Literal["creator"]]` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.custom\_actions.actions\_create(...) -> AsyncHttpResponse\[ActionCreateResponse] Crea un'azione personalizzata in un'area di lavoro. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python usage from frameio import Frameio from frameio.custom_actions import ActionCreateParamsData client = Frameio( token="YOUR_TOKEN", ) client.custom_actions.actions_create( account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", workspace_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", data=ActionCreateParamsData( description="customizing our workflow", event="my.event", name="First Custom Action", timeout=7, url="https://example.com/custom-action", ), ) ``` **Parametri** `account_id`: `Uuid` — `workspace_id`: `Uuid` — `data`: `ActionCreateParamsData` `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.custom\_actions.actions\_update(...) -> AsyncHttpResponse\[ActionResponse] Aggiorna i dettagli dell’azione personalizzata. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python usage from frameio import Frameio from frameio.custom_actions import ActionUpdateParamsData client = Frameio( token="YOUR_TOKEN", ) client.custom_actions.actions_update( account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", action_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", data=ActionUpdateParamsData( active=True, description="customizing our workflow", event="my.event", multi_asset=True, name="First Custom Action", timeout=7, url="https://example.com/custom-action", ), ) ``` **Parametri** `account_id`: `Uuid` — `action_id`: `Uuid` — `data`: `ActionUpdateParamsData` `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.custom\_actions.actions\_delete(...) -> AsyncHttpResponse\[None] Elimina un'azione personalizzata. Limiti di frequenza: 60 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python usage from frameio import Frameio client = Frameio( token="YOUR_TOKEN", ) client.custom_actions.actions_delete( account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", action_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", ) ``` **Parametri** `account_id`: `Uuid` — `action_id`: `Uuid` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### File #### client.files.list(...) -> AsyncHttpResponse\[AssetsWithIncludesResponse] Elenca i file in una cartella specifica. Limiti di frequenza: 5 chiamate ogni 1 secondo per account\_user **`usage`** ```python 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="", page_size=10, include_total_count=False, ) ``` **Parametri** `account_id`: `Uuid` — `folder_id`: `Uuid` — `include`: `typing.Optional[FileWithMediaLinksInclude]` — `after`: `typing.Optional[RequestAfterOpaqueCursor]` Parametro di richiesta del cursore opaco per le richieste che restituiscono risultati impaginati. > **Tip** > > Questo valore è generato automaticamente e incluso come nei link provenienti da una risposta precedente. Non è destinato a essere leggibile. `page_size`: `typing.Optional[RequestPageSize]` — `include_total_count`: `typing.Optional[IncludeTotalCount]` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.files.create(...) -> AsyncHttpResponse\[FileWithUploadUrlsResponse] Crea un nuovo file nella cartella padre. `Create file (local upload)` e `Create file (remote upload)` hanno sostituito questo endpoint. Limiti di frequenza: 5 chiamate ogni 1 secondo per account\_user **`usage`** ```python 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", ), ) ``` **Parametri** `account_id`: `Uuid` — `folder_id`: `Uuid` — `data`: `FileCreateParamsData` `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.files.show(...) -> AsyncHttpResponse\[FileWithIncludesResponse] Mostra i dettagli del file. Usa il parametro di query "include" della richiesta per includere in modo selettivo proprietà aggiuntive nella risposta. > **Note** > > Se includi `media_links.original` e l'utente non ha l'autorizzazione per scaricare il file, questo endpoint risponderà con un errore `403 Forbidden`. Se il contenuto non è accessibile perché è richiesta la filigrana per questo utente e non è supportata dai media\_link richiesti, la richiesta avrà esito positivo, ma i link multimediali non supportati saranno impostati su null. Allo stesso modo, se un link di transcodifica richiesto non esiste per un file particolare (ad esempio includendo `media_links.video_h264_180` su un file di immagine statica) o se il processo di transcodifica non è stato completato (ovvero lo stato del file è "uploaded" invece di "transcoded"), anche il link sarà impostato su null nel payload di risposta. In breve, il client deve gestire i link multimediali null in modo appropriato. Limiti di frequenza: 5 chiamate ogni 1 secondo per account\_user **`usage`** ```python 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", ) ``` **Parametri** `account_id`: `Uuid` — `file_id`: `Uuid` — `include`: `typing.Optional[FileWithMediaLinksInclude]` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.files.delete(...) -> AsyncHttpResponse\[None] Elimina il file in base all'ID. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ) ``` **Parametri** `account_id`: `Uuid` — `file_id`: `Uuid` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.files.update(...) -> AsyncHttpResponse\[FileResponse] Aggiorna i dettagli del file. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ), ) ``` **Parametri** `account_id`: `Uuid` — `file_id`: `Uuid` — `data`: `FileUpdateParamsData` `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.files.copy(...) -> AsyncHttpResponse\[FileCopyResponse] Copia il file. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ), ) ``` **Parametri** `account_id`: `Uuid` — `file_id`: `Uuid` — `copy_metadata`: `typing.Optional[bool]` — Indica se copiare i valori dei metadati insieme al file `dipy_comments`: `typing.Optional[FilesCopyRequestCopyComments]` — Indica quali commenti copiare insieme al file `data`: `typing.Optional[FileCopyParamsData]` `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.files.create\_remote\_upload(...) -> AsyncHttpResponse\[FileRemoteUploadResponse] Crea un nuovo file nella cartella padre tramite caricamento remoto. Limiti di frequenza: 5 chiamate ogni 1 secondo per account\_user **`usage`** ```python 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", ), ) ``` **Parametri** `account_id`: `Uuid` — `folder_id`: `Uuid` — `data`: `FileCreateRemoteUploadParamsData` `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.files.move(...) -> AsyncHttpResponse\[FileResponse] Sposta il file in una cartella o in uno stack di versioni. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ), ) ``` **Parametri** `account_id`: `Uuid` — `file_id`: `Uuid` — `data`: `FileMoveParamsData` `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.files.create\_local\_upload(...) -> AsyncHttpResponse\[FileWithUploadUrlsResponse] Crea un nuovo file nella cartella padre tramite caricamento locale. Limiti di frequenza: 5 chiamate ogni 1 secondo per account\_user **`usage`** ```python 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", ), ) ``` **Parametri** `account_id`: `Uuid` — `folder_id`: `Uuid` — `data`: `FileCreateLocalUploadParamsData` `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.files.show\_file\_upload\_status(...) -> AsyncHttpResponse\[FileUploadStatusResponse] Mostra i dettagli dello stato di caricamento del file. Limiti di frequenza: 5 chiamate ogni 1 secondo per account\_user **`usage`** ```python 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", ) ``` **Parametri** `account_id`: `Uuid` — `file_id`: `Uuid` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.files.import\_file(...) -> AsyncHttpResponse\[FileResponse] Importa un file da una posizione di archiviazione configurata sull'account. Limiti di frequenza: 5 chiamate ogni 1 secondo per account\_user **`usage`** ```python usage from frameio import Frameio from frameio.files import FileImportParamsData client = Frameio( token="YOUR_TOKEN", ) client.files.import_file( account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", folder_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", data=FileImportParamsData( key="uploads/08091b0f-a541-42f5-a059-5e8c4afecc12/original.png", name="asset.png", storage_location="123e4567-e89b-12d3-a456-426614174000", ), ) ``` **Parametri** `account_id`: `Uuid` — `folder_id`: `Uuid` — `data`: `FileImportParamsData` `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### Autorizzazioni cartella #### client.folder\_permissions.folder\_user\_roles\_index(...) -> AsyncHttpResponse\[UserRolesResponse] Elenca i ruoli utente per un cartella specifica. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python usage from frameio import Frameio client = Frameio( token="YOUR_TOKEN", ) client.folder_permissions.folder_user_roles_index( account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", folder_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", include_deactivated=True, after="", page_size=10, include_total_count=False, ) ``` **Parameters** `account_id`: `Uuid` — `folder_id`: `Uuid` — `include_deactivated`: `typing.Optional[bool]` — Supporta l'inclusione di utenti disattivati nella risposta. Il valore predefinito è false. `after`: `typing.Optional[RequestAfterOpaqueCursor]` Parametro di richiesta del cursore opaco per le richieste che restituiscono risultati impaginati. > **Tip** > > Questo valore è generato automaticamente e incluso come nei link provenienti da una risposta precedente. Non è destinato a essere leggibile. `page_size`: `typing.Optional[RequestPageSize]` — `include_total_count`: `typing.Optional[IncludeTotalCount]` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.folder\_permissions.folder\_user\_roles\_update(...) -> AsyncHttpResponse\[UpdateUserRolesResponse] Aggiorna i ruoli utente per la cartella specificata se l'utente è già stato aggiunto alla cartella. Se l'utente non è stato aggiunto alla cartella, viene aggiunto con il ruolo specificato. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python usage from frameio import Frameio, UpdateUserRolesParamsData client = Frameio( token="YOUR_TOKEN", ) client.folder_permissions.folder_user_roles_update( account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", folder_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", user_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", data=UpdateUserRolesParamsData( role="editor", ), ) ``` **Parametri** `account_id`: `Uuid` — `folder_id`: `Uuid` — `user_id`: `Uuid` — `data`: `UpdateUserRolesParamsData` `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.folder\_permissions.delete(...) -> AsyncHttpResponse\[None] Rimuovi un utente da una cartella specifica. Limiti di frequenza: 60 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python usage from frameio import Frameio client = Frameio( token="YOUR_TOKEN", ) client.folder_permissions.delete( account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", folder_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", user_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", ) ``` **Parametri** `account_id`: `Uuid` — `folder_id`: `Uuid` — `user_id`: `Uuid` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### Cartelle #### client.folders.show(...) -> AsyncHttpResponse\[FolderWithIncludesResponse] Mostra i dettagli della cartella. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ) ``` **Parametri** `account_id`: Uuid — `folder_id`: Uuid — `include`: typing.Optional\[AssetInclude] — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.folders.delete(...) -> AsyncHttpResponse\[None] Elimina la cartella in base all'ID. Limiti di frequenza: 60 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ) ``` **Parametri** `account_id`: Uuid — `folder_id`: Uuid — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.folders.update(...) -> AsyncHttpResponse\[FolderResponse] Aggiorna i dettagli della cartella. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ), ) ``` **Parametri** `account_id`: Uuid — `folder_id`: Uuid — `data`: FolderUpdateParamsData `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.folders.index(...) -> AsyncHttpResponse\[AssetsWithIncludesResponse] Elenca gli elementi figlio nella cartella specificata. Usa il parametro di query "include" della richiesta per includere in modo selettivo proprietà aggiuntive nella risposta. > **Note** > > Se includi `media_links.original` e l'utente non ha l'autorizzazione per scaricare file nel progetto corrispondente, questo endpoint risponderà con un errore 403 Forbidden.Se il contenuto non è accessibile perché è richiesta la filigrana per questo utente e non è supportata dai media\_link richiesti, la richiesta avrà esito positivo, ma i link multimediali non supportati saranno impostati su null. Allo stesso modo, se un link di transcodifica richiesto non esiste per un file particolare (ad esempio includendo `media_links.video_h264_180` su un file di immagine statica) o se il processo di transcodifica non è finito (ovvero lo stato del file è "uploaded" invece di "transcoded"), anche un link multimediale sarà impostato su null nel payload di risposta. In breve, il client deve gestire i link multimediali null in modo appropriato. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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="", page_size=10, include_total_count=False, ) ``` **Parametri** `account_id`: Uuid — `folder_id`: Uuid — `include`: typing.Optional\[FileWithMediaLinksInclude] — `type`: typing.Optional\[ChildrenType] — `after`: typing.Optional\[RequestAfterOpaqueCursor] Parametro di richiesta del cursore opaco per le richieste che restituiscono risultati impaginati. > **Tip** > > Questo valore è generato automaticamente e incluso come nei link provenienti da una risposta precedente. Non è destinato a essere leggibile. `page_size`: typing.Optional\[RequestPageSize] — `include_total_count`: typing.Optional\[IncludeTotalCount] — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.folders.copy(...) -> AsyncHttpResponse\[FolderCopyResponse] Copia la cartella. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ), ) ``` **Parametri** `account_id`: Uuid — `folder_id`: Uuid — `copy_metadata`: typing.Optional\[bool] — Indica se copiare i valori dei metadati insieme alla cartella `data`: typing.Optional\[FolderCopyParamsData] `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.folders.list(...) -> AsyncHttpResponse\[FoldersWithIncludesResponse] Elenca le cartelle in una cartella specifica. Limiti di frequenza: 5 chiamate ogni 1 secondo per account\_user **`usage`** ```python 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="", page_size=10, include_total_count=False, ) ``` **Parametri** `account_id`: Uuid — `folder_id`: Uuid — `include`: typing.Optional\[AssetInclude] — `after`: typing.Optional\[RequestAfterOpaqueCursor] Parametro di richiesta del cursore opaco per le richieste che restituiscono risultati impaginati. > **Tip** > > Questo valore è generato automaticamente e incluso come nei link provenienti da una risposta precedente. Non è destinato a essere leggibile. `page_size`: typing.Optional\[RequestPageSize] — `include_total_count`: typing.Optional\[IncludeTotalCount] — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.folders.create(...) -> AsyncHttpResponse\[FolderResponse] Crea una nuova cartella nel percorso specificato dal parametro folder\_id. Limiti di frequenza: 3 chiamate ogni 1 secondo per account\_user **`usage`** ```python 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", ), ) ``` **Parametri** `account_id`: Uuid — `folder_id`: Uuid — `data`: FolderCreateParamsData `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.folders.move(...) -> AsyncHttpResponse\[FolderResponse] Sposta la cartella in una cartella. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ), ) ``` **Parametri** `account_id`: Uuid — `folder_id`: Uuid — `data`: FolderMoveParamsData `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### Gruppi #### client.groups.index(...) -> AsyncHttpResponse\[GroupsWithIncludesResponse] Elenca i gruppi nell'account. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python usage from frameio import Frameio client = Frameio( token="YOUR_TOKEN", ) client.groups.index( account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", include="creator", sort="creator_asc", after="", page_size=10, include_total_count=False, ) ``` **Parametri** `account_id`: `Uuid` — `include`: `typing.Optional[typing.Literal["creator"]]` — `sort`: `typing.Optional[GroupsIndexRequestSort]` — Ordina i gruppi in base ai parametri di query `after`: `typing.Optional[RequestAfterOpaqueCursor]` Parametro di richiesta del cursore opaco per le richieste che restituiscono risultati impaginati. > **Tip** > > Questo valore è generato automaticamente e incluso come nei link provenienti da una risposta precedente. Non è destinato a essere leggibile. `page_size`: `typing.Optional[RequestPageSize]` — `include_total_count`: `typing.Optional[IncludeTotalCount]` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.groups.show(...) -> AsyncHttpResponse\[GroupWithIncludesResponse] Mostra i dettagli del gruppo. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python usage from frameio import Frameio client = Frameio( token="YOUR_TOKEN", ) client.groups.show( account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", group_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", include="creator", ) ``` **Parametri** `account_id`: `Uuid` — `group_id`: `Uuid` — `include`: `typing.Optional[typing.Literal["creator"]]` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.groups.create(...) -> AsyncHttpResponse\[GroupResponse] Crea un gruppo per l'account corrente. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python usage from frameio import Frameio from frameio.groups import CreateGroupParamsData client = Frameio( token="YOUR_TOKEN", ) client.groups.create( account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", data=CreateGroupParamsData( emoji="smile", name="group-1", ), ) ``` **Parametri** `account_id`: `Uuid` — `data`: `CreateGroupParamsData` `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.groups.update(...) -> AsyncHttpResponse\[GroupResponse] Aggiorna i dettagli del gruppo. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python usage from frameio import Frameio from frameio.groups import UpdateGroupParamsData client = Frameio( token="YOUR_TOKEN", ) client.groups.update( account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", group_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", data=UpdateGroupParamsData( emoji="smile", name="group-1", ), ) ``` **Parametri** `account_id`: `Uuid` — `group_id`: `Uuid` — `data`: `UpdateGroupParamsData` `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### Metadati #### client.metadata.bulk\_update(...) -> AsyncHttpResponse\[None] Aggiorna i valori dei metadati in più file. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", }, ], ) ], ), ) ``` **Parametri** `account_id`: `Uuid` — `project_id`: `Uuid` — `data`: `BulkUpdateMetadataParamsData` `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.metadata.show(...) -> AsyncHttpResponse\[MetadataResponse] Mostra i metadati di un file. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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, ) ``` **Parametri** `account_id`: `Uuid` — `file_id`: `Uuid` — `show_null`: `typing.Optional[bool]` — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### Campi dei metadati #### client.metadata\_fields.metadata\_field\_definitions\_delete(...) -> AsyncHttpResponse\[None] Elimina le definizioni dei campi personalizzati a livello di account. Limiti di frequenza: 60 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ) ``` **Parametri** `account_id`: Uuid — `field_definition_id`: Uuid — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.metadata\_fields.metadata\_field\_definitions\_update(...) -> AsyncHttpResponse\[FieldDefinitionResponse] Aggiorna le definizioni dei campi personalizzati a livello di account. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ), ) ``` **Parametri** `account_id`: Uuid — `field_definition_id`: Uuid — `data`: typing.Optional\[UpdateFieldDefinitionParamsData] `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.metadata\_fields.metadata\_field\_definitions\_index(...) -> AsyncHttpResponse\[FieldDefinitionsWithIncludesResponse] Elenca definizioni dei campi a livello di account. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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="", page_size=10, include_total_count=False, ) ``` **Parametri** `account_id`: Uuid — `include`: typing.Optional\[typing.Literal\["creator"]] — `after`: typing.Optional\[RequestAfterOpaqueCursor] Parametro di richiesta del cursore opaco per le richieste che restituiscono risultati impaginati. > **Tip** > > Questo valore è generato automaticamente e incluso come nei link provenienti da una risposta precedente. Non è destinato a essere leggibile. `page_size`: typing.Optional\[RequestPageSize] — `include_total_count`: typing.Optional\[IncludeTotalCount] — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.metadata\_fields.metadata\_field\_definitions\_create(...) -> AsyncHttpResponse\[FieldDefinitionResponse] Crea definizioni dei campi a livello di account. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ), ) ``` **Parametri** `account_id`: Uuid — `data`: typing.Optional\[CreateFieldDefinitionParamsData] `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### Autorizzazioni del progetto #### client.project\_permissions.index(...) -> AsyncPager\[UserRole, UserRolesResponse] Elenca i ruoli utente per un progetto specifico. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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="", 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 ``` **Parametri** `account_id`: Uuid — `project_id`: Uuid — `include_deactivated`: typing.Optional\[bool] — Supporta l'inclusione di utenti disattivati nella risposta. Il valore predefinito è false. `after`: typing.Optional\[RequestAfterOpaqueCursor] Parametro di richiesta del cursore opaco per le richieste che restituiscono risultati impaginati. > **Tip** > > NOTA: questo valore è generato automaticamente e incluso come nei link provenienti da una risposta precedente. Non è destinato a essere leggibile. `page_size`: typing.Optional\[RequestPageSize] — `include_total_count`: typing.Optional\[IncludeTotalCount] — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.project\_permissions.delete(...) -> AsyncHttpResponse\[None] Rimuovi un utente da un progetto specifico. Limiti di frequenza: 60 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ) ``` **Parametri** `account_id`: Uuid — `project_id`: Uuid — `user_id`: Uuid — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.project\_permissions.project\_user\_roles\_update(...) -> AsyncHttpResponse\[UpdateUserRolesResponse] Aggiorna i ruoli utente per il progetto specificato se l'utente è già stato aggiunto al progetto. Se l'utente non è stato aggiunto al progetto, viene aggiunto con il ruolo specificato. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ), ) ``` **Parametri** `account_id`: Uuid — `project_id`: Uuid — `user_id`: Uuid — `data`: UpdateUserRolesParamsData `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### Progetti #### client.projects.show(...) -> AsyncHttpResponse\[ProjectWithIncludesResponse] Mostra i dettagli del progetto. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ) ``` **Parametri** `account_id`: `Uuid` — `project_id`: `Uuid` — `include`: `typing.Optional[typing.Literal["owner"]]` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.projects.delete(...) -> AsyncHttpResponse\[None] Elimina un progetto. Limiti di frequenza: 60 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ) ``` **Parametri** `account_id`: `Uuid` — `project_id`: `Uuid` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.projects.update(...) -> AsyncHttpResponse\[ProjectResponse] Aggiorna i dettagli del progetto. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ), ) ``` **Parametri** `account_id`: `Uuid` — `project_id`: `Uuid` — `data`: `ProjectUpdateParamsData` `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.projects.index(...) -> AsyncPager\[ProjectWithIncludes, ProjectsWithIncludesResponse] Elenca i progetti in un'area di lavoro specifica. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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="", 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 ``` **Parametri** `account_id`: `Uuid` — `workspace_id`: `Uuid` — `include`: `typing.Optional[typing.Literal["owner"]]` — `after`: `typing.Optional[RequestAfterOpaqueCursor]` Parametro di richiesta del cursore opaco per le richieste che restituiscono risultati impaginati. > **Tip** > > Questo valore è generato automaticamente e incluso come nei link provenienti da una risposta precedente. Non è destinato a essere leggibile. `page_size`: `typing.Optional[RequestPageSize]` — `include_total_count`: `typing.Optional[IncludeTotalCount]` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.projects.create(...) -> AsyncHttpResponse\[ProjectResponse] Crea un progetto in un'area di lavoro specifica. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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, ), ) ``` **Parametri** `account_id`: `Uuid` — `workspace_id`: `Uuid` — `data`: `ProjectParamsData` `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.projects.account\_projects\_index(...) -> AsyncPager\[ProjectWithIncludes, ProjectsWithIncludesResponse] Elenca tutti i progetti a cui l'utente autenticato ha accesso nell'account specificato. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python usage from frameio import Frameio client = Frameio( token="YOUR_TOKEN", ) response = client.projects.account_projects_index( account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", include="owner", sort="name_asc", after="", 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 ``` **Parametri** `account_id`: `Uuid` — `include`: `typing.Optional[typing.Literal["owner"]]` — `sort`: `typing.Optional[AccountProjectsIndexRequestSort]` — Ordina i progetti in base ai parametri di query `after`: `typing.Optional[RequestAfterOpaqueCursor]` Parametro di richiesta del cursore opaco per le richieste che restituiscono risultati impaginati. > **Tip** > > Questo valore è generato automaticamente e incluso come nei link provenienti da una risposta precedente. Non è destinato a essere leggibile. `page_size`: `typing.Optional[RequestPageSize]` — `include_total_count`: `typing.Optional[IncludeTotalCount]` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.projects.invited\_projects\_index(...) -> AsyncPager\[ProjectWithIncludes, ProjectsWithIncludesResponse] Elenca i progetti a cui l'utente corrente è stato invitato nell'account specificato, ma non ha accesso a livello di area di lavoro. Si tratta di progetti in cui l'utente ha accesso come utente collaboratore specifico del progetto senza autorizzazioni più ampie del team o dell'area di lavoro. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python usage from frameio import Frameio client = Frameio( token="YOUR_TOKEN", ) response = client.projects.invited_projects_index( account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", include="owner", sort="name_asc", after="", 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 ``` **Parametri** `account_id`: `Uuid` — `include`: `typing.Optional[typing.Literal["owner"]]` — `sort`: `typing.Optional[InvitedProjectsIndexRequestSort]` — Ordina i progetti in base ai parametri di query `after`: `typing.Optional[RequestAfterOpaqueCursor]` Parametro di richiesta del cursore opaco per le richieste che restituiscono risultati impaginati. > **Tip** > > Questo valore è generato automaticamente e incluso come nei link provenienti da una risposta precedente. Non è destinato a essere leggibile. `page_size`: `typing.Optional[RequestPageSize]` — `include_total_count`: `typing.Optional[IncludeTotalCount]` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### Ricerca #### client.search.search(...) -> AsyncHttpResponse\[SearchResponse] Cerca tra risorse, cartelle e progetti all'interno di un account. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python usage from frameio import Frameio from frameio.search import SearchParamsFilters client = Frameio( token="YOUR_TOKEN", ) client.search.search( account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", engine="nlp", query="red car driving on highway", filters=SearchParamsFilters( files_and_version_stacks=True, folders=False, projects=False, ), after="", page_size=10, include_total_count=False, ) ``` **Parametri** `account_id`: `Uuid` — `engine`: `SearchParamsEngine` — Motore di ricerca da utilizzare. Motori disponibili: lexical, nlp. `query`: `str` — Testo della query di ricerca `after`: `typing.Optional[RequestAfterOpaqueCursor]` Parametro di richiesta del cursore opaco per le richieste che restituiscono risultati impaginati. > **Tip** > > Questo valore è generato automaticamente e incluso come nei link provenienti da una risposta precedente. Non è destinato a essere leggibile. `page_size`: `typing.Optional[RequestPageSize]` — `include_total_count`: `typing.Optional[IncludeTotalCount]` — `filters`: `typing.Optional[SearchParamsFilters]` — Filtri per controllare quali tipi di risultati vengono restituiti `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### Condivisioni #### client.shares.show(...) -> AsyncHttpResponse\[ShareResponse] Mostra una singola condivisione. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ) ``` **Parametri** `account_id`: `Uuid` — `share_id`: `Uuid` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.shares.delete(...) -> AsyncHttpResponse\[None] Elimina una condivisione. Limiti di frequenza: 60 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ) ``` **Parametri** `account_id`: `Uuid` — `share_id`: `Uuid` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.shares.update(...) -> AsyncHttpResponse\[ShareResponse] Aggiorna la condivisione. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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(*", ), ) ``` **Parametri** `account_id`: `Uuid` — `share_id`: `Uuid`— `data`: `UpdateShareParamsData` `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.shares.list\_reviewers(...) -> AsyncPager\[User, ShareReviewersResponse] Elenca i revisori della condivisione. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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="", 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 ``` **Parametri** `account_id`: `Uuid` — `share_id`: `Uuid`— `after`: `typing.Optional[RequestAfterOpaqueCursor]` Parametro di richiesta del cursore opaco per le richieste che restituiscono risultati impaginati. > **Tip** > > Questo valore è generato automaticamente e incluso come nei link provenienti da una risposta precedente. Non è destinato a essere leggibile. `page_size`: `typing.Optional[RequestPageSize]` — `include_total_count`: `typing.Optional[IncludeTotalCount]` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.shares.add\_reviewers(...) -> AsyncHttpResponse\[None] Aggiungi revisori alla condivisione sicura in base a tre tipi di identificatore: `adobe_user_id`, `e-mail` e `user_id`. Una richiesta può includere un solo parametro di tipo di identificatore. `e-mail` è l'unico identificatore in grado di aggiungere a una condivisione i revisori che non hanno un membro dell'account Frame nell'account a cui appartiene la condivisione. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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"], ), ), ) ``` **Parametri** `account_id`: `Uuid` — `share_id`: `Uuid`— `data`: `AddReviewersToShareParamsData` `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.shares.remove\_reviewers(...) -> AsyncHttpResponse\[None] Rimuove i revisori dalla condivisione sicura in base a tre tipi di identificatore: `adobe_user_id`, `e-mail` e `user_id`. Una richiesta può includere un solo parametro di tipo di identificatore. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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" ], ), ), ) ``` **Parametri** `account_id`: `Uuid` — `share_id`: `Uuid`— `data`: `RemoveReviewerParamsData` `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.shares.remove\_asset(...) -> AsyncHttpResponse\[RemoveAssetResponse] Rimuovi una risorsa all'interno di una condivisione. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ) ``` **Parametri** `account_id`: `Uuid` — `share_id`: `Uuid`— `asset_id`: `Uuid`— `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.shares.add\_asset(...) -> AsyncHttpResponse\[AddAssetResponse] Aggiungi nuova condivisione della risorsa. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ), ) ``` **Parametri** `account_id`: `Uuid` — `share_id`: `Uuid`— `data`: `AddAssetParamsData` `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.shares.index(...) -> AsyncPager\[Share, SharesResponse] Elenca le condivisioni in un progetto. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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="", 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 ``` **Parametri** `account_id`: `Uuid` — `project_id`: `Uuid`— `after`: `typing.Optional[RequestAfterOpaqueCursor]` Parametro di richiesta del cursore opaco per le richieste che restituiscono risultati impaginati. > **Tip** > > Questo valore è generato automaticamente e incluso come nei link provenienti da una risposta precedente. Non è destinato a essere leggibile. `page_size`: `typing.Optional[RequestPageSize]` — `include_total_count`: `typing.Optional[IncludeTotalCount]` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.shares.create(...) -> AsyncHttpResponse\[ShareResponse] Crea una condivisione. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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(*", ), ) ``` **Parametri** `account_id`: `Uuid` — `project_id`: `Uuid`— `data`: `CreateShareParamsData` `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### Caricare #### frameio.upload.FrameioUploader(asset, file, ...) Carica un file locale su Frame.io utilizzando gli URL pre-firmati restituiti da `client.files.create_local_upload(...)`. `FrameioUploader` è un thin wrapper che legge `upload_urls`, `file_size` e `media_type` dalla risposta `FileWithUploadUrls` ed esegue un caricamento S3 suddiviso in blocchi e multi-thread. **`usage`** ```python usage from frameio import Frameio from frameio.files import FileCreateLocalUploadParamsData from frameio.upload import FrameioUploader client = Frameio( token="YOUR_TOKEN", ) response = 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", ), ) with open("asset.png", "rb") as f: FrameioUploader(response.data, f).upload() ``` **Parametri** `asset`: `FileWithUploadUrls` — Un'istanza `FileWithUploadUrls` restituita da `client.files.create_local_upload(...)`. `file`: `typing.BinaryIO` — Un oggetto simile a un file aperto in modalità di lettura binaria (`"rb"`). `max_workers`: `int` — Concorrenza del pool di thread passata all'uploader sottostante. Il valore predefinito è 5. `headers`: `typing.Optional[typing.Dict[str, str]]` — Intestazioni aggiuntive unite in ogni richiesta PUT S3. Il valore predefinito è `{"x-amz-acl": "private"}` come richiesto da Frame.io. `max_retries`: `int` — Numero di tentativi di ripetizione per chunk. Il valore predefinito è 3. `on_progress`: `typing.Optional[typing.Callable[[int, int], None]]` — Callback opzionale richiamato dopo ogni chunk con `(bytes_uploaded_so_far, total_bytes)`. **Metodi** `upload() -> None` — Carica il file. Si blocca fino al completamento o genera un errore. #### Utenti #### client.users.show() -> AsyncHttpResponse\[ProfileResponse] Ispeziona i dettagli dell'utente associato al token bearer. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python usage from frameio import Frameio client = Frameio( token="YOUR_TOKEN", ) client.users.show() ``` **Parametri** `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### Stack di versioni #### client.version\_stacks.index(...) -> AsyncHttpResponse\[AssetsWithIncludesResponse] Elenca gli elementi figlio (file) in uno stack di versioni specifico. Usa il parametro di query "include" della richiesta per includere in modo selettivo proprietà aggiuntive nella risposta. > **Note** > > Se includi `media_links.original` e l'utente non ha l'autorizzazione per scaricare file nel progetto corrispondente, questo endpoint risponderà con un errore `403 Forbidden`. Se il contenuto non è accessibile perché è richiesta la filigrana per questo utente e non è supportata dai media\_link richiesti, la richiesta avrà esito positivo, ma i link multimediali non supportati saranno impostati su null. Allo stesso modo, se un link di transcodifica richiesto non esiste per un file particolare (ad esempio includendo `media_links.video_h264_180` su un file di immagine statica) o se il processo di transcodifica non è finito (ovvero lo stato del file è "uploaded" invece di "transcoded"), anche un link multimediale sarà impostato su null nel payload di risposta. In breve, il client deve gestire i link multimediali null in modo appropriato. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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="", page_size=10, include_total_count=False, ) ``` **Parametri** `account_id`: Uuid — `version_stack_id`: Uuid — `include`: typing.Optional\[FileWithMediaLinksInclude] — `after`: typing.Optional\[RequestAfterOpaqueCursor] Parametro di richiesta del cursore opaco per le richieste che restituiscono risultati impaginati. > **Tip** > > Questo valore è generato automaticamente e incluso come nei link provenienti da una risposta precedente. Non è destinato a essere leggibile. `page_size`: typing.Optional\[RequestPageSize] — `include_total_count`: typing.Optional\[IncludeTotalCount] — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.version\_stacks.show(...) -> AsyncHttpResponse\[VersionStackWithIncludesResponse] Mostra i dettagli dello stack di versioni. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ) ``` **Parametri** `account_id`: Uuid — `version_stack_id`: Uuid — `include`: typing.Optional\[VersionStacksShowRequestInclude] — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.version\_stacks.copy(...) -> AsyncHttpResponse\[VersionStackCopyResponse] Copia lo stack di versioni. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ), ) ``` **Parametri** `account_id`: Uuid — `version_stack_id`: Uuid — `copy_metadata`: typing.Optional\[bool] — Indica se copiare i valori dei metadati insieme allo stack di versioni `data`: typing.Optional\[VersionStackCopyParamsData] `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.version\_stacks.list(...) -> AsyncHttpResponse\[VersionStacksWithIncludesResponse] Elenca gli stack di versioni in una determinata cartella. Limiti di frequenza: 5 chiamate ogni 1 secondo per account\_user **`usage`** ```python 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="", page_size=10, include_total_count=False, ) ``` **Parametri** `account_id`: Uuid — `folder_id`: Uuid — `include`: typing.Optional\[FileWithMediaLinksInclude] — `after`: typing.Optional\[RequestAfterOpaqueCursor] Parametro di richiesta del cursore opaco per le richieste che restituiscono risultati impaginati. > **Tip** > > Questo valore è generato automaticamente e incluso come nei link provenienti da una risposta precedente. Non è destinato a essere leggibile. `page_size`: typing.Optional\[RequestPageSize] — `include_total_count`: typing.Optional\[IncludeTotalCount] — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.version\_stacks.create(...) -> AsyncHttpResponse\[VersionStackWithIncludesResponse] Crea un nuovo stack di versioni nella cartella principale. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ], ), ) ``` **Parametri** `account_id`: Uuid — `folder_id`: Uuid — `data`: VersionStackCreateParamsData `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.version\_stacks.move(...) -> AsyncHttpResponse\[VersionStackResponse] Sposta lo stack di versioni in una cartella. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ), ) ``` **Parametri** `account_id`: Uuid — `version_stack_id`: Uuid — `data`: VersionStackMoveParamsData `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### Webhook #### client.webhooks.index(...) -> AsyncPager\[WebhookWithIncludes, WebhooksWithIncludesResponse] Elenca i webhook per l'area di lavoro specifica. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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="", 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 ``` **Parametri** `account_id`: Uuid — `workspace_id`: Uuid — `include`: typing.Optional\[typing.Literal\["creator"]] — `after`: typing.Optional\[RequestAfterOpaqueCursor] Parametro di richiesta del cursore opaco per le richieste che restituiscono risultati impaginati. > **Tip** > > Questo valore è generato automaticamente e incluso come nei link provenienti da una risposta precedente. Non è destinato a essere leggibile. `page_size`: typing.Optional\[RequestPageSize] — `include_total_count`: typing.Optional\[IncludeTotalCount] — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.webhooks.create(...) -> AsyncHttpResponse\[WebhookCreateResponse] Crea un singolo webhook con un secret. Eventi validi: `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`. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account **`usage`** ```python 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", ), ) ``` **Parametri** `account_id`: Uuid — `workspace_id`: Uuid — `data`: WebhookCreateParamsData `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.webhooks.show(...) -> AsyncHttpResponse\[WebhookWithIncludesResponse] Mostra i dettagli del webhook. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ) ``` **Parametri** `account_id`: Uuid — `webhook_id`: Uuid — `include`: typing.Optional\[typing.Literal\["creator"]] — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.webhooks.delete(...) -> AsyncHttpResponse\[None] Elimina un webhook. Limiti di frequenza: 60 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ) ``` **Parametri** `account_id`: Uuid — `webhook_id`: Uuid — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.webhooks.update(...) -> AsyncHttpResponse\[WebhookResponse] Aggiorna i dettagli del webhook. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ), ) ``` **Parametri** `account_id`: Uuid — `webhook_id`: Uuid — `data`: WebhookUpdateParamsData `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### Autorizzazioni dell’area di lavoro #### client.workspace\_permissions.index(...) -> AsyncPager\[UserRole, UserRolesResponse] Elenca i ruoli utente per un'area di lavoro specifica. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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="", 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 ``` **Parametri** `account_id`: `Uuid` — `workspace_id`: `Uuid` — `includ_deactivated`: `typing.Optional[bool]` — Supporta l'inclusione di utenti disattivati nella risposta.Il valore predefinito è false. `after`: `typing.Optional[RequestAfterOpaqueCursor]` Parametro di richiesta del cursore opaco per le richieste che restituiscono risultati impaginati. > **Tip** > > Questo valore è generato automaticamente e incluso come nei link provenienti da una risposta precedente. Non è destinato a essere leggibile. `page_size`: `typing.Optional[RequestPageSize]` — `include_total_count`: `typing.Optional[IncludeTotalCount]` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.workspace\_permissions.workspace\_user\_roles\_delete(...) -> AsyncHttpResponse\[None] Rimuovi un utente da un'area di lavoro specifica. Limiti di frequenza: 60 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ) ``` **Parametri** `account_id`: `Uuid` — `workspace_id`: `Uuid` — `user_id`: `Uuid` — `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### client.workspace\_permissions.workspace\_user\_roles\_update(...) -> AsyncHttpResponse\[UpdateUserRolesResponse] Aggiorna i ruoli utente per l'area di lavoro specificata se l'utente è già stato aggiunto all'area di lavoro. Se l'utente non è stato aggiunto all'area di lavoro, viene aggiunto con il ruolo specificato. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ), ) ``` **Parametri** `account_id`: `Uuid` — `workspace_id`: `Uuid`— `user_id`: `Uuid` — `data`: `UpdateUserRolesParamsData` `request_options`: `typing.Optional[RequestOptions]` — Configurazione specifica della richiesta. #### Aree di lavoro #### client.workspaces.show(...) -> AsyncHttpResponse\[WorkspaceWithIncludesResponse] Mostra i dettagli dell'area di lavoro. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ) ``` **Parametri** `account_id`: Uuid — `workspace_id`: Uuid — `include`: typing.Optional\[typing.Literal\["creator"]] — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.workspaces.delete(...) -> AsyncHttpResponse\[None] Elimina l'area di lavoro dall'account. Limiti di frequenza: 60 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ) ``` **Parametri** `account_id`: Uuid — `workspace_id`: Uuid — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.workspaces.update(...) -> AsyncHttpResponse\[WorkspaceResponse] Aggiorna un'area di lavoro. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ), ) ``` **Parametri** `account_id`: Uuid — `workspace_id`: Uuid — `data`: WorkspaceParamsData `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.workspaces.index(...) -> AsyncPager\[WorkspaceWithIncludes, WorkspacesWithIncludesResponse] Elenca le aree di lavoro per un account specifico. Limiti di frequenza: 100 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python usage from frameio import Frameio client = Frameio( token="YOUR_TOKEN", ) response = client.workspaces.index( account_id="b2702c44-c6da-4bb6-8bbd-be6e547ccf1b", after="", 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 ``` **Parametri** `account_id`: Uuid — `workspace_id`: Uuid — `include`: typing.Optional\[typing.Literal\["owner"]] — after: typing.Optional\[RequestAfterOpaqueCursor] Parametro di richiesta del cursore opaco per le richieste che restituiscono risultati impaginati. > **Tip** > > Questo valore è generato automaticamente e incluso come nei link provenienti da una risposta precedente. Non è destinato a essere leggibile. `page_size`: typing.Optional\[RequestPageSize] — `include_total_count`: typing.Optional\[IncludeTotalCount] — `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. #### client.workspaces.create(...) -> AsyncHttpResponse\[WorkspaceResponse] Crea l'area di lavoro da un account. Limiti di frequenza: 10 chiamate ogni 1,00 minuto per account\_user **`usage`** ```python 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", ), ) ``` **Parametri** `account_id`: Uuid — `data`: WorkspaceParamsData `request_options`: typing.Optional\[RequestOptions] — Configurazione specifica della richiesta. --- ### PyPI > **Launch** > > Visualizza su [PyPI](https://pypi.org/project/frameio/) ---