Python Client Library Reference =============================== .. py:module:: indivo_python_client :synopsis: A python client library for making authenticated Indivo API calls. .. py:class:: IndivoClient(server_params, consumer_params, resource_token=None, **state_vars) The Indivo python client. The client should be initialized with the following arguments: * *server_params*: A dictionary containing information about the API server. The dictionary should have two keys: ``api_base``, the server location from which the API is served, and ``authorization_base``, the server location to which the user should be redirected to perform OAuth authorization. * *consumer_params*: A dictionary containing information about your app. The dictionary should have two keys: ``consumer_key``, the OAuth consumer key for your app, and ``consumer_secret``, the OAuth consumer secret for your app. * *resource_token*: **Optional.** A token (request, access, or session) with which to sign requests. The token should be a dictionary with two keys: ``oauth_token`` and ``oauth_token_secret``. * *state_vars*: **Optional.** Additional state to track with the API. This will be used to fill in url parameters when available. For example, if you create an IndivoClient with ``pha_email='myapp@apps.indivo.org'``, then making an API call like :http:get:`/apps/{PHA_EMAIL}` will automatically fill in the url, without you needing to pass the ``pha_email`` argument into the call. This is useful with variables that are unlikely to change within the use of a single client object, such as ``pha_email`` or ``record_id``. You can override the variables in individual API calls if need be, however. -------- .. py:method:: IndivoClient.get(uri, body={}, headers={}, **uri_params) Make a signed HTTP GET request against Indivo. Arguments are: * *uri*: The URI against which to make the request. Optionally, the URI may have templatable parameters, which should take the form of ``{VAR_NAME}``. Such variables must be passed in via the *uri_params* argument or be present as a state variable on the :py:class:`~indivo_python_client.IndivoClient` instance itself, or a :py:exc:`KeyError` will be raised. * *body*: **Optional.** A dictionary containing querystring parameters to add to the request, for example: ``{ 'record_id': 'abcde' }``. * *headers*: **Optional.** A dictionary containing additional HTTP headers to add to the request. * *uri_params*: **Optional.** Additional parameters to be templated into the uri. parameter names should be the lower-cased equivalent of uri parameters. For example, if the URI contains ``{PHA_EMAIL}``, *uri_params* should contain ``pha_email='someapp@apps.indivo.org'``. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.put(uri, body='', headers={}, content_type=None, **uri_params) Make a signed HTTP PUT request against Indivo. Arguments are: * *uri*: The URI against which to make the request. Optionally, the URI may have templatable parameters, which should take the form of ``{VAR_NAME}``. Such variables must be passed in via the *uri_params* argument or be present as a state variable on the :py:class:`~indivo_python_client.IndivoClient` instance itself, or a :py:exc:`KeyError` will be raised. * *body*: **Optional.** The body of the request. It should be either a raw data string, or a dictionary containing form-data parameters. * *headers*: **Optional.** A dictionary containing additional HTTP headers to add to the request. * *content_type*: **Optional.** The MIME type of the data submitted in the PUT request. defaults to ``application/x-www-form-urlencoded``. * *uri_params*: **Optional.** Additional parameters to be templated into the uri. parameter names should be the lower-cased equivalent of uri parameters. For example, if the URI contains ``{PHA_EMAIL}``, *uri_params* should contain ``pha_email='someapp@apps.indivo.org'``. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.post(uri, body='', headers={}, content_type=None, **uri_params) Make a signed HTTP POST request against Indivo. Arguments are: * *uri*: The URI against which to make the request. Optionally, the URI may have templatable parameters, which should take the form of ``{VAR_NAME}``. Such variables must be passed in via the *uri_params* argument or be present as a state variable on the :py:class:`~indivo_python_client.IndivoClient` instance itself, or a :py:exc:`KeyError` will be raised. * *body*: **Optional.** The body of the request. It should be either a raw data string, or a dictionary containing form-data parameters. * *headers*: **Optional.** A dictionary containing additional HTTP headers to add to the request. * *content_type*: **Optional.** The MIME type of the data submitted in the POST request. defaults to ``application/x-www-form-urlencoded``. * *uri_params*: **Optional.** Additional parameters to be templated into the uri. parameter names should be the lower-cased equivalent of uri parameters. For example, if the URI contains ``{PHA_EMAIL}``, *uri_params* should contain ``pha_email='someapp@apps.indivo.org'``. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.delete(uri, headers={}, **uri_params) Make a signed HTTP DELETE request against Indivo. Arguments are: * *uri*: The URI against which to make the request. Optionally, the URI may have templatable parameters, which should take the form of ``{VAR_NAME}``. Such variables must be passed in via the *uri_params* argument or be present as a state variable on the :py:class:`~indivo_python_client.IndivoClient` instance itself, or a :py:exc:`KeyError` will be raised. * *headers*: **Optional.** A dictionary containing additional HTTP headers to add to the request. * *uri_params*: **Optional.** Additional parameters to be templated into the uri. parameter names should be the lower-cased equivalent of uri parameters. For example, if the URI contains ``{PHA_EMAIL}``, *uri_params* should contain ``pha_email='someapp@apps.indivo.org'``. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.update_token(resource_token) Update the token used by the client to sign requests. *resource_token* should be a dictionary with two keys: ``oauth_token`` and ``oauth_token_secret``. Returns ``None``. -------- .. py:method:: IndivoClient.fetch_request_token(params={}) Get a new request token from the server. *params* should include parameters for generating the token, such as ``indivo_record_id``. Returns the request token in the form of a dictionary with two keys: ``oauth_token`` and ``oauth_token_secret``. -------- .. py:method:: IndivoClient.exchange_token(verifier) Exchange the client's current token (a request token) for an access token. *verifier* must be the verifier string returned after the user has successfully authenticated. Returns the newly acquired access token in the form of a dictionary with two keys: ``oauth_token`` and ``oauth_token_secret``. -------- .. py:method:: IndivoClient.get_surl_credentials() Generate a token and secret for signing URLs. This token/secret are based on the client's current resource token (which should be an access token). SURL credentials are required in order to use a UI Server widget: they delegate access to the UI Server to make API calls on behalf of a user app. Returns a dictionary with two keys: ``token`` and ``secret``. -------- .. py:method:: IndivoClient.account_create([body={}, headers={}, content_type=None]) Create a new account, and send out initialization emails. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/accounts/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.account_search([body={}, headers={}]) Search for accounts by name or email. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/accounts/search` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.account_info(account_email=None[, body={}, headers={}]) Display information about an account. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/accounts/{ACCOUNT_EMAIL}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.get_connect_credentials(account_email=None, pha_email=None[, body={}, headers={}, content_type=None]) Get oAuth credentials for an app to run in Connect or SMART REST mode. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/accounts/{ACCOUNT_EMAIL}/apps/{PHA_EMAIL}/connect_credentials` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.delete_user_preferences(account_email=None, pha_email=None[, headers={}]) Delete all app-specific User Preferences for an account. *headers* should contain any additional HTTP headers to pass in with the call. See :http:delete:`/accounts/{ACCOUNT_EMAIL}/apps/{PHA_EMAIL}/preferences` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.get_user_preferences(account_email=None, pha_email=None[, body={}, headers={}]) Get app-specific User Preferences for an account. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/accounts/{ACCOUNT_EMAIL}/apps/{PHA_EMAIL}/preferences` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.set_user_preferences(account_email=None, pha_email=None[, body={}, headers={}, content_type=None]) Set app-specific User Preferences for an account. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:put:`/accounts/{ACCOUNT_EMAIL}/apps/{PHA_EMAIL}/preferences` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.account_authsystem_add(account_email=None[, body={}, headers={}, content_type=None]) Add a new method of authentication to an account. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/accounts/{ACCOUNT_EMAIL}/authsystems/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.account_password_change(account_email=None[, body={}, headers={}, content_type=None]) Change a account's password. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/accounts/{ACCOUNT_EMAIL}/authsystems/password/change` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.account_password_set(account_email=None[, body={}, headers={}, content_type=None]) Force the password of an account to a given value. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/accounts/{ACCOUNT_EMAIL}/authsystems/password/set` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.account_username_set(account_email=None[, body={}, headers={}, content_type=None]) Force the username of an account to a given value. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/accounts/{ACCOUNT_EMAIL}/authsystems/password/set-username` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.account_check_secrets(account_email=None, primary_secret=None[, body={}, headers={}]) Validate an account's primary and secondary secrets. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/accounts/{ACCOUNT_EMAIL}/check-secrets/{PRIMARY_SECRET}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.account_forgot_password(account_email=None[, body={}, headers={}, content_type=None]) Resets an account if the user has forgotten its password. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/accounts/{ACCOUNT_EMAIL}/forgot-password` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.account_inbox(account_email=None[, body={}, headers={}]) List messages in an account's inbox. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/accounts/{ACCOUNT_EMAIL}/inbox/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.account_send_message(account_email=None[, body={}, headers={}, content_type=None]) Send a message to an account. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/accounts/{ACCOUNT_EMAIL}/inbox/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.account_inbox_message(account_email=None, message_id=None[, body={}, headers={}]) Retrieve an individual message from an account's inbox. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/accounts/{ACCOUNT_EMAIL}/inbox/{MESSAGE_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.account_message_archive(account_email=None, message_id=None[, body={}, headers={}, content_type=None]) Archive a message. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/accounts/{ACCOUNT_EMAIL}/inbox/{MESSAGE_ID}/archive` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.account_inbox_message_attachment_accept(attachment_num=None, account_email=None, message_id=None[, body={}, headers={}, content_type=None]) Accept a message attachment into the record it corresponds to. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/accounts/{ACCOUNT_EMAIL}/inbox/{MESSAGE_ID}/attachments/{ATTACHMENT_NUM}/accept` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.account_info_set(account_email=None[, body={}, headers={}, content_type=None]) Set basic information about an account. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/accounts/{ACCOUNT_EMAIL}/info-set` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.account_initialize(account_email=None, primary_secret=None[, body={}, headers={}, content_type=None]) Initialize an account, activating it. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/accounts/{ACCOUNT_EMAIL}/initialize/{PRIMARY_SECRET}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.account_notifications(account_email=None[, body={}, headers={}]) List an account's notifications. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/accounts/{ACCOUNT_EMAIL}/notifications/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.account_permissions(account_email=None[, body={}, headers={}]) List the carenets that an account has access to. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/accounts/{ACCOUNT_EMAIL}/permissions/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.account_primary_secret(account_email=None[, body={}, headers={}]) Display an account's primary secret. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/accounts/{ACCOUNT_EMAIL}/primary-secret` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_list(account_email=None[, body={}, headers={}]) List all available records for an account. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/accounts/{ACCOUNT_EMAIL}/records/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.account_reset(account_email=None[, body={}, headers={}, content_type=None]) Reset an account to an ``uninitialized`` state. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/accounts/{ACCOUNT_EMAIL}/reset` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.account_secret(account_email=None[, body={}, headers={}]) Return the secondary secret of an account. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/accounts/{ACCOUNT_EMAIL}/secret` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.account_resend_secret(account_email=None[, body={}, headers={}, content_type=None]) Sends an account user their primary secret in case they lost it. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/accounts/{ACCOUNT_EMAIL}/secret-resend` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.account_set_state(account_email=None[, body={}, headers={}, content_type=None]) Set the state of an account. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/accounts/{ACCOUNT_EMAIL}/set-state` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.all_phas([body={}, headers={}]) List all available userapps. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/apps/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.all_manifests([body={}, headers={}]) List SMART manifests for all available userapps. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/apps/manifests/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.pha_delete(pha_email=None[, headers={}]) Delete a userapp from Indivo. *headers* should contain any additional HTTP headers to pass in with the call. See :http:delete:`/apps/{PHA_EMAIL}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.pha(pha_email=None[, body={}, headers={}]) Return a description of a single userapp. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/apps/{PHA_EMAIL}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.app_document_list(pha_email=None[, body={}, headers={}]) List app-specific documents. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/apps/{PHA_EMAIL}/documents/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.app_document_create(pha_email=None[, body={}, headers={}, content_type=None]) Create an app-specific Indivo document. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/apps/{PHA_EMAIL}/documents/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.app_document_create_or_update_ext(external_id=None, pha_email=None[, body={}, headers={}, content_type=None]) Create an app-specific Indivo document with an associated external id. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:put:`/apps/{PHA_EMAIL}/documents/external/{EXTERNAL_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.app_document_meta_ext(external_id=None, pha_email=None[, body={}, headers={}]) Fetch the metadata of an app-specific document identified by external id. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/apps/{PHA_EMAIL}/documents/external/{EXTERNAL_ID}/meta` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.app_document_delete(pha_email=None, document_id=None[, headers={}]) Delete an app-specific document. *headers* should contain any additional HTTP headers to pass in with the call. See :http:delete:`/apps/{PHA_EMAIL}/documents/{DOCUMENT_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.app_specific_document(pha_email=None, document_id=None[, body={}, headers={}]) Retrive an app-specific document. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/apps/{PHA_EMAIL}/documents/{DOCUMENT_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.app_document_create_or_update(pha_email=None, document_id=None[, body={}, headers={}, content_type=None]) Create or Overwrite an app-specific Indivo document. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:put:`/apps/{PHA_EMAIL}/documents/{DOCUMENT_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.app_document_label(pha_email=None, document_id=None[, body={}, headers={}, content_type=None]) Set the label of an app-specific document. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:put:`/apps/{PHA_EMAIL}/documents/{DOCUMENT_ID}/label` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.app_document_meta(pha_email=None, document_id=None[, body={}, headers={}]) Fetch the metadata of an app-specific document. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/apps/{PHA_EMAIL}/documents/{DOCUMENT_ID}/meta` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.app_manifest(pha_email=None[, body={}, headers={}]) Return a SMART manifest for a single userapp. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/apps/{PHA_EMAIL}/manifest` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.app_record_list(pha_email=None[, body={}, headers={}]) Return a list of all records that have this pha enabled. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/apps/{PHA_EMAIL}/records/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.autonomous_access_token(record_id=None, pha_email=None[, body={}, headers={}, content_type=None]) Fetch an access token for an autonomous app to access a record. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/apps/{PHA_EMAIL}/records/{RECORD_ID}/access_token` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.smart_capabilities([body={}, headers={}]) SMART Capabilities *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/capabilities/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.carenet_delete(carenet_id=None[, headers={}]) Delete a carenet. *headers* should contain any additional HTTP headers to pass in with the call. See :http:delete:`/carenets/{CARENET_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.carenet_account_list(carenet_id=None[, body={}, headers={}]) List the accounts in a carenet. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/carenets/{CARENET_ID}/accounts/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.carenet_account_create(carenet_id=None[, body={}, headers={}, content_type=None]) Add an account to a carenet. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/carenets/{CARENET_ID}/accounts/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.carenet_account_delete(account_id=None, carenet_id=None[, headers={}]) Remove an account from a carenet. *headers* should contain any additional HTTP headers to pass in with the call. See :http:delete:`/carenets/{CARENET_ID}/accounts/{ACCOUNT_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.carenet_account_permissions(account_id=None, carenet_id=None[, body={}, headers={}]) List the permissions of an account within a carenet. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/carenets/{CARENET_ID}/accounts/{ACCOUNT_ID}/permissions` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.carenet_apps_list(carenet_id=None[, body={}, headers={}]) List Apps within a given carenet. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/carenets/{CARENET_ID}/apps/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.carenet_apps_delete(pha_email=None, carenet_id=None[, headers={}]) Remove an app from a given carenet. *headers* should contain any additional HTTP headers to pass in with the call. See :http:delete:`/carenets/{CARENET_ID}/apps/{PHA_EMAIL}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.carenet_apps_create(pha_email=None, carenet_id=None[, body={}, headers={}, content_type=None]) Add an app to a carenet *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:put:`/carenets/{CARENET_ID}/apps/{PHA_EMAIL}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.carenet_app_permissions(pha_email=None, carenet_id=None[, body={}, headers={}]) Retrieve the permissions for an app within a carenet. NOT IMPLEMENTED. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/carenets/{CARENET_ID}/apps/{PHA_EMAIL}/permissions` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.read_demographics_carenet(carenet_id=None[, body={}, headers={}]) Read demographics from a carenet. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/carenets/{CARENET_ID}/demographics` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.carenet_document_list(carenet_id=None[, body={}, headers={}]) List documents from a given carenet. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/carenets/{CARENET_ID}/documents/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.carenet_document(document_id=None, carenet_id=None[, body={}, headers={}]) Return a document from a carenet. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/carenets/{CARENET_ID}/documents/{DOCUMENT_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.carenet_document_meta(document_id=None, carenet_id=None[, body={}, headers={}]) Fetch the metadata of a record-specific document via a carenet. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/carenets/{CARENET_ID}/documents/{DOCUMENT_ID}/meta` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.carenet_record(carenet_id=None[, body={}, headers={}]) Get basic information about the record to which a carenet belongs. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/carenets/{CARENET_ID}/record` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.carenet_rename(carenet_id=None[, body={}, headers={}, content_type=None]) Change a carenet's name. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/carenets/{CARENET_ID}/rename` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.carenet_equipment_list(carenet_id=None[, body={}, headers={}]) List the equipment data for a given carenet. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/carenets/{CARENET_ID}/reports/minimal/equipment/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.carenet_measurement_list(carenet_id=None, lab_code=None[, body={}, headers={}]) List the measurement data for a given carenet. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/carenets/{CARENET_ID}/reports/minimal/measurements/{LAB_CODE}/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.carenet_procedure_list(carenet_id=None[, body={}, headers={}]) List the procedure data for a given carenet. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/carenets/{CARENET_ID}/reports/minimal/procedures/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.carenet_simple_clinical_notes_list(carenet_id=None[, body={}, headers={}]) List the simple_clinical_notes data for a given carenet. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/carenets/{CARENET_ID}/reports/minimal/simple-clinical-notes/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.carenet_generic_list(data_model=None, carenet_id=None[, body={}, headers={}]) List the Model data for a given carenet. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/carenets/{CARENET_ID}/reports/{DATA_MODEL}/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.coding_systems_list([body={}, headers={}]) List available codingsystems. NOT IMPLEMENTED. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/codes/systems/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.coding_system_query(system_short_name=None[, body={}, headers={}]) Query a codingsystem for a value. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/codes/systems/{SYSTEM_SHORT_NAME}/query` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.exchange_token([body={}, headers={}, content_type=None]) Exchange a request token for a valid access token. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/oauth/access_token` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.request_token_approve(reqtoken_id=None[, body={}, headers={}, content_type=None]) Indicate a user's consent to bind an app to a record or carenet. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/oauth/internal/request_tokens/{REQTOKEN_ID}/approve` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.request_token_claim(reqtoken_id=None[, body={}, headers={}, content_type=None]) Claim a request token on behalf of an account. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/oauth/internal/request_tokens/{REQTOKEN_ID}/claim` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.request_token_info(reqtoken_id=None[, body={}, headers={}]) Get information about a request token. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/oauth/internal/request_tokens/{REQTOKEN_ID}/info` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.session_create([body={}, headers={}, content_type=None]) Authenticate a user and register a web session for them. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/oauth/internal/session_create` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.surl_verify([body={}, headers={}]) Verify a signed URL. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/oauth/internal/surl-verify` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.request_token([body={}, headers={}, content_type=None]) Get a new request token, bound to a record or carenet if desired. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/oauth/request_token` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.smart_ontology([body={}, headers={}]) Fetch the SMART ontology as RDF/XML. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/ontology` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_create([body={}, headers={}, content_type=None]) Create a new record. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/records/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_create_ext(principal_email=None, external_id=None[, body={}, headers={}, content_type=None]) Create a new record with an associated external id. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:put:`/records/external/{PRINCIPAL_EMAIL}/{EXTERNAL_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_search([body={}, headers={}]) Search for records by label (usually the same as full name). *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/search` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record(record_id=None[, body={}, headers={}]) Get information about an individual record. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.smart_allergies(record_id=None[, body={}, headers={}]) SMART allergy list, serialized as RDF/XML. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/allergies/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.smart_allergies_instance(record_id=None, model_id=None[, body={}, headers={}]) Retrieve a specific instance of a SMART Allergy/AllergyExclusion. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/allergies/{MODEL_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_phas(record_id=None[, body={}, headers={}]) List userapps bound to a given record. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/apps/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.pha_record_delete(record_id=None, pha_email=None[, headers={}]) Remove a userapp from a record. *headers* should contain any additional HTTP headers to pass in with the call. See :http:delete:`/records/{RECORD_ID}/apps/{PHA_EMAIL}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_pha(record_id=None, pha_email=None[, body={}, headers={}]) Get information about a given userapp bound to a record. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/apps/{PHA_EMAIL}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_pha_enable(record_id=None, pha_email=None[, body={}, headers={}, content_type=None]) Enable a userapp for a record. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:put:`/records/{RECORD_ID}/apps/{PHA_EMAIL}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_app_document_list(record_id=None, pha_email=None[, body={}, headers={}]) List record-app-specific documents. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/apps/{PHA_EMAIL}/documents/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_app_document_create(record_id=None, pha_email=None[, body={}, headers={}, content_type=None]) Create a record-app-specific Indivo document. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/records/{RECORD_ID}/apps/{PHA_EMAIL}/documents/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_app_document_create_or_update_ext(record_id=None, external_id=None, pha_email=None[, body={}, headers={}, content_type=None]) Create or Overwrite a record-app-specific Indivo document with an associated external id. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/records/{RECORD_ID}/apps/{PHA_EMAIL}/documents/external/{EXTERNAL_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_app_document_create_or_update_ext(record_id=None, external_id=None, pha_email=None[, body={}, headers={}, content_type=None]) Create or Overwrite a record-app-specific Indivo document with an associated external id. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:put:`/records/{RECORD_ID}/apps/{PHA_EMAIL}/documents/external/{EXTERNAL_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_app_document_meta_ext(record_id=None, external_id=None, pha_email=None[, body={}, headers={}]) Fetch the metadata of a record-app-specific document identified by external id. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/apps/{PHA_EMAIL}/documents/external/{EXTERNAL_ID}/meta` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_app_document_delete(record_id=None, pha_email=None, document_id=None[, headers={}]) Delete a record-app-specific document. *headers* should contain any additional HTTP headers to pass in with the call. See :http:delete:`/records/{RECORD_ID}/apps/{PHA_EMAIL}/documents/{DOCUMENT_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_app_specific_document(record_id=None, pha_email=None, document_id=None[, body={}, headers={}]) Retrieve a record-app-specific document. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/apps/{PHA_EMAIL}/documents/{DOCUMENT_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_app_document_label(record_id=None, pha_email=None, document_id=None[, body={}, headers={}, content_type=None]) Set the label of a record-app-specific document. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:put:`/records/{RECORD_ID}/apps/{PHA_EMAIL}/documents/{DOCUMENT_ID}/label` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_app_document_meta(record_id=None, pha_email=None, document_id=None[, body={}, headers={}]) Fetch the metadata of a record-app-specific document. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/apps/{PHA_EMAIL}/documents/{DOCUMENT_ID}/meta` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_pha_setup(record_id=None, pha_email=None[, body={}, headers={}, content_type=None]) Bind an app to a record without user authorization. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/records/{RECORD_ID}/apps/{PHA_EMAIL}/setup` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.audit_record_view(record_id=None[, body={}, headers={}]) Return audits of calls touching *record*. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/audits/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.audit_document_view(record_id=None, document_id=None[, body={}, headers={}]) Return audits of calls touching *record* and *document_id*. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/audits/documents/{DOCUMENT_ID}/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.audit_function_view(record_id=None, document_id=None, function_name=None[, body={}, headers={}]) Return audits of calls to *function_name* touching *record* and *document_id*. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/audits/documents/{DOCUMENT_ID}/functions/{FUNCTION_NAME}/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.audit_query(record_id=None[, body={}, headers={}]) Select Audit Objects via the Query API Interface. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/audits/query/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.autoshare_list(record_id=None[, body={}, headers={}]) For a single record, list all carenets that a given doctype is autoshared with. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/autoshare/bytype/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.autoshare_list_bytype_all(record_id=None[, body={}, headers={}]) For a single record, list all doctypes autoshared into carenets. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/autoshare/bytype/all` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.autoshare_create(record_id=None, carenet_id=None[, body={}, headers={}, content_type=None]) Automatically share all documents of a certain type into a carenet. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/records/{RECORD_ID}/autoshare/carenets/{CARENET_ID}/bytype/set` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.autoshare_delete(record_id=None, carenet_id=None[, body={}, headers={}, content_type=None]) Remove an autoshare from a carenet. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/records/{RECORD_ID}/autoshare/carenets/{CARENET_ID}/bytype/unset` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.carenet_list(record_id=None[, body={}, headers={}]) List all carenets for a record. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/carenets/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.carenet_create(record_id=None[, body={}, headers={}, content_type=None]) Create a new carenet for a record. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/records/{RECORD_ID}/carenets/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.read_demographics(record_id=None[, body={}, headers={}]) Read demographics from a record. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/demographics` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.set_demographics(record_id=None[, body={}, headers={}, content_type=None]) Create or update demographics on a record. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:put:`/records/{RECORD_ID}/demographics` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.documents_delete(record_id=None[, headers={}]) Delete all documents associated with a record. *headers* should contain any additional HTTP headers to pass in with the call. See :http:delete:`/records/{RECORD_ID}/documents/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_document_list(record_id=None[, body={}, headers={}]) List record-specific documents. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/documents/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.document_create(record_id=None[, body={}, headers={}, content_type=None]) Create a record-specific Indivo Document. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/records/{RECORD_ID}/documents/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.document_create_by_ext_id(record_id=None, external_id=None, pha_email=None[, body={}, headers={}, content_type=None]) Create a record-specific Indivo Document with an associated external id. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:put:`/records/{RECORD_ID}/documents/external/{PHA_EMAIL}/{EXTERNAL_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_document_label_ext(record_id=None, external_id=None, pha_email=None[, body={}, headers={}, content_type=None]) Set the label of a record-specific document, specified by external id. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:put:`/records/{RECORD_ID}/documents/external/{PHA_EMAIL}/{EXTERNAL_ID}/label` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_document_meta_ext(record_id=None, external_id=None, pha_email=None[, body={}, headers={}]) Fetch the metadata of a record-specific document identified by external id. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/documents/external/{PHA_EMAIL}/{EXTERNAL_ID}/meta` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.document_rels(record_id=None, document_id_1=None, document_id_0=None, rel=None[, body={}, headers={}, content_type=None]) Create a new relationship between two existing documents. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:put:`/records/{RECORD_ID}/documents/{DOCUMENT_ID_0}/rels/{REL}/{DOCUMENT_ID_1}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_specific_document(record_id=None, document_id=None[, body={}, headers={}]) Retrieve a record-specific document. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/documents/{DOCUMENT_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.document_carenets(record_id=None, document_id=None[, body={}, headers={}]) List all the carenets into which a document has been shared. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/documents/{DOCUMENT_ID}/carenets/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.carenet_document_delete(record_id=None, carenet_id=None, document_id=None[, headers={}]) Unshare a document from a given carenet. *headers* should contain any additional HTTP headers to pass in with the call. See :http:delete:`/records/{RECORD_ID}/documents/{DOCUMENT_ID}/carenets/{CARENET_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.carenet_document_placement(record_id=None, carenet_id=None, document_id=None[, body={}, headers={}, content_type=None]) Place a document into a given carenet. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:put:`/records/{RECORD_ID}/documents/{DOCUMENT_ID}/carenets/{CARENET_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.autoshare_revert(record_id=None, carenet_id=None, document_id=None[, body={}, headers={}, content_type=None]) Revert the document-sharing of a document in a carent to whatever rules are specified by autoshares. NOT IMPLEMENTED. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/records/{RECORD_ID}/documents/{DOCUMENT_ID}/carenets/{CARENET_ID}/autoshare-revert` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_document_label(record_id=None, document_id=None[, body={}, headers={}, content_type=None]) Set the label of a record-specific document. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:put:`/records/{RECORD_ID}/documents/{DOCUMENT_ID}/label` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_document_meta(record_id=None, document_id=None[, body={}, headers={}]) Fetch the metadata of a record-specific document. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/documents/{DOCUMENT_ID}/meta` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.update_document_meta(record_id=None, document_id=None[, body={}, headers={}, content_type=None]) Set metadata fields on a document. NOT IMPLEMENTED. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:put:`/records/{RECORD_ID}/documents/{DOCUMENT_ID}/meta` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.document_remove_nevershare(record_id=None, document_id=None[, headers={}]) Remove the nevershare flag from a document. *headers* should contain any additional HTTP headers to pass in with the call. See :http:delete:`/records/{RECORD_ID}/documents/{DOCUMENT_ID}/nevershare` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.document_set_nevershare(record_id=None, document_id=None[, body={}, headers={}, content_type=None]) Flag a document to never be shared, anywhere. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:put:`/records/{RECORD_ID}/documents/{DOCUMENT_ID}/nevershare` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.get_documents_by_rel(record_id=None, rel=None, document_id=None[, body={}, headers={}]) Get all documents related to the passed document_id by a relation of the passed relation-type. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/documents/{DOCUMENT_ID}/rels/{REL}/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.document_create_by_rel(record_id=None, rel=None, document_id=None[, body={}, headers={}, content_type=None]) Create a document and relate it to an existing document. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/records/{RECORD_ID}/documents/{DOCUMENT_ID}/rels/{REL}/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.document_create_by_rel_with_ext_id(record_id=None, rel=None, external_id=None, pha_email=None, document_id=None[, body={}, headers={}, content_type=None]) Create a document, assign it an external id, and relate it to an existing document. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/records/{RECORD_ID}/documents/{DOCUMENT_ID}/rels/{REL}/external/{PHA_EMAIL}/{EXTERNAL_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.document_create_by_rel_with_ext_id(record_id=None, rel=None, external_id=None, pha_email=None, document_id=None[, body={}, headers={}, content_type=None]) Create a document, assign it an external id, and relate it to an existing document. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:put:`/records/{RECORD_ID}/documents/{DOCUMENT_ID}/rels/{REL}/external/{PHA_EMAIL}/{EXTERNAL_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.document_version(record_id=None, document_id=None[, body={}, headers={}, content_type=None]) Create a new version of a record-specific document. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/records/{RECORD_ID}/documents/{DOCUMENT_ID}/replace` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.document_version_by_ext_id(record_id=None, external_id=None, pha_email=None, document_id=None[, body={}, headers={}, content_type=None]) Create a new version of a record-specific document and assign it an external id. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:put:`/records/{RECORD_ID}/documents/{DOCUMENT_ID}/replace/external/{PHA_EMAIL}/{EXTERNAL_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.document_set_status(record_id=None, document_id=None[, body={}, headers={}, content_type=None]) Set the status of a record-specific document. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/records/{RECORD_ID}/documents/{DOCUMENT_ID}/set-status` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.document_status_history(record_id=None, document_id=None[, body={}, headers={}]) List all changes to a document's status over time. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/documents/{DOCUMENT_ID}/status-history` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.document_versions(record_id=None, document_id=None[, body={}, headers={}]) Retrieve the versions of a document. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/documents/{DOCUMENT_ID}/versions/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_send_message(record_id=None, message_id=None[, body={}, headers={}, content_type=None]) Send a message to a record. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/records/{RECORD_ID}/inbox/{MESSAGE_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_message_attach(record_id=None, attachment_num=None, message_id=None[, body={}, headers={}, content_type=None]) Attach a document to an Indivo message. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/records/{RECORD_ID}/inbox/{MESSAGE_ID}/attachments/{ATTACHMENT_NUM}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_notify(record_id=None[, body={}, headers={}, content_type=None]) Send a notification about a record to all accounts authorized to be notified. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/records/{RECORD_ID}/notifications/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_notify(record_id=None[, body={}, headers={}, content_type=None]) Send a notification about a record to all accounts authorized to be notified. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/records/{RECORD_ID}/notify` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_get_owner(record_id=None[, body={}, headers={}]) Get the owner of a record. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/owner` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_set_owner(record_id=None[, body={}, headers={}, content_type=None]) Set the owner of a record. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/records/{RECORD_ID}/owner` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_set_owner(record_id=None[, body={}, headers={}, content_type=None]) Set the owner of a record. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:put:`/records/{RECORD_ID}/owner` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.report_ccr(record_id=None[, body={}, headers={}]) Export patient data as a Continuity of Care Record (CCR) document. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/reports/experimental/ccr` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.equipment_list(record_id=None[, body={}, headers={}]) List the equipment data for a given record. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/reports/minimal/equipment/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.measurement_list(record_id=None, lab_code=None[, body={}, headers={}]) List the measurement data for a given record. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/reports/minimal/measurements/{LAB_CODE}/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.procedure_list(record_id=None[, body={}, headers={}]) List the procedure data for a given record. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/reports/minimal/procedures/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.simple_clinical_notes_list(record_id=None[, body={}, headers={}]) List the simple_clinical_notes data for a given record. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/reports/minimal/simple-clinical-notes/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.generic_list(record_id=None, data_model=None[, body={}, headers={}]) List the Model data for a given record. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/reports/{DATA_MODEL}/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_shares(record_id=None[, body={}, headers={}]) List the shares of a record. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/shares/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_share_add(record_id=None[, body={}, headers={}, content_type=None]) Fully share a record with another account. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/records/{RECORD_ID}/shares/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_share_delete(record_id=None, other_account_id=None[, headers={}]) Undo a full record share with an account. *headers* should contain any additional HTTP headers to pass in with the call. See :http:delete:`/records/{RECORD_ID}/shares/{OTHER_ACCOUNT_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.record_share_delete(record_id=None, other_account_id=None[, body={}, headers={}, content_type=None]) Undo a full record share with an account. *body* should contain the data to send with the call. *headers* should contain any additional HTTP headers to pass in with the call. *content_type* should contain the MIME type of the data sent in the *body* argument. See :http:post:`/records/{RECORD_ID}/shares/{OTHER_ACCOUNT_ID}/delete` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.smart_generic(record_id=None, model_name=None[, body={}, headers={}]) SMART-compatible alias for the generic list view: returns data_models serialized as SMART RDF. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/{MODEL_NAME}/` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.smart_generic_instance(record_id=None, model_id=None, model_name=None[, body={}, headers={}]) Retrieve a specific instance of a SMART model. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/records/{RECORD_ID}/{MODEL_NAME}/{MODEL_ID}` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo. -------- .. py:method:: IndivoClient.get_version([body={}, headers={}]) Return the current version of Indivo. *body* should contain query parameters for the call. *headers* should contain any additional HTTP headers to pass in with the call. See :http:get:`/version` for valid parameters and the returned content. This call will return a tuple ``(response, content)``, where *response* is an instance of :py:class:`httplib2.Response`, and *content* is the raw content returned by Indivo.