lilt.DocumentsApi

All URIs are relative to https://lilt.com/2

Method	HTTP request	Description
assign_document	PUT /documents/share	Assign a Document
create_document	POST /documents	Create a Document
delete_document	DELETE /documents	Delete a Document
download_document	GET /documents/files	Download a Document
get_document	GET /documents	Retrieve a Document
mark_review_done	POST /documents/done/review	Mark review done
mark_translation_done	POST /documents/done/translation	Mark translation done
pretranslate_documents	POST /documents/pretranslate	Pretranslate a Document
unlock_documents	POST /documents/done/unlock	Unlock documents
upload_document	POST /documents/files	Upload a File

assign_document

DocumentAssignmentResponse assign_document(body)

Assign a Document

Assign and unassign a Document for translation and/or review.

Example

Api Key Authentication (ApiKeyAuth):

from __future__ import print_function
import time
import lilt
from lilt.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://lilt.com/2
# See configuration.py for a list of all supported configuration parameters.
configuration = lilt.Configuration(
    host = "https://lilt.com/2"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration = lilt.Configuration(
    host = "https://lilt.com/2",
    api_key = {
        'key': 'YOUR_API_KEY'
    }
)
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['key'] = 'Bearer'

# Configure HTTP basic authorization: BasicAuth
configuration = lilt.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Enter a context with an instance of the API client
with lilt.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lilt.DocumentsApi(api_client)
    body = lilt.DocumentAssignmentParameters() # DocumentAssignmentParameters | 

    try:
        # Assign a Document
        api_response = api_instance.assign_document(body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DocumentsApi->assign_document: %s\n" % e)

Basic Authentication (BasicAuth):

from __future__ import print_function
import time
import lilt
from lilt.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://lilt.com/2
# See configuration.py for a list of all supported configuration parameters.
configuration = lilt.Configuration(
    host = "https://lilt.com/2"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration = lilt.Configuration(
    host = "https://lilt.com/2",
    api_key = {
        'key': 'YOUR_API_KEY'
    }
)
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['key'] = 'Bearer'

# Configure HTTP basic authorization: BasicAuth
configuration = lilt.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Enter a context with an instance of the API client
with lilt.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lilt.DocumentsApi(api_client)
    body = lilt.DocumentAssignmentParameters() # DocumentAssignmentParameters | 

    try:
        # Assign a Document
        api_response = api_instance.assign_document(body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DocumentsApi->assign_document: %s\n" % e)

Parameters

Name	Type	Description	Notes
body	DocumentAssignmentParameters

Return type

DocumentAssignmentResponse

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

HTTP response details

Status code	Description	Response headers
200	A status object.	-
0	Unexpected error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

create_document

DocumentWithSegments create_document(body=body)

Create a Document

Create a new Document. A Document is a collection of one or more Segments. Documents are nested inside of Projects, and appear in the Project details view in the web app. Document-level relationships between Segments are considered by the machine translation system during adaptation. If there is no inherent document structure in your data, you still might consider grouping related Segments into Documents to improve translation quality.

Example

Api Key Authentication (ApiKeyAuth):

from __future__ import print_function
import time
import lilt
from lilt.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://lilt.com/2
# See configuration.py for a list of all supported configuration parameters.
configuration = lilt.Configuration(
    host = "https://lilt.com/2"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration = lilt.Configuration(
    host = "https://lilt.com/2",
    api_key = {
        'key': 'YOUR_API_KEY'
    }
)
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['key'] = 'Bearer'

# Configure HTTP basic authorization: BasicAuth
configuration = lilt.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Enter a context with an instance of the API client
with lilt.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lilt.DocumentsApi(api_client)
    body = lilt.DocumentParameters() # DocumentParameters |  (optional)

    try:
        # Create a Document
        api_response = api_instance.create_document(body=body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DocumentsApi->create_document: %s\n" % e)

Basic Authentication (BasicAuth):

from __future__ import print_function
import time
import lilt
from lilt.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://lilt.com/2
# See configuration.py for a list of all supported configuration parameters.
configuration = lilt.Configuration(
    host = "https://lilt.com/2"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration = lilt.Configuration(
    host = "https://lilt.com/2",
    api_key = {
        'key': 'YOUR_API_KEY'
    }
)
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['key'] = 'Bearer'

# Configure HTTP basic authorization: BasicAuth
configuration = lilt.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Enter a context with an instance of the API client
with lilt.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lilt.DocumentsApi(api_client)
    body = lilt.DocumentParameters() # DocumentParameters |  (optional)

    try:
        # Create a Document
        api_response = api_instance.create_document(body=body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DocumentsApi->create_document: %s\n" % e)

Parameters

Name	Type	Description	Notes
body	DocumentParameters		[optional]

Return type

DocumentWithSegments

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

HTTP response details

Status code	Description	Response headers
200	A Document object.	-
0	Unexpected error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

delete_document

DocumentDeleteResponse delete_document(id)

Delete a Document

Delete a Document.

Example

Api Key Authentication (ApiKeyAuth):

from __future__ import print_function
import time
import lilt
from lilt.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://lilt.com/2
# See configuration.py for a list of all supported configuration parameters.
configuration = lilt.Configuration(
    host = "https://lilt.com/2"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration = lilt.Configuration(
    host = "https://lilt.com/2",
    api_key = {
        'key': 'YOUR_API_KEY'
    }
)
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['key'] = 'Bearer'

# Configure HTTP basic authorization: BasicAuth
configuration = lilt.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Enter a context with an instance of the API client
with lilt.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lilt.DocumentsApi(api_client)
    id = 56 # int | A unique Document identifier.

    try:
        # Delete a Document
        api_response = api_instance.delete_document(id)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DocumentsApi->delete_document: %s\n" % e)

Basic Authentication (BasicAuth):

from __future__ import print_function
import time
import lilt
from lilt.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://lilt.com/2
# See configuration.py for a list of all supported configuration parameters.
configuration = lilt.Configuration(
    host = "https://lilt.com/2"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration = lilt.Configuration(
    host = "https://lilt.com/2",
    api_key = {
        'key': 'YOUR_API_KEY'
    }
)
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['key'] = 'Bearer'

# Configure HTTP basic authorization: BasicAuth
configuration = lilt.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Enter a context with an instance of the API client
with lilt.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lilt.DocumentsApi(api_client)
    id = 56 # int | A unique Document identifier.

    try:
        # Delete a Document
        api_response = api_instance.delete_document(id)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DocumentsApi->delete_document: %s\n" % e)

Parameters

Name	Type	Description	Notes
id	int	A unique Document identifier.

Return type

DocumentDeleteResponse

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

HTTP response details

Status code	Description	Response headers
200	A status object.	-
0	Unexpected error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

download_document

str download_document(id, is_xliff=is_xliff)

Download a Document

Export a Document that has been translated in the Lilt web application. Any Document can be downloaded in XLIFF 1.2 format, or can be retrieved in its original uploaded format by setting is_xliff=false. This endpoint will fail if either (a) export or (b) pre-translation operations are in-progress. The status of those operations can be determined by retrieving the Document resource. Example CURL command: curl -X GET https://lilt.com/2/documents/files?key=API_KEY&id=274 -o from_lilt.xliff

Example

Api Key Authentication (ApiKeyAuth):

from __future__ import print_function
import time
import lilt
from lilt.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://lilt.com/2
# See configuration.py for a list of all supported configuration parameters.
configuration = lilt.Configuration(
    host = "https://lilt.com/2"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration = lilt.Configuration(
    host = "https://lilt.com/2",
    api_key = {
        'key': 'YOUR_API_KEY'
    }
)
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['key'] = 'Bearer'

# Configure HTTP basic authorization: BasicAuth
configuration = lilt.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Enter a context with an instance of the API client
with lilt.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lilt.DocumentsApi(api_client)
    id = 56 # int | An unique Document identifier.
is_xliff = True # bool | Download the document in XLIFF 1.2 format. (optional) (default to True)

    try:
        # Download a Document
        api_response = api_instance.download_document(id, is_xliff=is_xliff)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DocumentsApi->download_document: %s\n" % e)

Basic Authentication (BasicAuth):

from __future__ import print_function
import time
import lilt
from lilt.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://lilt.com/2
# See configuration.py for a list of all supported configuration parameters.
configuration = lilt.Configuration(
    host = "https://lilt.com/2"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration = lilt.Configuration(
    host = "https://lilt.com/2",
    api_key = {
        'key': 'YOUR_API_KEY'
    }
)
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['key'] = 'Bearer'

# Configure HTTP basic authorization: BasicAuth
configuration = lilt.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Enter a context with an instance of the API client
with lilt.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lilt.DocumentsApi(api_client)
    id = 56 # int | An unique Document identifier.
is_xliff = True # bool | Download the document in XLIFF 1.2 format. (optional) (default to True)

    try:
        # Download a Document
        api_response = api_instance.download_document(id, is_xliff=is_xliff)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DocumentsApi->download_document: %s\n" % e)

Parameters

Name	Type	Description	Notes
id	int	An unique Document identifier.
is_xliff	bool	Download the document in XLIFF 1.2 format.	[optional] [default to True]

Return type

str

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

Content-Type: Not defined
Accept: application/octet-stream

HTTP response details

Status code	Description	Response headers
200	A file.	-
502	File in pretranslation.	-
0	Unexpected error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

get_document

DocumentWithSegments get_document(id, with_segments=with_segments)

Retrieve a Document

List a Document. The listing will include the pretranslation status for the document. When pretranslation is in progress for a document, the GET /documents endpoint's response will include is_pretranslating = true as well as a more detailed status property status.pretranslation one of idle, pending, or running.

Example

Api Key Authentication (ApiKeyAuth):

from __future__ import print_function
import time
import lilt
from lilt.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://lilt.com/2
# See configuration.py for a list of all supported configuration parameters.
configuration = lilt.Configuration(
    host = "https://lilt.com/2"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration = lilt.Configuration(
    host = "https://lilt.com/2",
    api_key = {
        'key': 'YOUR_API_KEY'
    }
)
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['key'] = 'Bearer'

# Configure HTTP basic authorization: BasicAuth
configuration = lilt.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Enter a context with an instance of the API client
with lilt.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lilt.DocumentsApi(api_client)
    id = 56 # int | A unique Document identifier.
with_segments = True # bool | Flag indicating whether full segment information should be returned. (optional)

    try:
        # Retrieve a Document
        api_response = api_instance.get_document(id, with_segments=with_segments)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DocumentsApi->get_document: %s\n" % e)

Basic Authentication (BasicAuth):

from __future__ import print_function
import time
import lilt
from lilt.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://lilt.com/2
# See configuration.py for a list of all supported configuration parameters.
configuration = lilt.Configuration(
    host = "https://lilt.com/2"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration = lilt.Configuration(
    host = "https://lilt.com/2",
    api_key = {
        'key': 'YOUR_API_KEY'
    }
)
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['key'] = 'Bearer'

# Configure HTTP basic authorization: BasicAuth
configuration = lilt.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Enter a context with an instance of the API client
with lilt.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lilt.DocumentsApi(api_client)
    id = 56 # int | A unique Document identifier.
with_segments = True # bool | Flag indicating whether full segment information should be returned. (optional)

    try:
        # Retrieve a Document
        api_response = api_instance.get_document(id, with_segments=with_segments)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DocumentsApi->get_document: %s\n" % e)

Parameters

Name	Type	Description	Notes
id	int	A unique Document identifier.
with_segments	bool	Flag indicating whether full segment information should be returned.	[optional]

Return type

DocumentWithSegments

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

HTTP response details

Status code	Description	Response headers
200	A Document object.	-
0	Unexpected error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

mark_review_done

list[float] mark_review_done(body)

Mark review done

Mark the review of documents as done/undone in bulk. When being marked positively as done: - Documents must not already be marked as done for review. - Documents must already be marked as done for translation. - This request will also trigger an email notification. Example curl: curl --X --request POST 'https://lilt.com/2/documents/done/review?key=API_KEY' \\ --header 'Content-Type: application/json' \\ --data-raw '{ \"documentIds\": [23921, 23922], \"isDone\": true }'

Example

Api Key Authentication (ApiKeyAuth):

from __future__ import print_function
import time
import lilt
from lilt.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://lilt.com/2
# See configuration.py for a list of all supported configuration parameters.
configuration = lilt.Configuration(
    host = "https://lilt.com/2"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration = lilt.Configuration(
    host = "https://lilt.com/2",
    api_key = {
        'key': 'YOUR_API_KEY'
    }
)
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['key'] = 'Bearer'

# Configure HTTP basic authorization: BasicAuth
configuration = lilt.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Enter a context with an instance of the API client
with lilt.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lilt.DocumentsApi(api_client)
    body = lilt.DocumentDoneUpdateParameters2() # DocumentDoneUpdateParameters2 | 

    try:
        # Mark review done
        api_response = api_instance.mark_review_done(body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DocumentsApi->mark_review_done: %s\n" % e)

Basic Authentication (BasicAuth):

from __future__ import print_function
import time
import lilt
from lilt.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://lilt.com/2
# See configuration.py for a list of all supported configuration parameters.
configuration = lilt.Configuration(
    host = "https://lilt.com/2"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration = lilt.Configuration(
    host = "https://lilt.com/2",
    api_key = {
        'key': 'YOUR_API_KEY'
    }
)
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['key'] = 'Bearer'

# Configure HTTP basic authorization: BasicAuth
configuration = lilt.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Enter a context with an instance of the API client
with lilt.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lilt.DocumentsApi(api_client)
    body = lilt.DocumentDoneUpdateParameters2() # DocumentDoneUpdateParameters2 | 

    try:
        # Mark review done
        api_response = api_instance.mark_review_done(body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DocumentsApi->mark_review_done: %s\n" % e)

Parameters

Name	Type	Description	Notes
body	DocumentDoneUpdateParameters2

Return type

list[float]

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

HTTP response details

Status code	Description	Response headers
200	array of updated documents	-
0	Unexpected error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

mark_translation_done

list[float] mark_translation_done(body)

Mark translation done

Mark the translation of documents as done/undone in bulk. When being marked positively as done: - Documents must not already be marked as done and all segments must be confirmed. - This request will also trigger an email notification to a document's assigned reviewer that the document is ready for review. When being marked as un-done: - Documents must not be marked as complete for review. Example curl: curl --X --request POST 'https://lilt.com/2/documents/done/translation?key=API_KEY' \\ --header 'Content-Type: application/json' \\ --data-raw '{ \"documentIds\": [23921, 23922], \"isDone\": true }'

Example

Api Key Authentication (ApiKeyAuth):

from __future__ import print_function
import time
import lilt
from lilt.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://lilt.com/2
# See configuration.py for a list of all supported configuration parameters.
configuration = lilt.Configuration(
    host = "https://lilt.com/2"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration = lilt.Configuration(
    host = "https://lilt.com/2",
    api_key = {
        'key': 'YOUR_API_KEY'
    }
)
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['key'] = 'Bearer'

# Configure HTTP basic authorization: BasicAuth
configuration = lilt.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Enter a context with an instance of the API client
with lilt.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lilt.DocumentsApi(api_client)
    body = lilt.DocumentDoneUpdateParameters1() # DocumentDoneUpdateParameters1 | 

    try:
        # Mark translation done
        api_response = api_instance.mark_translation_done(body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DocumentsApi->mark_translation_done: %s\n" % e)

Basic Authentication (BasicAuth):

from __future__ import print_function
import time
import lilt
from lilt.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://lilt.com/2
# See configuration.py for a list of all supported configuration parameters.
configuration = lilt.Configuration(
    host = "https://lilt.com/2"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration = lilt.Configuration(
    host = "https://lilt.com/2",
    api_key = {
        'key': 'YOUR_API_KEY'
    }
)
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['key'] = 'Bearer'

# Configure HTTP basic authorization: BasicAuth
configuration = lilt.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Enter a context with an instance of the API client
with lilt.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lilt.DocumentsApi(api_client)
    body = lilt.DocumentDoneUpdateParameters1() # DocumentDoneUpdateParameters1 | 

    try:
        # Mark translation done
        api_response = api_instance.mark_translation_done(body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DocumentsApi->mark_translation_done: %s\n" % e)

Parameters

Name	Type	Description	Notes
body	DocumentDoneUpdateParameters1

Return type

list[float]

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

HTTP response details

Status code	Description	Response headers
200	array of updated documents	-
0	Unexpected error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

pretranslate_documents

DocumentPretranslateResponse pretranslate_documents(body, auto_accept=auto_accept, case_sensitive=case_sensitive, attribute_to_creator=attribute_to_creator, mode=mode)

Pretranslate a Document

Initiate pretranslation of a list of Documents. This request will mark document(s) as being pretranslated. Pretranslation in this context is: - Applying and confirming exact TM matches based on the Memory of the Project; - Translating all other segments via MT without confirming them. Example CURL command: curl -X POST https://lilt.com/2/documents/pretranslate?key=API_KEY -d '{\"id\": [123]}' -H \"Content-Type: application/json\" Document translation is an asynchronous process that, in effect, is performed in the background. To check the status of pretranslation for a document, use the GET /documents endpoint. When pretranslation is in progress for a document, the GET /documents endpoint's response will include is_pretranslating = true as well as a more detailed status property status.pretranslation one of idle, pending, or running. Once pretranslation is finished, the document can be downloaded via GET /documents/files.

Example

Api Key Authentication (ApiKeyAuth):

from __future__ import print_function
import time
import lilt
from lilt.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://lilt.com/2
# See configuration.py for a list of all supported configuration parameters.
configuration = lilt.Configuration(
    host = "https://lilt.com/2"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration = lilt.Configuration(
    host = "https://lilt.com/2",
    api_key = {
        'key': 'YOUR_API_KEY'
    }
)
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['key'] = 'Bearer'

# Configure HTTP basic authorization: BasicAuth
configuration = lilt.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Enter a context with an instance of the API client
with lilt.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lilt.DocumentsApi(api_client)
    body = lilt.DocumentPretranslateParameters() # DocumentPretranslateParameters | 
auto_accept = True # bool | Deprecated, use body param instead. Optional parameter for auto-accepting 100% TM hits. (optional)
case_sensitive = True # bool | Deprecated, use body param instead. Optional for using case matching against TM hits. (optional)
attribute_to_creator = True # bool | Deprecated, use body param instead. Optional parameter for attributing translation authorship of exact matches to document creator. (optional)
mode = 'mode_example' # str | Deprecated, use body param instead. An optional parameter indicating how the document will be pretranslated.  The accepted values are `tm`, or `tm+mt`. Default is `tm`.  (optional)

    try:
        # Pretranslate a Document
        api_response = api_instance.pretranslate_documents(body, auto_accept=auto_accept, case_sensitive=case_sensitive, attribute_to_creator=attribute_to_creator, mode=mode)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DocumentsApi->pretranslate_documents: %s\n" % e)

Basic Authentication (BasicAuth):

from __future__ import print_function
import time
import lilt
from lilt.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://lilt.com/2
# See configuration.py for a list of all supported configuration parameters.
configuration = lilt.Configuration(
    host = "https://lilt.com/2"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration = lilt.Configuration(
    host = "https://lilt.com/2",
    api_key = {
        'key': 'YOUR_API_KEY'
    }
)
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['key'] = 'Bearer'

# Configure HTTP basic authorization: BasicAuth
configuration = lilt.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Enter a context with an instance of the API client
with lilt.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lilt.DocumentsApi(api_client)
    body = lilt.DocumentPretranslateParameters() # DocumentPretranslateParameters | 
auto_accept = True # bool | Deprecated, use body param instead. Optional parameter for auto-accepting 100% TM hits. (optional)
case_sensitive = True # bool | Deprecated, use body param instead. Optional for using case matching against TM hits. (optional)
attribute_to_creator = True # bool | Deprecated, use body param instead. Optional parameter for attributing translation authorship of exact matches to document creator. (optional)
mode = 'mode_example' # str | Deprecated, use body param instead. An optional parameter indicating how the document will be pretranslated.  The accepted values are `tm`, or `tm+mt`. Default is `tm`.  (optional)

    try:
        # Pretranslate a Document
        api_response = api_instance.pretranslate_documents(body, auto_accept=auto_accept, case_sensitive=case_sensitive, attribute_to_creator=attribute_to_creator, mode=mode)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DocumentsApi->pretranslate_documents: %s\n" % e)

Parameters

Name	Type	Description	Notes
body	DocumentPretranslateParameters
auto_accept	bool	Deprecated, use body param instead. Optional parameter for auto-accepting 100% TM hits.	[optional]
case_sensitive	bool	Deprecated, use body param instead. Optional for using case matching against TM hits.	[optional]
attribute_to_creator	bool	Deprecated, use body param instead. Optional parameter for attributing translation authorship of exact matches to document creator.	[optional]
mode	str	Deprecated, use body param instead. An optional parameter indicating how the document will be pretranslated. The accepted values are `tm`, or `tm+mt`. Default is `tm`.	[optional]

Return type

DocumentPretranslateResponse

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

HTTP response details

Status code	Description	Response headers
202	A status object.	-
0	Unexpected error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

unlock_documents

list[float] unlock_documents(body)

Unlock documents

Unlock documents for translation. Sets document "Translation Done" and "Review Done" to false. Example curl: curl --X --request POST 'https://lilt.com/2/documents/done/unlock?key=API_KEY' \\ --header 'Content-Type: application/json' \\ --data-raw '{ \"documentIds\": [23921, 23922] }'

Example

Api Key Authentication (ApiKeyAuth):

from __future__ import print_function
import time
import lilt
from lilt.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://lilt.com/2
# See configuration.py for a list of all supported configuration parameters.
configuration = lilt.Configuration(
    host = "https://lilt.com/2"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration = lilt.Configuration(
    host = "https://lilt.com/2",
    api_key = {
        'key': 'YOUR_API_KEY'
    }
)
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['key'] = 'Bearer'

# Configure HTTP basic authorization: BasicAuth
configuration = lilt.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Enter a context with an instance of the API client
with lilt.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lilt.DocumentsApi(api_client)
    body = lilt.DocumentDoneUpdateParameters() # DocumentDoneUpdateParameters | 

    try:
        # Unlock documents
        api_response = api_instance.unlock_documents(body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DocumentsApi->unlock_documents: %s\n" % e)

Basic Authentication (BasicAuth):

from __future__ import print_function
import time
import lilt
from lilt.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://lilt.com/2
# See configuration.py for a list of all supported configuration parameters.
configuration = lilt.Configuration(
    host = "https://lilt.com/2"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration = lilt.Configuration(
    host = "https://lilt.com/2",
    api_key = {
        'key': 'YOUR_API_KEY'
    }
)
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['key'] = 'Bearer'

# Configure HTTP basic authorization: BasicAuth
configuration = lilt.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Enter a context with an instance of the API client
with lilt.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lilt.DocumentsApi(api_client)
    body = lilt.DocumentDoneUpdateParameters() # DocumentDoneUpdateParameters | 

    try:
        # Unlock documents
        api_response = api_instance.unlock_documents(body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DocumentsApi->unlock_documents: %s\n" % e)

Parameters

Name	Type	Description	Notes
body	DocumentDoneUpdateParameters

Return type

list[float]

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

HTTP response details

Status code	Description	Response headers
200	array of updated documents	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

upload_document

DocumentWithSegments upload_document(name, project_id, body, pretranslate=pretranslate, auto_accept=auto_accept, case_sensitive=case_sensitive, match_attribution=match_attribution, config_id=config_id)

Upload a File

Create a Document from a file in any of the formats documented in our knowledge base. Request parameters should be passed as JSON object with the header field LILT-API. File names in the header can only contain US-ASCII characters. File names with characters outside of US-ASCII should be URI encoded or transliterated to US-ASCII strings. Example CURL command: curl -X POST https://lilt.com/2/documents/files?key=API_KEY \\ --header \"LILT-API: {\\\"name\\\": \\\"introduction.xliff\\\",\\\"pretranslate\\\": \\\"tm+mt\\\",\\\"project_id\\\": 9}\" \\ --header \"Content-Type: application/octet-stream\" \\ --data-binary @Introduction.xliff

Example

Api Key Authentication (ApiKeyAuth):

from __future__ import print_function
import time
import lilt
from lilt.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://lilt.com/2
# See configuration.py for a list of all supported configuration parameters.
configuration = lilt.Configuration(
    host = "https://lilt.com/2"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration = lilt.Configuration(
    host = "https://lilt.com/2",
    api_key = {
        'key': 'YOUR_API_KEY'
    }
)
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['key'] = 'Bearer'

# Configure HTTP basic authorization: BasicAuth
configuration = lilt.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Enter a context with an instance of the API client
with lilt.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lilt.DocumentsApi(api_client)
    name = 'name_example' # str | A file name.
project_id = 56 # int | A unique Project identifier.
body = '/path/to/file' # file | The file contents to be uploaded. The entire POST body will be treated as the file. 
pretranslate = 'pretranslate_example' # str | An optional parameter indicating if and how the document will be pretranslated upon being uploaded. The accepted values are `TM`, or `TM+MT`  (optional)
auto_accept = True # bool | An optional parameter to auto-accept segments with 100% translation memory matches when the `pretranslate` option is also set, or to auto-accept any target data that is present when the uploaded file is XLIFF. If omitted it will default to your organization settings for `Accept and lock exact matches`, if set to `false`, no segments will be auto-accepted.  (optional)
case_sensitive = True # bool | An optional parameter to use case sensitive translation memory matching when the `pretranslate` option is also enabled. Matches must have identical character-by-character case to qualify as matches. Default value matches your organization settings for `Use case sensitive translation memory matching` setting  (optional)
match_attribution = True # bool | An optional parameter to attribute translation authorship of exact matches to the author of the file when the `pretranslate` option is also enabled. Default value matches your organization settings for `Translation authorship` setting  (optional)
config_id = 56 # int | An optional pararameter to specify an import configuration to be applied when extracting translatable content from this file.  (optional)

    try:
        # Upload a File
        api_response = api_instance.upload_document(name, project_id, body, pretranslate=pretranslate, auto_accept=auto_accept, case_sensitive=case_sensitive, match_attribution=match_attribution, config_id=config_id)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DocumentsApi->upload_document: %s\n" % e)

Basic Authentication (BasicAuth):

from __future__ import print_function
import time
import lilt
from lilt.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://lilt.com/2
# See configuration.py for a list of all supported configuration parameters.
configuration = lilt.Configuration(
    host = "https://lilt.com/2"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration = lilt.Configuration(
    host = "https://lilt.com/2",
    api_key = {
        'key': 'YOUR_API_KEY'
    }
)
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['key'] = 'Bearer'

# Configure HTTP basic authorization: BasicAuth
configuration = lilt.Configuration(
    username = 'YOUR_USERNAME',
    password = 'YOUR_PASSWORD'
)

# Enter a context with an instance of the API client
with lilt.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = lilt.DocumentsApi(api_client)
    name = 'name_example' # str | A file name.
project_id = 56 # int | A unique Project identifier.
body = '/path/to/file' # file | The file contents to be uploaded. The entire POST body will be treated as the file. 
pretranslate = 'pretranslate_example' # str | An optional parameter indicating if and how the document will be pretranslated upon being uploaded. The accepted values are `TM`, or `TM+MT`  (optional)
auto_accept = True # bool | An optional parameter to auto-accept segments with 100% translation memory matches when the `pretranslate` option is also set, or to auto-accept any target data that is present when the uploaded file is XLIFF. If omitted it will default to your organization settings for `Accept and lock exact matches`, if set to `false`, no segments will be auto-accepted.  (optional)
case_sensitive = True # bool | An optional parameter to use case sensitive translation memory matching when the `pretranslate` option is also enabled. Matches must have identical character-by-character case to qualify as matches. Default value matches your organization settings for `Use case sensitive translation memory matching` setting  (optional)
match_attribution = True # bool | An optional parameter to attribute translation authorship of exact matches to the author of the file when the `pretranslate` option is also enabled. Default value matches your organization settings for `Translation authorship` setting  (optional)
config_id = 56 # int | An optional pararameter to specify an import configuration to be applied when extracting translatable content from this file.  (optional)

    try:
        # Upload a File
        api_response = api_instance.upload_document(name, project_id, body, pretranslate=pretranslate, auto_accept=auto_accept, case_sensitive=case_sensitive, match_attribution=match_attribution, config_id=config_id)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DocumentsApi->upload_document: %s\n" % e)

Parameters

Name	Type	Description	Notes
name	str	A file name.
project_id	int	A unique Project identifier.
body	file	The file contents to be uploaded. The entire POST body will be treated as the file.
pretranslate	str	An optional parameter indicating if and how the document will be pretranslated upon being uploaded. The accepted values are `TM`, or `TM+MT`	[optional]
auto_accept	bool	An optional parameter to auto-accept segments with 100% translation memory matches when the `pretranslate` option is also set, or to auto-accept any target data that is present when the uploaded file is XLIFF. If omitted it will default to your organization settings for `Accept and lock exact matches`, if set to `false`, no segments will be auto-accepted.	[optional]
case_sensitive	bool	An optional parameter to use case sensitive translation memory matching when the `pretranslate` option is also enabled. Matches must have identical character-by-character case to qualify as matches. Default value matches your organization settings for `Use case sensitive translation memory matching` setting	[optional]
match_attribution	bool	An optional parameter to attribute translation authorship of exact matches to the author of the file when the `pretranslate` option is also enabled. Default value matches your organization settings for `Translation authorship` setting	[optional]
config_id	int	An optional pararameter to specify an import configuration to be applied when extracting translatable content from this file.	[optional]

Return type

DocumentWithSegments

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

Content-Type: application/octet-stream
Accept: application/json

HTTP response details

Status code	Description	Response headers
200	A Document object.	-
0	Unexpected error	-

[Back to top] [Back to API list] [Back to Model list] [Back to README]

Files

DocumentsApi.md

Latest commit

History

DocumentsApi.md

File metadata and controls

lilt.DocumentsApi

assign_document

Example

Parameters

Return type

Authorization

HTTP request headers

HTTP response details

create_document

Example

Parameters

Return type

Authorization

HTTP request headers

HTTP response details

delete_document

Example

Parameters

Return type

Authorization

HTTP request headers

HTTP response details

download_document

Example

Parameters

Return type

Authorization

HTTP request headers

HTTP response details

get_document

Example

Parameters

Return type

Authorization

HTTP request headers

HTTP response details

mark_review_done

Example

Parameters

Return type

Authorization

HTTP request headers

HTTP response details

mark_translation_done

Example

Parameters

Return type

Authorization

HTTP request headers

HTTP response details

pretranslate_documents

Example

Parameters

Return type

Authorization

HTTP request headers

HTTP response details

unlock_documents

Example

Parameters

Return type

Authorization

HTTP request headers

HTTP response details

upload_document

Example

Parameters

Return type

Authorization

HTTP request headers

HTTP response details