Instruction:
Create a Python 3 function for
putting VMSS body. Can be used to create or update a scale set. E.g. call get_vmss(), make changes to the body, call put_vmss(). Args: access_token (str): A valid Azure authentication token. subscription_id (str): Azure subscription id. resource_group (str): Azure resource group name. vmss_name (str): Name of the new scale set. vmss_body (dictionary): Body containining Returns: HTTP response. JSON body of the virtual machine scale set properties.

Response:
def put_vmss(access_token, subscription_id, resource_group, vmss_name, vmss_body):
    '''Put VMSS body.

    Can be used to create or update a scale set.
    E.g. call get_vmss(), make changes to the body, call put_vmss().

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        resource_group (str): Azure resource group name.
        vmss_name (str): Name of the new scale set.
        vmss_body (dictionary): Body containining

    Returns:
        HTTP response. JSON body of the virtual machine scale set properties.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourceGroups/', resource_group,
                        '/providers/Microsoft.Compute/virtualMachineScaleSets/', vmss_name,
                        '?api-version=', COMP_API])
    body = json.dumps(vmss_body)
    return do_put(endpoint, body, access_token)


Instruction:
Make a summary of the following Python 3 code
def put_vmss_vm(access_token, subscription_id, resource_group, vmss_name, vm_id, vm_body):
    '''Update a VMSS VM. E.g. add/remove a data disk from a specifc VM in a scale set (preview).
       Note: Only currently enabled for Azure Canary regions.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        resource_group (str): Azure resource group name.
        vmss_name (str): Name of the new scale set.
        vm_id (int): VM ID of VM to update
        vmss_body (dictionary): Body containining

    Returns:
        HTTP response. JSON body of the virtual machine scale set VM properties.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourceGroups/', resource_group,
                        '/providers/Microsoft.Compute/virtualMachineScaleSets/', vmss_name,
                        '/virtualMachines/', str(vm_id),
                        '?api-version=', COMP_API])
    body = json.dumps(vm_body)
    return do_put(endpoint, body, access_token)

Response: Update a VMSS VM. Eg. add a data disk from a specifc VM in a scale set VM.


Instruction:
How would you code a function in Python 3 to
change the instance count of an existing VM Scale Set.

Response:
def scale_vmss(access_token, subscription_id, resource_group, vmss_name, capacity):
    '''Change the instance count of an existing VM Scale Set.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        resource_group (str): Azure resource group name.
        vmss_name (str): Name of the virtual machine scale set.
        capacity (int): New number of VMs.
    Returns:
        HTTP response.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourceGroups/', resource_group,
                        '/providers/Microsoft.Compute/virtualMachineScaleSets/', vmss_name,
                        '?api-version=', COMP_API])
    body = '{"sku":{"capacity":"' + str(capacity) + '"}}'
    return do_patch(endpoint, body, access_token)


Instruction:
Can you generate a brief explanation for the following Python 3 code
def start_vm(access_token, subscription_id, resource_group, vm_name):
    '''Start a virtual machine.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        resource_group (str): Azure resource group name.
        vm_name (str): Name of the virtual machine.

    Returns:
        HTTP response.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourceGroups/', resource_group,
                        '/providers/Microsoft.Compute/virtualMachines/',
                        vm_name,
                        '/start',
                        '?api-version=', COMP_API])
    return do_post(endpoint, '', access_token)

Response: Start a virtual machine.


Instruction:
Explain what the following Python 3 code does
def update_vm(access_token, subscription_id, resource_group, vm_name, body):
    '''Update a virtual machine with a new JSON body. E.g. do a GET, change something, call this.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        resource_group (str): Azure resource group name.
        vm_name (str): Name of the virtual machine.
        body (dict): JSON body of the VM.

    Returns:
        HTTP response.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourceGroups/', resource_group,
                        '/providers/Microsoft.Compute/virtualMachines/', vm_name,
                        '?api-version=', COMP_API])
    return do_put(endpoint, body, access_token)

Response: Update a virtual machine with a new JSON body. Eg. do a PUT call this.


Instruction:
Can you implement a function in Python 3 that
updates a VMSS with a new JSON body. Eg. do a PUT call this.

Response:
def update_vmss(access_token, subscription_id, resource_group, vmss_name, body):
    '''Update a VMSS with a new JSON body. E.g. do a GET, change something, call this.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        resource_group (str): Azure resource group name.
        vm_name (str): Name of the virtual machine.
        body (dict): JSON body of the VM scale set.

    Returns:
        HTTP response.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourceGroups/', resource_group,
                        '/providers/Microsoft.Compute/virtualMachineScaleSets/', vmss_name,
                        '?api-version=', COMP_API])
    return do_put(endpoint, body, access_token)


Instruction:
Make a summary of the following Python 3 code
def get_vm_ids_by_ud(access_token, subscription_id, resource_group, vmssname, updatedomain):
    '''look at VMSS VM instance view to get VM IDs by UD'''
    instance_viewlist = azurerm.list_vmss_vm_instance_view(access_token, subscription_id,
                                                           resource_group, vmssname)
    # print(json.dumps(instance_viewlist, sort_keys=False, indent=2, separators=(',', ': ')))

    # loop through the instance view list, and build the vm id list of VMs in
    # the matching UD
    udinstancelist = []
    for instance_view in instance_viewlist['value']:
        vmud = instance_view['properties']['instance_view']['platformUpdateDomain']
        if vmud == updatedomain:
            udinstancelist.append(instance_view['instanceId'])
    udinstancelist.sort()
    return udinstancelist

Response: look at VMSS VM instance view to get VM IDs by UD


Instruction:
Here you have a function in Python 3, explain what it does
def get_graph_token_from_msi():
    '''get a Microsoft Graph access token using Azure Cloud Shell's MSI_ENDPOINT.

        Notes:
        The auth token returned by this function is not an Azure auth token. Use it for querying
        the Microsoft Graph API.
        This function only works in an Azure cloud shell or virtual machine.

    Returns:
        A Microsoft Graph authentication token string.
    '''
    if 'ACC_CLOUD' in os.environ and 'MSI_ENDPOINT' in os.environ:
        endpoint = os.environ['MSI_ENDPOINT']
    else:
        return None

    headers = {'Metadata': 'true'}
    body = {"resource": 'https://' + GRAPH_RESOURCE_HOST + '/'}
    ret = requests.post(endpoint, headers=headers, data=body)
    return ret.json()['access_token']

Response: get a Microsoft Graph authentication token using Microsoft Cloud Shell s MSI_ENDPOINT


Instruction:
How would you implement a function in Python 3 that
gets the object ID for the Graph user who owns the access token.

Response:
def get_object_id_from_graph(access_token=None):
    '''Return the object ID for the Graph user who owns the access token.

    Args:
        access_token (str): A Microsoft Graph access token. (Not an Azure access token.)
                            If not provided, attempt to get it from MSI_ENDPOINT.

    Returns:
        An object ID string for a user or service principal.
    '''
    if access_token is None:
        access_token = get_graph_token_from_msi()

    endpoint = 'https://' + GRAPH_RESOURCE_HOST + '/v1.0/me/'
    headers = {'Authorization': 'Bearer ' + access_token, 'Host': GRAPH_RESOURCE_HOST}
    ret = requests.get(endpoint, headers=headers)
    return ret.json()['id']


Instruction:
Can you generate a brief explanation for the following Python 3 code
def get_subscription_from_cli(name=None):
    '''Get the default, or named, subscription id from CLI's local cache.

    Args:
        name (str): Optional subscription name. If this is set, the subscription id of the named
           subscription is returned from the CLI cache if present. If not set, the subscription id
           of the default subscription is returned.

    Returns:
        Azure subscription ID string.

    Requirements:
        User has run 'az login' once, or is in Azure Cloud Shell.
    '''
    home = os.path.expanduser('~')
    azure_profile_path = home + os.sep + '.azure' + os.sep + 'azureProfile.json'
    if os.path.isfile(azure_profile_path) is False:
        print('Error from get_subscription_from_cli(): Cannot find ' +
              azure_profile_path)
        return None
    with io.open(azure_profile_path, 'r', encoding='utf-8-sig') as azure_profile_fd:
        azure_profile = json.load(azure_profile_fd)
    for subscription_info in azure_profile['subscriptions']:
        if (name is None and subscription_info['isDefault'] is True) or \
                                            subscription_info['name'] == name:
            return subscription_info['id']
    return None

Response: Get the default or named subscription id from CLI s local cache.


Instruction:
Make a summary of the following Python 3 code
def list_locations(access_token, subscription_id):
    '''List available locations for a subscription.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.

    Returns:
        HTTP response. JSON list of locations.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/locations?api-version=', BASE_API])
    return do_get(endpoint, access_token)

Response: List available locations for a subscription.


Instruction:
Write a Python 3 script for
creating a new Cosmos DB account in the named resource group with the named location.

Response:
def create_cosmosdb_account(access_token, subscription_id, rgname, account_name, location,
                            cosmosdb_kind):
    '''Create a new Cosmos DB account in the named resource group, with the named location.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        rgname (str): Azure resource group name.
        account_name (str): Name of the new Cosmos DB account.
        location (str): Azure data center location. E.g. westus.
        cosmosdb_kind (str): Database type. E.g. GlobalDocumentDB.

    Returns:
        HTTP response. JSON body of storage account properties.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourcegroups/', rgname,
                        '/providers/Microsoft.DocumentDB/databaseAccounts/', account_name,
                        '?api-version=', COSMOSDB_API])

    cosmosdb_body = {'location': location,
                     'kind': cosmosdb_kind,
                     'properties': {'databaseAccountOfferType': 'Standard',
                                    'locations': [{'failoverPriority': 0,
                                                   'locationName': location}]}}
    body = json.dumps(cosmosdb_body)
    return do_put(endpoint, body, access_token)


Instruction:
Write a Python 3 function that can
get the access keys for the specified Cosmos DB account.

Response:
def get_cosmosdb_account_keys(access_token, subscription_id, rgname, account_name):
    '''Get the access keys for the specified Cosmos DB account.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        rgname (str): Azure resource group name.
        account_name (str): Name of the Cosmos DB account.

    Returns:
        HTTP response. JSON body of Cosmos DB account keys.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourcegroups/', rgname,
                        '/providers/Microsoft.DocumentDB/databaseAccounts/', account_name,
                        '/listKeys',
                        '?api-version=', COSMOSDB_API])
    return do_post(endpoint, '', access_token)


Instruction:
Given the following Python 3 function, write the documentation
def create_keyvault(access_token, subscription_id, rgname, vault_name, location,
                    template_deployment=True, tenant_id=None, object_id=None):
    '''Create a new key vault in the named resource group.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        rgname (str): Azure resource group name.
        vault_name (str): Name of the new key vault.
        location (str): Azure data center location. E.g. westus2.
        template_deployment (boolean): Whether to allow deployment from template.
        tenant_id (str): Optionally specify a tenant ID (otherwise picks first response) from
                         ist_tenants().
        object_id (str): Optionally specify an object ID representing user or principal for the
                         access policy.

    Returns:
        HTTP response. JSON body of key vault properties.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourcegroups/', rgname,
                        '/providers/Microsoft.KeyVault/vaults/', vault_name,
                        '?api-version=', KEYVAULT_API])
    # get tenant ID if not specified
    if tenant_id is None:
        ret = list_tenants(access_token)
        tenant_id = ret['value'][0]['tenantId']
    # if object_id is None:
    access_policies = [{'tenantId': tenant_id, 'objectId': object_id,
                        'permissions': {
                            'keys': ['get', 'create', 'delete', 'list', 'update', 'import',
                                     'backup', 'restore', 'recover'],
                            'secrets': ['get', 'list', 'set', 'delete', 'backup', 'restore',
                                        'recover'],
                            'certificates': ['get', 'list', 'delete', 'create', 'import', 'update',
                                             'managecontacts', 'getissuers', 'listissuers',
                                             'setissuers', 'deleteissuers', 'manageissuers',
                                             'recover'],
                            'storage': ['get', 'list', 'delete', 'set', 'update', 'regeneratekey',
                                        'setsas', 'listsas', 'getsas', 'deletesas']
                        }}]
    vault_properties = {'tenantId': tenant_id, 'sku': {'family': 'A', 'name': 'standard'},
                        'enabledForTemplateDeployment': template_deployment,
                        'accessPolicies': access_policies}
    vault_body = {'location': location, 'properties': vault_properties}
    body = json.dumps(vault_body)
    return do_put(endpoint, body, access_token)

Response: Create a new key vault in the named resource group.


Instruction:
Write a Python 3 script to
delete a key vault in the named resource group.

Response:
def delete_keyvault(access_token, subscription_id, rgname, vault_name):
    '''Deletes a key vault in the named resource group.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        rgname (str): Azure resource group name.
        vault_name (str): Name of the new key vault.

    Returns:
        HTTP response. 200 OK.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourcegroups/', rgname,
                        '/providers/Microsoft.KeyVault/vaults/', vault_name,
                        '?api-version=', KEYVAULT_API])
    return do_delete(endpoint, access_token)


Instruction:
How would you explain what the following Python 3 function does
def get_keyvault(access_token, subscription_id, rgname, vault_name):
    '''Gets details about the named key vault.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        rgname (str): Azure resource group name.
        vault_name (str): Name of the key vault.

    Returns:
        HTTP response. JSON body of key vault properties.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourcegroups/', rgname,
                        '/providers/Microsoft.KeyVault/vaults/', vault_name,
                        '?api-version=', KEYVAULT_API])
    return do_get(endpoint, access_token)

Response: Gets details about the named key vault.


Instruction:
How would you explain what the following Python 3 function does
def list_keyvaults(access_token, subscription_id, rgname):
    '''Lists key vaults in the named resource group.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        rgname (str): Azure resource group name.

    Returns:
        HTTP response. 200 OK.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourcegroups/', rgname,
                        '/providers/Microsoft.KeyVault/vaults',
                        '?api-version=', KEYVAULT_API])
    return do_get_next(endpoint, access_token)

Response: Lists key vaults in the named resource group.


Instruction:
Can you tell what is the following Python 3 function doing
def list_keyvaults_sub(access_token, subscription_id):
    '''Lists key vaults belonging to this subscription.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.

    Returns:
        HTTP response. 200 OK.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/providers/Microsoft.KeyVault/vaults',
                        '?api-version=', KEYVAULT_API])
    return do_get_next(endpoint, access_token)

Response: Lists key vaults belonging to this subscription.


Instruction:
Write a Python 3 script for
adding a secret to a key vault using the key vault URI. Creates a new version if the secret already exists.

Response:
def set_keyvault_secret(access_token, vault_uri, secret_name, secret_value):
    '''Adds a secret to a key vault using the key vault URI.
       Creates a new version if the secret already exists.

    Args:
        access_token (str): A valid Azure authentication token.
        vault_uri (str): Vault URI e.g. https://myvault.vault.azure.net.
        secret_name (str): Name of the secret to add.
        secret_value (str): Value of the secret.

    Returns:
        HTTP response. 200 OK.
    '''
    endpoint = ''.join([vault_uri,
                    '/secrets/', secret_name,
                    '?api-version=', '7.0'])
    current_time = datetime.datetime.now().isoformat()
    attributes = {'created': current_time,
                  'enabled': True,
                  'exp': None,
                  'nbf': None,
                  'recoveryLevel': 'Purgeable',
                  'updated': current_time}
    secret_body = {'attributes': attributes,
                   'contentType': None,
                   'kid': None,
                   'managed': None,
                   'tags': {'file-encoding': 'utf-8'},
                   'value': secret_value}
    body = json.dumps(secret_body)
    print(body)
    return do_put(endpoint, body, access_token)


Instruction:
Here you have a function in Python 3, explain what it does
def delete_keyvault_secret(access_token, vault_uri, secret_name):
    '''Deletes a secret from a key vault using the key vault URI.

    Args:
        access_token (str): A valid Azure authentication token.
        vault_uri (str): Vault URI e.g. https://myvault.azure.net.
        secret_name (str): Name of the secret to add.

    Returns:
        HTTP response. 200 OK.
    '''
    endpoint = ''.join([vault_uri,
                    '/secrets/', secret_name,
                    '?api-version=', '7.0'])
    return do_delete(endpoint, access_token)

Response: Deletes a secret from a key vault using the key vault URI.


Instruction:
Can you generate the documentation for the following Python 3 function
def create_autoscale_rule(subscription_id, resource_group, vmss_name, metric_name, operator,
                          threshold, direction, change_count, time_grain='PT1M',
                          time_window='PT5M', cool_down='PT1M'):
    '''Create a new autoscale rule - pass the output in a list to create_autoscale_setting().

    Args:
        subscription_id (str): Azure subscription id.
        resource_group (str): Azure resource group name.
        vmss_name (str): Name of scale set to apply scale events to.
        metric_name (str): Name of metric being evaluated.
        operator (str): Operator to evaluate. E.g. "GreaterThan".
        threshold (str): Threshold to trigger action.
        direction (str): Direction of action. E.g. Increase.
        change_count (str): How many to increase or decrease by.
        time_grain (str): Optional. Measurement granularity. Default 'PT1M'.
        time_window (str): Optional. Range of time to collect data over. Default 'PT5M'.
        cool_down (str): Optional. Time to wait after last scaling action. ISO 8601 format.
            Default 'PT1M'.
    Returns:
        HTTP response. JSON body of autoscale setting.
    '''
    metric_trigger = {'metricName': metric_name}
    metric_trigger['metricNamespace'] = ''
    metric_trigger['metricResourceUri'] = '/subscriptions/' + subscription_id + \
        '/resourceGroups/' + resource_group + \
        '/providers/Microsoft.Compute/virtualMachineScaleSets/' + vmss_name
    metric_trigger['timeGrain'] = time_grain
    metric_trigger['statistic'] = 'Average'
    metric_trigger['timeWindow'] = time_window
    metric_trigger['timeAggregation'] = 'Average'
    metric_trigger['operator'] = operator
    metric_trigger['threshold'] = threshold
    scale_action = {'direction': direction}
    scale_action['type'] = 'ChangeCount'
    scale_action['value'] = str(change_count)
    scale_action['cooldown'] = cool_down
    new_rule = {'metricTrigger': metric_trigger}
    new_rule['scaleAction'] = scale_action
    return new_rule

Response: Creates a new autoscale rule for the given resource group and metric.


Instruction:
How would you code a function in Python 3 to
create a new autoscale setting for a resource group.

Response:
def create_autoscale_setting(access_token, subscription_id, resource_group, setting_name,
                             vmss_name, location, minval, maxval, default, autoscale_rules,
                             notify=None):
    '''Create a new autoscale setting for a scale set.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        resource_group (str): Azure resource group name.
        setting_name (str): Name of the autoscale setting.
        vmss_name (str): Name of scale set to apply scale events to.
        location (str): Azure data center location. E.g. westus.
        minval (int): Minimum number of VMs.
        maxval (int): Maximum number of VMs.
        default (int): Default VM number when no data available.
        autoscale_rules (list): List of outputs from create_autoscale_rule().
        notify (str): Optional.
    Returns:
        HTTP response. JSON body of autoscale setting.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourceGroups/', resource_group,
                        '/providers/microsoft.insights/autoscaleSettings/', setting_name,
                        '?api-version=', INSIGHTS_API])
    autoscale_setting = {'location': location}
    profile = {'name': 'Profile1'}
    capacity = {'minimum': str(minval)}
    capacity['maximum'] = str(maxval)
    capacity['default'] = str(default)
    profile['capacity'] = capacity
    profile['rules'] = autoscale_rules
    profiles = [profile]
    properties = {'name': setting_name}
    properties['profiles'] = profiles
    properties['targetResourceUri'] = '/subscriptions/' + subscription_id + \
        '/resourceGroups/' + resource_group + \
        '/providers/Microsoft.Compute/virtualMachineScaleSets/' + vmss_name
    properties['enabled'] = True
    if notify is not None:
        notification = {'operation': 'Scale'}
        email = {'sendToSubscriptionAdministrato': False}
        email['sendToSubscriptionCoAdministrators'] = False
        email['customEmails'] = [notify]
        notification = {'email': email}
        properties['notifications'] = [notification]
    autoscale_setting['properties'] = properties
    body = json.dumps(autoscale_setting)
    return do_put(endpoint, body, access_token)


Instruction:
Here you have a function in Python 3, explain what it does
def list_autoscale_settings(access_token, subscription_id):
    '''List the autoscale settings in a subscription.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.

    Returns:
        HTTP response. JSON body of autoscale settings.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/providers/microsoft.insights/',
                        '/autoscaleSettings?api-version=', INSIGHTS_API])
    return do_get(endpoint, access_token)

Response: List the autoscale settings in a subscription.


Instruction:
Given the following Python 3 function, write the documentation
def list_insights_components(access_token, subscription_id, resource_group):
    '''List the Microsoft Insights components in a resource group.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        resource_group (str): Azure resource group name.

    Returns:
        HTTP response. JSON body of components.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourceGroups/', resource_group,
                        '/providers/microsoft.insights/',
                        '/components?api-version=', INSIGHTS_COMPONENTS_API])
    return do_get(endpoint, access_token)

Response: List Microsoft Insights components in a resource group.


Instruction:
How would you explain what the following Python 3 function does
def list_metric_defs_for_resource(access_token, subscription_id, resource_group,
                                  resource_provider, resource_type, resource_name):
    '''List the monitoring metric definitions for a resource.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        resource_group (str): Azure resource group name.
        resource_provider (str): Type of resource provider.
        resource_type (str): Type of resource.
        resource_name (str): Name of resource.

    Returns:
        HTTP response. JSON body of metric definitions.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourceGroups/', resource_group,
                        '/providers/', resource_provider,
                        '/', resource_type,
                        '/', resource_name,
                        '/providers/microsoft.insights',
                        '/metricdefinitions?api-version=', INSIGHTS_METRICS_API])
    return do_get(endpoint, access_token)

Response: List the monitoring metric definitions for a resource.


Instruction:
Write a Python 3 script to
get the monitoring metrics for a resource.

Response:
def get_metrics_for_resource(access_token, subscription_id, resource_group, resource_provider,
                             resource_type, resource_name):
    '''Get the monitoring metrics for a resource.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        resource_group (str): Azure resource group name.
        resource_type (str): Type of resource.
        resource_name (str): Name of resource.

    Returns:
        HTTP response. JSON body of resource metrics.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourceGroups/', resource_group,
                        '/providers/', resource_provider,
                        '/', resource_type,
                        '/', resource_name,
                        '/providers/microsoft.insights',
                        '/metrics?api-version=', INSIGHTS_PREVIEW_API])
    return do_get(endpoint, access_token)


Instruction:
Explain what the following Python 3 code does
def get_events_for_subscription(access_token, subscription_id, start_timestamp):
    '''Get the insights evens for a subsctipion since the specific timestamp.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        start_timestamp (str): timestamp to get events from. E.g. '2017-05-01T00:00:00.0000000Z'.
    Returns:
        HTTP response. JSON body of insights events.

    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/providers/microsoft.insights/eventtypes/management/values?api-version=',
                        INSIGHTS_API, '&$filter=eventTimestamp ge \'', start_timestamp, '\''])
    return do_get(endpoint, access_token)

Response: Get the insights evens for a subscription since the specific timestamp.


Instruction:
Make a summary of the following Python 3 code
def deploy_template(access_token, subscription_id, resource_group, deployment_name, template,
                    parameters):
    '''Deploy a template referenced by a JSON string, with parameters as a JSON string.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        resource_group (str): Azure resource group name.
        deployment_name (str): A name you give to the deployment.
        template (str): String representatipn of a JSON template body.
        parameters (str): String representation of a JSON template parameters body.

    Returns:
        HTTP response.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourcegroups/', resource_group,
                        '/providers/Microsoft.Resources/deployments/', deployment_name,
                        '?api-version=', DEPLOYMENTS_API])
    properties = {'template': template}
    properties['mode'] = 'Incremental'
    properties['parameters'] = parameters
    template_body = {'properties': properties}
    body = json.dumps(template_body)
    return do_put(endpoint, body, access_token)

Response: Deploy a template referenced by a JSON string with parameters as a JSON string.


Instruction:
Can you implement a function in Python 3 that
deploys a template referenced by a URI with parameters as a JSON string.

Response:
def deploy_template_uri(access_token, subscription_id, resource_group, deployment_name,
                        template_uri, parameters):
    '''Deploy a template referenced by a URI, with parameters as a JSON string.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        resource_group (str): Azure resource group name.
        deployment_name (str): A name you give to the deployment.
        template_uri (str): URI which points to a JSON template (e.g. github raw location).
        parameters (str): String representation of a JSON template parameters body.

    Returns:
        HTTP response.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourcegroups/', resource_group,
                        '/providers/Microsoft.Resources/deployments/', deployment_name,
                        '?api-version=', DEPLOYMENTS_API])
    properties = {'templateLink': {'uri': template_uri}}
    properties['mode'] = 'Incremental'
    properties['parameters'] = parameters
    template_body = {'properties': properties}
    body = json.dumps(template_body)
    return do_put(endpoint, body, access_token)


Instruction:
Make a summary of the following Python 3 code
def deploy_template_uri_param_uri(access_token, subscription_id, resource_group, deployment_name,
                                  template_uri, parameters_uri):
    '''Deploy a template with both template and parameters referenced by URIs.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        resource_group (str): Azure resource group name.
        deployment_name (str): A name you give to the deployment.
        template_uri (str): URI which points to a JSON template (e.g. github raw location).
        parameters_uri (str): URI which points to a JSON parameters file (e.g. github raw location).

    Returns:
        HTTP response.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourcegroups/', resource_group,
                        '/providers/Microsoft.Resources/deployments/', deployment_name,
                        '?api-version=', DEPLOYMENTS_API])
    properties = {'templateLink': {'uri': template_uri}}
    properties['mode'] = 'Incremental'
    properties['parametersLink'] = {'uri': parameters_uri}
    template_body = {'properties': properties}
    body = json.dumps(template_body)
    return do_put(endpoint, body, access_token)

Response: Deploy a template with both template and parameters referenced by URIs.


Instruction:
Can you generate the documentation for the following Python 3 function
def attach_model(subscription, rgname, vmssvm_model, diskname, lun):
    '''Attach a data disk to a VMSS VM model'''
    disk_id = '/subscriptions/' + subscription + '/resourceGroups/' + rgname + \
        '/providers/Microsoft.Compute/disks/' + diskname
    disk_model = {'lun': lun, 'createOption': 'Attach', 'caching': 'None',
                  'managedDisk': {'storageAccountType': 'Standard_LRS', 'id': disk_id}}
    vmssvm_model['properties']['storageProfile']['dataDisks'].append(
        disk_model)
    return vmssvm_model

Response: Attach a data disk to a VMSS VM model


Instruction:
Can you implement a function in Python 3 that
detaches a data disk from a VMSS VM model

Response:
def detach_model(vmssvm_model, lun):
    '''Detach a data disk from a VMSS VM model'''
    data_disks = vmssvm_model['properties']['storageProfile']['dataDisks']
    data_disks[:] = [disk for disk in data_disks if disk.get('lun') != lun]
    vmssvm_model['properties']['storageProfile']['dataDisks'] = data_disks
    return vmssvm_model


Instruction:
Can you generate a brief explanation for the following Python 3 code
def get_access_token(tenant_id, application_id, application_secret):
    '''get an Azure access token using the adal library.

    Args:
        tenant_id (str): Tenant id of the user's account.
        application_id (str): Application id of a Service Principal account.
        application_secret (str): Application secret (password) of the Service Principal account.

    Returns:
        An Azure authentication token string.
    '''
    context = adal.AuthenticationContext(
        get_auth_endpoint() + tenant_id, api_version=None)
    token_response = context.acquire_token_with_client_credentials(
        get_resource_endpoint(), application_id, application_secret)
    return token_response.get('accessToken')

Response: get an Azure access token using the adal library.


Instruction:
Implement a function in Python 3 to
get an Azure authentication token from CLI s local cache.

Response:
def get_access_token_from_cli():
    '''Get an Azure authentication token from CLI's cache.

    Will only work if CLI local cache has an unexpired auth token (i.e. you ran 'az login'
        recently), or if you are running in Azure Cloud Shell (aka cloud console)

    Returns:
        An Azure authentication token string.
    '''

    # check if running in cloud shell, if so, pick up token from MSI_ENDPOINT
    if 'ACC_CLOUD' in os.environ and 'MSI_ENDPOINT' in os.environ:
        endpoint = os.environ['MSI_ENDPOINT']
        headers = {'Metadata': 'true'}
        body = {"resource": "https://management.azure.com/"}
        ret = requests.post(endpoint, headers=headers, data=body)
        return ret.json()['access_token']

    else: # not running cloud shell
        home = os.path.expanduser('~')
        sub_username = ""

        # 1st identify current subscription
        azure_profile_path = home + os.sep + '.azure' + os.sep + 'azureProfile.json'
        if os.path.isfile(azure_profile_path) is False:
            print('Error from get_access_token_from_cli(): Cannot find ' + azure_profile_path)
            return None
        with codecs.open(azure_profile_path, 'r', 'utf-8-sig') as azure_profile_fd:
            subs = json.load(azure_profile_fd)
        for sub in subs['subscriptions']:
            if sub['isDefault'] == True:
                sub_username = sub['user']['name']
        if sub_username == "":
            print('Error from get_access_token_from_cli(): Default subscription not found in ' +  \
                azure_profile_path)
            return None

        # look for acces_token
        access_keys_path = home + os.sep + '.azure' + os.sep + 'accessTokens.json'
        if os.path.isfile(access_keys_path) is False:
            print('Error from get_access_token_from_cli(): Cannot find ' + access_keys_path)
            return None
        with open(access_keys_path, 'r') as access_keys_fd:
            keys = json.load(access_keys_fd)

        # loop through accessTokens.json until first unexpired entry found
        for key in keys:
            if key['userId'] == sub_username:
                if 'accessToken' not in keys[0]:
                    print('Error from get_access_token_from_cli(): accessToken not found in ' + \
                        access_keys_path)
                    return None
                if 'tokenType' not in keys[0]:
                    print('Error from get_access_token_from_cli(): tokenType not found in ' + \
                        access_keys_path)
                    return None
                if 'expiresOn' not in keys[0]:
                    print('Error from get_access_token_from_cli(): expiresOn not found in ' + \
                        access_keys_path)
                    return None
                expiry_date_str = key['expiresOn']

                # check date and skip past expired entries
                if 'T' in expiry_date_str:
                    exp_date = dt.strptime(key['expiresOn'], '%Y-%m-%dT%H:%M:%S.%fZ')
                else:
                    exp_date = dt.strptime(key['expiresOn'], '%Y-%m-%d %H:%M:%S.%f')
                if exp_date < dt.now():
                    continue
                else:
                    return key['accessToken']

        # if dropped out of the loop, token expired
        print('Error from get_access_token_from_cli(): token expired. Run \'az login\'')
        return None


Instruction:
Implement a function in Python 3 to
list available VM image offers from a publisher.

Response:
def list_offers(access_token, subscription_id, location, publisher):
    '''List available VM image offers from a publisher.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        location (str): Azure data center location. E.g. westus.
        publisher (str): Publisher name, e.g. Canonical.

    Returns:
        HTTP response with JSON list of image offers.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/providers/Microsoft.Compute/',
                        'locations/', location,
                        '/publishers/', publisher,
                        '/artifacttypes/vmimage/offers?api-version=', COMP_API])
    return do_get(endpoint, access_token)


Instruction:
Can you write a function in Python 3 where it
lists available VM image skus for a publisher offer.

Response:
def list_skus(access_token, subscription_id, location, publisher, offer):
    '''List available VM image skus for a publisher offer.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        location (str): Azure data center location. E.g. westus.
        publisher (str): VM image publisher. E.g. MicrosoftWindowsServer.
        offer (str): VM image offer. E.g. WindowsServer.

    Returns:
        HTTP response with JSON list of skus.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/providers/Microsoft.Compute/',
                        'locations/', location,
                        '/publishers/', publisher,
                        '/artifacttypes/vmimage/offers/', offer,
                        '/skus?api-version=', COMP_API])
    return do_get(endpoint, access_token)


Instruction:
Create a Python 3 function to
list available versions for a given publisher s sku.

Response:
def list_sku_versions(access_token, subscription_id, location, publisher, offer, sku):
    '''List available versions for a given publisher's sku.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        location (str): Azure data center location. E.g. westus.
        publisher (str): VM image publisher. E.g. MicrosoftWindowsServer.
        offer (str): VM image offer. E.g. WindowsServer.
        sku (str): VM image sku. E.g. 2016-Datacenter.

    Returns:
        HTTP response with JSON list of versions.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/providers/Microsoft.Compute/',
                        'locations/', location,
                        '/publishers/', publisher,
                        '/artifacttypes/vmimage/offers/', offer,
                        '/skus/', sku,
                        '/versions?api-version=', COMP_API])
    return do_get(endpoint, access_token)


Instruction:
Here you have a function in Python 3, explain what it does
def create_container_definition(container_name, image, port=80, cpu=1.0, memgb=1.5,
                                environment=None):
    '''Makes a python dictionary of container properties.

    Args:
        container_name: The name of the container.
        image (str): Container image string. E.g. nginx.
        port (int): TCP port number. E.g. 8080.
        cpu (float): Amount of CPU to allocate to container. E.g. 1.0.
        memgb (float): Memory in GB to allocate to container. E.g. 1.5.
        environment (list): A list of [{'name':'envname', 'value':'envvalue'}].
        Sets environment variables in the container.

    Returns:
        A Python dictionary of container properties, pass a list of these to
        create_container_group().
    '''
    container = {'name': container_name}
    container_properties = {'image': image}
    container_properties['ports'] = [{'port': port}]
    container_properties['resources'] = {
        'requests': {'cpu': cpu, 'memoryInGB': memgb}}
    container['properties'] = container_properties

    if environment is not None:
        container_properties['environmentVariables'] = environment
    return container

Response: Makes a python dictionary of container properties.


Instruction:
Implement a Python 3 function for
creating a new container group with a list of containers specifified by container_list.

Response:
def create_container_instance_group(access_token, subscription_id, resource_group,
                                    container_group_name, container_list, location,
                                    ostype='Linux', port=80, iptype='public'):
    '''Create a new container group with a list of containers specifified by container_list.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        resource_group (str): Azure resource group name.
        container_group_name (str): Name of container instance group.
        container_list (list): A list of container properties. Use create_container_definition to
        create each container property set.
        location (str): Azure data center location. E.g. westus.
        ostype (str): Container operating system type. Linux or Windows.
        port (int): TCP port number. E.g. 8080.
        iptype (str): Type of IP address. E.g. public.

    Returns:
        HTTP response with JSON body of container group.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourcegroups/', resource_group,
                        '/providers/Microsoft.ContainerInstance/ContainerGroups/',
                        container_group_name,
                        '?api-version=', CONTAINER_API])
    container_group_body = {'location': location}
    properties = {'osType': ostype}
    properties['containers'] = container_list
    ipport = {'protocol': 'TCP'}
    ipport['port'] = port
    ipaddress = {'ports': [ipport]}
    ipaddress['type'] = iptype
    properties['ipAddress'] = ipaddress
    container_group_body['properties'] = properties
    body = json.dumps(container_group_body)
    return do_put(endpoint, body, access_token)


Instruction:
How would you explain what the following Python 3 function does
def delete_container_instance_group(access_token, subscription_id, resource_group,
                                    container_group_name):
    '''Delete a container group from a resource group.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        resource_group (str): Azure resource group name.
        container_group_name (str): Name of container instance group.

    Returns:
        HTTP response.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourcegroups/', resource_group,
                        '/providers/Microsoft.ContainerInstance/ContainerGroups/',
                        container_group_name,
                        '?api-version=', CONTAINER_API])
    return do_delete(endpoint, access_token)

Response: Delete a container group from a resource group.


Instruction:
Can you tell what is the following Python 3 function doing
def get_container_instance_group(access_token, subscription_id, resource_group,
                                 container_group_name):
    '''Get the JSON definition of a container group.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        resource_group (str): Azure resource group name.
        container_group_name (str): Name of container instance group.

    Returns:
        HTTP response. JSON body of container group.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourcegroups/', resource_group,
                        '/providers/Microsoft.ContainerInstance/ContainerGroups/',
                        container_group_name,
                        '?api-version=', CONTAINER_API])
    return do_get(endpoint, access_token)

Response: Get the JSON definition of a container group.


Instruction:
Given the following Python 3 function, write the documentation
def get_container_instance_logs(access_token, subscription_id, resource_group, container_group_name,
                                container_name=None):
    '''Get the container logs for containers in a container group.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        resource_group (str): Azure resource group name.
        container_group_name (str): Name of container instance group.
        container_name (str): Optional name of a container in the group.

    Returns:
        HTTP response. Container logs.
    '''
    if container_name is None:
        container_name = container_group_name
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourcegroups/', resource_group,
                        '/providers/Microsoft.ContainerInstance/ContainerGroups/',
                        container_group_name,
                        '/containers/', container_name, '/logs?api-version=', CONTAINER_API])
    return do_get(endpoint, access_token)

Response: Get the container logs for containers in a container group.


Instruction:
Can you write a function in Python 3 where it
lists the container groups in a resource group.

Response:
def list_container_instance_groups(access_token, subscription_id, resource_group):
    '''List the container groups in a resource group.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        resource_group (str): Azure resource group name.

    Returns:
        HTTP response. JSON list of container groups and their properties.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourcegroups/', resource_group,
                        '/providers/Microsoft.ContainerInstance/ContainerGroups',
                        '?api-version=', CONTAINER_API])
    return do_get(endpoint, access_token)


Instruction:
Make a summary of the following Python 3 code
def list_container_instance_groups_sub(access_token, subscription_id):
    '''List the container groups in a subscription.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.

    Returns:
        HTTP response. JSON list of container groups and their properties.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/providers/Microsoft.ContainerInstance/ContainerGroups',
                        '?api-version=', CONTAINER_API])
    return do_get(endpoint, access_token)

Response: List the container groups in a subscription.


Instruction:
Create a Python 3 function to
create a resource group in the specified location.

Response:
def create_resource_group(access_token, subscription_id, rgname, location):
    '''Create a resource group in the specified location.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        rgname (str): Azure resource group name.
        location (str): Azure data center location. E.g. westus.

    Returns:
        HTTP response. JSON body.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourcegroups/', rgname,
                        '?api-version=', RESOURCE_API])
    rg_body = {'location': location}
    body = json.dumps(rg_body)
    return do_put(endpoint, body, access_token)


Instruction:
Create a Python 3 function to
delete the named resource group.

Response:
def delete_resource_group(access_token, subscription_id, rgname):
    '''Delete the named resource group.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        rgname (str): Azure resource group name.

    Returns:
        HTTP response.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourcegroups/', rgname,
                        '?api-version=', RESOURCE_API])
    return do_delete(endpoint, access_token)


Instruction:
Can you create a Python 3 function that
captures the specified resource group as a template.

Response:
def export_template(access_token, subscription_id, rgname):
    '''Capture the specified resource group as a template

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        rgname (str): Azure resource group name.

    Returns:
        HTTP response. JSON body.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourcegroups/', rgname,
                        '/exportTemplate',
                        '?api-version=', RESOURCE_API])
    rg_body = {'options':'IncludeParameterDefaultValue', 'resources':['*']}
    body = json.dumps(rg_body)
    return do_post(endpoint, body, access_token)


Instruction:
Create a Python 3 function for
getting details about the named resource group.

Response:
def get_resource_group(access_token, subscription_id, rgname):
    '''Get details about the named resource group.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.
        rgname (str): Azure resource group name.

    Returns:
        HTTP response. JSON body.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourceGroups/', rgname,
                        '?api-version=', RESOURCE_API])
    return do_get(endpoint, access_token)


Instruction:
How would you code a function in Python 3 to
list the resource groups in a subscription.

Response:
def list_resource_groups(access_token, subscription_id):
    '''List the resource groups in a subscription.

    Args:
        access_token (str): A valid Azure authentication token.
        subscription_id (str): Azure subscription id.

    Returns:
        HTTP response.
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourceGroups/',
                        '?api-version=', RESOURCE_API])
    return do_get(endpoint, access_token)


Instruction:
Can you write a function in Python 3 where it
writes your forwards methods here.

Response:
def forwards(self, orm):
        "Write your forwards methods here."
        # Note: Don't use "from appname.models import ModelName".
        # Use orm.ModelName to refer to models in this application,
        # and orm['appname.ModelName'] for models in other applications.
        for coupon in orm['coupons.Coupon'].objects.all():
            if coupon.user is not None or coupon.redeemed_at is not None:
                orm['coupons.CouponUser'].objects.create(
                    coupon=coupon,
                    user=coupon.user,
                    redeemed_at=coupon.redeemed_at
                )


Instruction:
Can you generate the documentation for the following Python 3 function
def get(self, requirement):
        filename = self.generate_filename(requirement)
        for backend in list(self.backends):
            try:
                pathname = backend.get(filename)
                if pathname is not None:
                    return pathname
            except CacheBackendDisabledError as e:
                logger.debug("Disabling %s because it requires configuration: %s", backend, e)
                self.backends.remove(backend)
            except Exception as e:
                logger.exception("Disabling %s because it failed: %s", backend, e)
                self.backends.remove(backend)

Response: Get a distribution archive from any of the available caches.


Instruction:
Write a Python 3 script for
storing a distribution archive in all of the available caches.

Response:
def put(self, requirement, handle):
        """
        Store a distribution archive in all of the available caches.

        :param requirement: A :class:`.Requirement` object.
        :param handle: A file-like object that provides access to the
                       distribution archive.
        """
        filename = self.generate_filename(requirement)
        for backend in list(self.backends):
            handle.seek(0)
            try:
                backend.put(filename, handle)
            except CacheBackendDisabledError as e:
                logger.debug("Disabling %s because it requires configuration: %s", backend, e)
                self.backends.remove(backend)
            except Exception as e:
                logger.exception("Disabling %s because it failed: %s", backend, e)
                self.backends.remove(backend)


Instruction:
Here you have a function in Python 3, explain what it does
def generate_filename(self, requirement):
        return FILENAME_PATTERN % (self.config.cache_format_revision,
                                   requirement.name, requirement.version,
                                   get_python_version())

Response: Generates a distribution archive filename for a package.


Instruction:
How would you code a function in Python 3 to
install missing dependencies for the given requirement.

Response:
def install_dependencies(self, requirement):
        """
        Install missing dependencies for the given requirement.

        :param requirement: A :class:`.Requirement` object.
        :returns: :data:`True` when missing system packages were installed,
                  :data:`False` otherwise.
        :raises: :exc:`.DependencyInstallationRefused` when automatic
                 installation is disabled or refused by the operator.
        :raises: :exc:`.DependencyInstallationFailed` when the installation
                 of missing system packages fails.

        If `pip-accel` fails to build a binary distribution, it will call this
        method as a last chance to install missing dependencies. If this
        function does not raise an exception, `pip-accel` will retry the build
        once.
        """
        install_timer = Timer()
        missing_dependencies = self.find_missing_dependencies(requirement)
        if missing_dependencies:
            # Compose the command line for the install command.
            install_command = shlex.split(self.install_command) + missing_dependencies
            # Prepend `sudo' to the command line?
            if not WINDOWS and not is_root():
                # FIXME Ideally this should properly detect the presence of `sudo'.
                #       Or maybe this should just be embedded in the *.ini files?
                install_command.insert(0, 'sudo')
            # Always suggest the installation command to the operator.
            logger.info("You seem to be missing %s: %s",
                        pluralize(len(missing_dependencies), "dependency", "dependencies"),
                        concatenate(missing_dependencies))
            logger.info("You can install %s with this command: %s",
                        "it" if len(missing_dependencies) == 1 else "them", " ".join(install_command))
            if self.config.auto_install is False:
                # Refuse automatic installation and don't prompt the operator when the configuration says no.
                self.installation_refused(requirement, missing_dependencies, "automatic installation is disabled")
            # Get the operator's permission to install the missing package(s).
            if self.config.auto_install:
                logger.info("Got permission to install %s (via auto_install option).",
                            pluralize(len(missing_dependencies), "dependency", "dependencies"))
            elif self.confirm_installation(requirement, missing_dependencies, install_command):
                logger.info("Got permission to install %s (via interactive prompt).",
                            pluralize(len(missing_dependencies), "dependency", "dependencies"))
            else:
                logger.error("Refused installation of missing %s!",
                             "dependency" if len(missing_dependencies) == 1 else "dependencies")
                self.installation_refused(requirement, missing_dependencies, "manual installation was refused")
            if subprocess.call(install_command) == 0:
                logger.info("Successfully installed %s in %s.",
                            pluralize(len(missing_dependencies), "dependency", "dependencies"),
                            install_timer)
                return True
            else:
                logger.error("Failed to install %s.",
                             pluralize(len(missing_dependencies), "dependency", "dependencies"))
                msg = "Failed to install %s required by Python package %s! (%s)"
                raise DependencyInstallationFailed(msg % (pluralize(len(missing_dependencies),
                                                                    "system package", "system packages"),
                                                          requirement.name,
                                                          concatenate(missing_dependencies)))
        return False


Instruction:
Implement a Python 3 function for
finding missing dependencies of a Python package.

Response:
def find_missing_dependencies(self, requirement):
        """
        Find missing dependencies of a Python package.

        :param requirement: A :class:`.Requirement` object.
        :returns: A list of strings with system package names.
        """
        known_dependencies = self.find_known_dependencies(requirement)
        if known_dependencies:
            installed_packages = self.find_installed_packages()
            logger.debug("Checking for missing dependencies of %s ..", requirement.name)
            missing_dependencies = sorted(set(known_dependencies).difference(installed_packages))
            if missing_dependencies:
                logger.debug("Found %s: %s",
                             pluralize(len(missing_dependencies), "missing dependency", "missing dependencies"),
                             concatenate(missing_dependencies))
            else:
                logger.info("All known dependencies are already installed.")
            return missing_dependencies


Instruction:
Write a Python 3 script for
finding the known dependencies of a Python package.

Response:
def find_known_dependencies(self, requirement):
        """
        Find the known dependencies of a Python package.

        :param requirement: A :class:`.Requirement` object.
        :returns: A list of strings with system package names.
        """
        logger.info("Checking for known dependencies of %s ..", requirement.name)
        known_dependencies = sorted(self.dependencies.get(requirement.name.lower(), []))
        if known_dependencies:
            logger.info("Found %s: %s", pluralize(len(known_dependencies), "known dependency", "known dependencies"),
                        concatenate(known_dependencies))
        else:
            logger.info("No known dependencies... Maybe you have a suggestion?")
        return known_dependencies


Instruction:
Can you write a function in Python 3 where it
finds the installed system packages.

Response:
def find_installed_packages(self):
        """
        Find the installed system packages.

        :returns: A list of strings with system package names.
        :raises: :exc:`.SystemDependencyError` when the command to list the
                 installed system packages fails.
        """
        list_command = subprocess.Popen(self.list_command, shell=True, stdout=subprocess.PIPE)
        stdout, stderr = list_command.communicate()
        if list_command.returncode != 0:
            raise SystemDependencyError("The command to list the installed system packages failed! ({command})",
                                        command=self.list_command)
        installed_packages = sorted(stdout.decode().split())
        logger.debug("Found %i installed system package(s): %s", len(installed_packages), installed_packages)
        return installed_packages


Instruction:
Can you write a function in Python 3 where it
raises a DependencyInstallationRefused exception with a user friendly message.

Response:
def installation_refused(self, requirement, missing_dependencies, reason):
        """
        Raise :exc:`.DependencyInstallationRefused` with a user friendly message.

        :param requirement: A :class:`.Requirement` object.
        :param missing_dependencies: A list of strings with missing dependencies.
        :param reason: The reason why installation was refused (a string).
        """
        msg = "Missing %s (%s) required by Python package %s (%s) but %s!"
        raise DependencyInstallationRefused(
            msg % (pluralize(len(missing_dependencies), "system package", "system packages"),
                   concatenate(missing_dependencies),
                   requirement.name,
                   requirement.version,
                   reason)
        )


Instruction:
Can you tell what is the following Python 3 function doing
def confirm_installation(self, requirement, missing_dependencies, install_command):
        try:
            return prompt_for_confirmation(format(
                "Do you want me to install %s %s?",
                "this" if len(missing_dependencies) == 1 else "these",
                "dependency" if len(missing_dependencies) == 1 else "dependencies",
            ), default=True)
        except KeyboardInterrupt:
            # Control-C is a negative response but doesn't
            # otherwise interrupt the program flow.
            return False

Response: Ask the operator s permission to install missing system packages.


Instruction:
How would you explain what the following Python 3 function does
def compact(text, **kw):
    return '\n\n'.join(' '.join(p.split()) for p in text.split('\n\n')).format(**kw)

Response: Compact whitespace in a string and format any keyword arguments into a string.


Instruction:
How would you explain what the following Python 3 function does
def expand_path(pathname):
    # The following logic previously used regular expressions but that approach
    # turned out to be very error prone, hence the current contraption based on
    # direct string manipulation :-).
    home_directory = find_home_directory()
    separators = set([os.sep])
    if os.altsep is not None:
        separators.add(os.altsep)
    if len(pathname) >= 2 and pathname[0] == '~' and pathname[1] in separators:
        pathname = os.path.join(home_directory, pathname[2:])
    # Also expand environment variables.
    return parse_path(pathname)

Response: Expand the home directory in a pathname based on the effective user id.


Instruction:
Make a summary of the following Python 3 code
def find_home_directory():
    if WINDOWS:
        directory = os.environ.get('APPDATA')
        if not directory:
            directory = os.path.expanduser(r'~\Application Data')
    else:
        # This module isn't available on Windows so we have to import it here.
        import pwd
        # Look up the home directory of the effective user id so we can
        # generate pathnames relative to the home directory.
        entry = pwd.getpwuid(os.getuid())
        directory = entry.pw_dir
    return directory

Response: Look up the home directory of the effective user id.


Instruction:
Explain what the following Python 3 code does
def makedirs(path, mode=0o777):
    try:
        os.makedirs(path, mode)
        return True
    except OSError as e:
        if e.errno != errno.EEXIST:
            # We don't want to swallow errors other than EEXIST,
            # because we could be obscuring a real problem.
            raise
        return False

Response: Create a directory if it doesn t already exist.


Instruction:
How would you explain what the following Python 3 function does
def same_directories(path1, path2):
    if all(os.path.isdir(p) for p in (path1, path2)):
        try:
            return os.path.samefile(path1, path2)
        except AttributeError:
            # On Windows and Python 2 os.path.samefile() is unavailable.
            return os.path.realpath(path1) == os.path.realpath(path2)
    else:
        return False

Response: Check if two pathnames refer to the same directory.


Instruction:
Can you create a Python 3 function that
calculates the hexadecimal digest of one or more local files.

Response:
def hash_files(method, *files):
    """
    Calculate the hexadecimal digest of one or more local files.

    :param method: The hash method (a string, given to :func:`hashlib.new()`).
    :param files: The pathname(s) of file(s) to hash (zero or more strings).
    :returns: The calculated hex digest (a string).
    """
    context = hashlib.new(method)
    for filename in files:
        with open(filename, 'rb') as handle:
            while True:
                chunk = handle.read(4096)
                if not chunk:
                    break
                context.update(chunk)
    return context.hexdigest()


Instruction:
Write a Python 3 script to
replace a file in an atomic fashion when possible.

Response:
def replace_file(src, dst):
    """
    Overwrite a file (in an atomic fashion when possible).

    :param src: The pathname of the source file (a string).
    :param dst: The pathname of the destination file (a string).
    """
    # Try os.replace() which was introduced in Python 3.3
    # (this should work on POSIX as well as Windows systems).
    try:
        os.replace(src, dst)
        return
    except AttributeError:
        pass
    # Try os.rename() which is atomic on UNIX but refuses to overwrite existing
    # files on Windows.
    try:
        os.rename(src, dst)
        return
    except OSError as e:
        if e.errno != errno.EEXIST:
            raise
    # Finally we fall back to the dumb approach required only on Windows.
    # See https://bugs.python.org/issue8828 for a long winded discussion.
    os.remove(dst)
    os.rename(src, dst)


Instruction:
Explain what the following Python 3 code does
def requirement_is_installed(expr):
    required_dist = next(parse_requirements(expr))
    try:
        installed_dist = get_distribution(required_dist.key)
        return installed_dist in required_dist
    except DistributionNotFound:
        return False

Response: Checks whether a requirement is installed.


Instruction:
Write a Python 3 script to
match a command line argument against a short and long option.

Response:
def match_option(argument, short_option, long_option):
    """
    Match a command line argument against a short and long option.

    :param argument: The command line argument (a string).
    :param short_option: The short option (a string).
    :param long_option: The long option (a string).
    :returns: :data:`True` if the argument matches, :data:`False` otherwise.
    """
    return short_option[1] in argument[1:] if is_short_option(argument) else argument == long_option


Instruction:
How would you implement a function in Python 3 that
checks if a list of command line options contains an option with a value pair.

Response:
def match_option_with_value(arguments, option, value):
    """
    Check if a list of command line options contains an option with a value.

    :param arguments: The command line arguments (a list of strings).
    :param option: The long option (a string).
    :param value: The expected value (a string).
    :returns: :data:`True` if the command line contains the option/value pair,
              :data:`False` otherwise.
    """
    return ('%s=%s' % (option, value) in arguments or
            contains_sublist(arguments, [option, value]))


Instruction:
Here you have a function in Python 3, explain what it does
def contains_sublist(lst, sublst):
    n = len(sublst)
    return any((sublst == lst[i:i + n]) for i in range(len(lst) - n + 1))

Response: Check if one list contains the items from another list.


Instruction:
Can you create a Python 3 function that
wraps around np. fromfile to support any file - like object.

Response:
def fromfile(file, dtype, count, *args, **kwargs):
    """Wrapper around np.fromfile to support any file-like object."""
    try:
        return numpy.fromfile(file, dtype=dtype, count=count, *args, **kwargs)
    except (TypeError, IOError):
        return numpy.frombuffer(file.read(count * numpy.dtype(dtype).itemsize),
                                dtype=dtype, count=count, *args, **kwargs)


Instruction:
Here you have a function in Python 3, explain what it does
def parse(path, meta_data_only=False, compensate=False, channel_naming='$PnS',
          reformat_meta=False, data_set=0, dtype='float32', encoding="utf-8"):
    """Parse an fcs file at the location specified by the path.

    Parameters
    ----------
    path: str
        Path of .fcs file
    meta_data_only: bool
        If True, the parse_fcs only returns the meta_data (the TEXT segment of the FCS file)
    output_format: 'DataFrame' | 'ndarray'
        If set to 'DataFrame' the returned
    channel_naming: '$PnS' | '$PnN'
        Determines which meta data field is used for naming the channels.
        The default should be $PnS (even though it is not guaranteed to be unique)

        $PnN stands for the short name (guaranteed to be unique).
            Will look like 'FL1-H'
        $PnS stands for the actual name (not guaranteed to be unique).
            Will look like 'FSC-H' (Forward scatter)

        The chosen field will be used to population self.channels

        Note: These names are not flipped in the implementation.
        It looks like they were swapped for some reason in the official FCS specification.
    reformat_meta: bool
        If true, the meta data is reformatted with the channel information organized
        into a DataFrame and moved into the '_channels_' key
    data_set: int
        Index of retrieved data set in the fcs file.
        This value specifies the data set being retrieved from an fcs file with multiple data sets.
    dtype: str | None
        If provided, will force convert all data into this dtype.
        This is set by default to auto-convert to float32 to deal with cases in which the original
        data has been stored using a smaller data type (e.g., unit8). This modifies the original
        data, but should make follow up analysis safer in basically all cases.
    encoding: str
        Provide encoding type of the text section.

    Returns
    -------
    if meta_data_only is True:
        meta_data: dict
            Contains a dictionary with the meta data information
    Otherwise:
        a 2-tuple with
            the first element the meta_data (dictionary)
            the second element the data (in either DataFrame or numpy format)

    Examples
    --------
    fname = '../tests/data/EY_2013-05-03_EID_214_PID_1120_Piperacillin_Well_B7.001.fcs'
    meta = parse_fcs(fname, meta_data_only=True)
    meta, data_pandas = parse_fcs(fname, meta_data_only=False)
    """
    if compensate:
        raise ParserFeatureNotImplementedError(u'Compensation has not been implemented yet.')

    read_data = not meta_data_only

    fcs_parser = FCSParser(path, read_data=read_data, channel_naming=channel_naming,
                           data_set=data_set, encoding=encoding)

    if reformat_meta:
        fcs_parser.reformat_meta()

    meta = fcs_parser.annotation

    if meta_data_only:
        return meta
    else:  # Then include both meta and dataframe.
        df = fcs_parser.dataframe
        df = df.astype(dtype) if dtype else df
        return meta, df

Response: Parse a FCS file at the specified location.


Instruction:
How would you code a function in Python 3 to
load the requested parts of the file into memory.

Response:
def load_file(self, file_handle, data_set=0, read_data=True):
        """Load the requested parts of the file into memory."""
        file_handle.seek(0, 2)
        self._file_size = file_handle.tell()
        file_handle.seek(0)
        data_segments = 0
        # seek the correct data set in fcs
        nextdata_offset = 0
        while data_segments <= data_set:
            self.read_header(file_handle, nextdata_offset)
            self.read_text(file_handle)
            if '$NEXTDATA' in self.annotation:
                data_segments += 1
                nextdata_offset = self.annotation['$NEXTDATA']
                file_handle.seek(nextdata_offset)
                if nextdata_offset == 0 and data_segments < data_set:
                    warnings.warn("File does not contain the number of data sets.")
                    break
            else:
                if data_segments != 0:
                    warnings.warn('File does not contain $NEXTDATA information.')
                break
        if read_data:
            self.read_data(file_handle)


Instruction:
Can you generate a brief explanation for the following Python 3 code
def from_data(cls, data):
        obj = cls()
        with contextlib.closing(BytesIO(data)) as file_handle:
            obj.load_file(file_handle)
        return obj

Response: Load an FCS file from a bytes - like object.


Instruction:
Implement a Python 3 function for
reading the header of the FCS file.

Response:
def read_header(self, file_handle, nextdata_offset=0):
        """Read the header of the FCS file.

        The header specifies where the annotation, data and analysis are located inside the binary
        file.

        Args:
            file_handle: buffer containing FCS file.
            nextdata_offset: byte offset of a set header from file start specified by $NEXTDATA
        """
        header = {'FCS format': file_handle.read(6)}

        file_handle.read(4)  # 4 space characters after the FCS format

        for field in ('text start', 'text end', 'data start', 'data end', 'analysis start',
                      'analysis end'):
            s = file_handle.read(8)
            try:
                field_value = int(s)
            except ValueError:
                field_value = 0
            header[field] = field_value + nextdata_offset

        # Checking that the location of the TEXT segment is specified
        for k in ('text start', 'text end'):
            if header[k] == 0:
                raise ValueError(u'The FCS file "{}" seems corrupted. (Parser cannot locate '
                                 u'information about the "{}" segment.)'.format(self.path, k))
            elif header[k] > self._file_size:
                raise ValueError(u'The FCS file "{}" is corrupted. "{}" segment '
                                 u'is larger than file size'.format(self.path, k))
            else:
                # All OK
                pass

        self._data_start = header['data start']
        self._data_end = header['data start']

        if header['analysis end'] - header['analysis start'] != 0:
            warnings.warn(u'There appears to be some information in the ANALYSIS segment of file '
                          u'{0}. However, it might not be read correctly.'.format(self.path))

        self.annotation['__header__'] = header


Instruction:
Given the following Python 3 function, write the documentation
def _extract_text_dict(self, raw_text):
        delimiter = raw_text[0]

        if raw_text[-1] != delimiter:
            raw_text = raw_text.strip()
            if raw_text[-1] != delimiter:
                msg = (u'The first two characters were:\n {}. The last two characters were: {}\n'
                       u'Parser expects the same delimiter character in beginning '
                       u'and end of TEXT segment'.format(raw_text[:2], raw_text[-2:]))
                raise ParserFeatureNotImplementedError(msg)

        # The delimiter is escaped by being repeated (two consecutive delimiters). This code splits
        # on the escaped delimiter first, so there is no need for extra logic to distinguish
        # actual delimiters from escaped delimiters.
        nested_split_list = [x.split(delimiter) for x in raw_text[1:-1].split(delimiter * 2)]
        # 1:-1 above removes the first and last characters which are reserved for the delimiter.

        # Flatten the nested list to a list of elements (alternating keys and values)
        raw_text_elements = nested_split_list[0]
        for partial_element_list in nested_split_list[1:]:
            # Rejoin two parts of an element that was split by an escaped delimiter (the end and
            # start of two successive sub-lists in nested_split_list)
            raw_text_elements[-1] += (delimiter + partial_element_list[0])
            raw_text_elements.extend(partial_element_list[1:])

        keys, values = raw_text_elements[0::2], raw_text_elements[1::2]
        return dict(zip(keys, values))

Response: Parse the TEXT segment of the FCS file into a python dictionary.


Instruction:
Write a Python 3 function that can
read the TEXT segment of the FCS file and returns the entry in the object.

Response:
def read_text(self, file_handle):
        """Parse the TEXT segment of the FCS file.

        The TEXT segment contains meta data associated with the FCS file.
        Converting all meta keywords to lower case.
        """
        header = self.annotation['__header__']  # For convenience

        #####
        # Read in the TEXT segment of the FCS file
        # There are some differences in how the
        file_handle.seek(header['text start'], 0)
        raw_text = file_handle.read(header['text end'] - header['text start'] + 1)
        try:
            raw_text = raw_text.decode(self._encoding)
        except UnicodeDecodeError as e:
            # Catching the exception and logging it in this way kills the traceback, but
            # we can worry about this later.
            logger.warning(u'Encountered an illegal utf-8 byte in the header.\n Illegal utf-8 '
                           u'characters will be ignored.\n{}'.format(e))
            raw_text = raw_text.decode(self._encoding, errors='ignore')

        text = self._extract_text_dict(raw_text)

        ##
        # Extract channel names and convert some of the channel properties
        # and other fields into numeric data types (from string)
        # Note: do not use regular expressions for manipulations here.
        # Regular expressions are too heavy in terms of computation time.
        pars = int(text['$PAR'])
        if '$P0B' in text.keys():  # Checking whether channel number count starts from 0 or from 1
            self.channel_numbers = range(0, pars)  # Channel number count starts from 0
        else:
            self.channel_numbers = range(1, pars + 1)  # Channel numbers start from 1

        # Extract parameter names
        try:
            names_n = tuple([text['$P{0}N'.format(i)] for i in self.channel_numbers])
        except KeyError:
            names_n = []

        try:
            names_s = tuple([text['$P{0}S'.format(i)] for i in self.channel_numbers])
        except KeyError:
            names_s = []

        self.channel_names_s = names_s
        self.channel_names_n = names_n

        # Convert some of the fields into integer values
        keys_encoding_bits = ['$P{0}B'.format(i) for i in self.channel_numbers]

        add_keys_to_convert_to_int = ['$NEXTDATA', '$PAR', '$TOT']

        keys_to_convert_to_int = keys_encoding_bits + add_keys_to_convert_to_int

        for key in keys_to_convert_to_int:
            value = text[key]
            text[key] = int(value)

        self.annotation.update(text)

        # Update data start segments if needed

        if self._data_start == 0:
            self._data_start = int(text['$BEGINDATA'])
        if self._data_end == 0:
            self._data_end = int(text['$ENDDATA'])


Instruction:
Given the following Python 3 function, write the documentation
def read_analysis(self, file_handle):
        start = self.annotation['__header__']['analysis start']
        end = self.annotation['__header__']['analysis end']
        if start != 0 and end != 0:
            file_handle.seek(start, 0)
            self._analysis = file_handle.read(end - start)
        else:
            self._analysis = None

Response: Reads the ANALYSIS segment of the FCS file and stores it in self. _analysis.


Instruction:
Can you generate the documentation for the following Python 3 function
def _verify_assumptions(self):
        text = self.annotation
        keys = text.keys()

        if '$MODE' not in text or text['$MODE'] != 'L':
            raise ParserFeatureNotImplementedError(u'Mode not implemented')

        if '$P0B' in keys:
            raise ParserFeatureNotImplementedError(u'Not expecting a parameter starting at 0')

        if text['$BYTEORD'] not in ['1,2,3,4', '4,3,2,1', '1,2', '2,1']:
            raise ParserFeatureNotImplementedError(u'$BYTEORD {} '
                                                   u'not implemented'.format(text['$BYTEORD']))

Response: Verify that all assumptions made by the parser hold are met.


Instruction:
Explain what the following Python 3 code does
def get_channel_names(self):
        names_s, names_n = self.channel_names_s, self.channel_names_n

        # Figure out which channel names to use
        if self._channel_naming == '$PnS':
            channel_names, channel_names_alternate = names_s, names_n
        else:
            channel_names, channel_names_alternate = names_n, names_s

        if len(channel_names) == 0:
            channel_names = channel_names_alternate

        if len(set(channel_names)) != len(channel_names):
            msg = (u'The default channel names (defined by the {} '
                   u'parameter in the FCS file) were not unique. To avoid '
                   u'problems in downstream analysis, the channel names '
                   u'have been switched to the alternate channel names '
                   u'defined in the FCS file. To avoid '
                   u'seeing this warning message, explicitly instruct '
                   u'the FCS parser to use the alternate channel names by '
                   u'specifying the channel_naming parameter.')
            msg = msg.format(self._channel_naming)
            warnings.warn(msg)
            channel_names = channel_names_alternate

        return channel_names

Response: Get list of channel names. Raises a warning if the names are not unique.


Instruction:
Create a Python 3 function for
reading the DATA segment of the FCS file.

Response:
def read_data(self, file_handle):
        """Read the DATA segment of the FCS file."""
        self._verify_assumptions()
        text = self.annotation

        if (self._data_start > self._file_size) or (self._data_end > self._file_size):
            raise ValueError(u'The FCS file "{}" is corrupted. Part of the data segment '
                             u'is missing.'.format(self.path))

        num_events = text['$TOT']  # Number of events recorded
        num_pars = text['$PAR']  # Number of parameters recorded

        if text['$BYTEORD'].strip() == '1,2,3,4' or text['$BYTEORD'].strip() == '1,2':
            endian = '<'
        elif text['$BYTEORD'].strip() == '4,3,2,1' or text['$BYTEORD'].strip() == '2,1':
            endian = '>'
        else:
            msg = 'Unrecognized byte order ({})'.format(text['$BYTEORD'])
            raise ParserFeatureNotImplementedError(msg)

        # dictionary to convert from FCS format to numpy convention
        conversion_dict = {'F': 'f', 'D': 'f', 'I': 'u'}

        if text['$DATATYPE'] not in conversion_dict.keys():
            raise ParserFeatureNotImplementedError('$DATATYPE = {0} is not yet '
                                                   'supported.'.format(text['$DATATYPE']))

        # Calculations to figure out data types of each of parameters
        # $PnB specifies the number of bits reserved for a measurement of parameter n
        bytes_per_par_list = [int(text['$P{0}B'.format(i)] / 8) for i in self.channel_numbers]

        par_numeric_type_list = [
            '{endian}{type}{size}'.format(endian=endian,
                                          type=conversion_dict[text['$DATATYPE']],
                                          size=bytes_per_par)
            for bytes_per_par in bytes_per_par_list
        ]

        # Parser for list mode. Here, the order is a list of tuples.
        # Each tuple stores event related information
        file_handle.seek(self._data_start, 0)  # Go to the part of the file where data starts

        ##
        # Read in the data
        if len(set(par_numeric_type_list)) > 1:
            # This branch deals with files in which the different columns (channels)
            # were encoded with different types; i.e., a mixed data format.
            dtype = ','.join(par_numeric_type_list)
            data = fromfile(file_handle, dtype, num_events)

            # The dtypes in the numpy array `data` above are associated with both a name
            # and a type; i.e.,
            # https://docs.scipy.org/doc/numpy/reference/generated/numpy.recarray.html
            # The names are assigned automatically.
            # In order for this code to work correctly with the pandas DataFrame constructor,
            # we convert the *names* of the dtypes to the channel names we want to use.

            names = self.get_channel_names()

            if six.PY2:
                encoded_names = [name.encode('ascii', errors='replace') for name in names]
            else:  # Assume that python3 or older then.
                encoded_names = [name for name in names]

            data.dtype.names = tuple(encoded_names)
        else:
            # values saved in a single data format
            dtype = par_numeric_type_list[0]
            data = fromfile(file_handle, dtype, num_events * num_pars)
            data = data.reshape((num_events, num_pars))
        ##
        # Convert to native byte order
        # This is needed for working with pandas data structures
        native_code = '<' if (sys.byteorder == 'little') else '>'
        if endian != native_code:
            # swaps the actual bytes and also the endianness
            data = data.byteswap().newbyteorder()

        self._data = data


Instruction:
Make a summary of the following Python 3 code
def data(self):
        if self._data is None:
            with open(self.path, 'rb') as f:
                self.read_data(f)
        return self._data

Response: Get parsed DATA segment of the FCS file.


Instruction:
Can you tell what is the following Python 3 function doing
def analysis(self):
        if self._analysis is None:
            with open(self.path, 'rb') as f:
                self.read_analysis(f)
        return self._analysis

Response: Get ANALYSIS segment of the FCS file.


Instruction:
Explain what the following Python 3 code does
def reformat_meta(self):
        meta = self.annotation  # For shorthand (passed by reference)
        channel_properties = []

        for key, value in meta.items():
            if key[:3] == '$P1':
                if key[3] not in string.digits:
                    channel_properties.append(key[3:])

        # Capture all the channel information in a list of lists -- used to create a data frame
        channel_matrix = [
            [meta.get('$P{0}{1}'.format(ch, p)) for p in channel_properties]
            for ch in self.channel_numbers
        ]

        # Remove this information from the dictionary
        for ch in self.channel_numbers:
            for p in channel_properties:
                key = '$P{0}{1}'.format(ch, p)
                if key in meta:
                    meta.pop(key)

        num_channels = meta['$PAR']
        column_names = ['$Pn{0}'.format(p) for p in channel_properties]

        df = pd.DataFrame(channel_matrix, columns=column_names,
                          index=(1 + numpy.arange(num_channels)))

        if '$PnE' in column_names:
            df['$PnE'] = df['$PnE'].apply(lambda x: x.split(','))

        df.index.name = 'Channel Number'
        meta['_channels_'] = df
        meta['_channel_names_'] = self.get_channel_names()

Response: Collect the meta data information in a more user friendly format.


Instruction:
Here you have a function in Python 3, explain what it does
def get_binary_dist(self, requirement):
        cache_file = self.cache.get(requirement)
        if cache_file:
            if self.needs_invalidation(requirement, cache_file):
                logger.info("Invalidating old %s binary (source has changed) ..", requirement)
                cache_file = None
        else:
            logger.debug("%s hasn't been cached yet, doing so now.", requirement)
        if not cache_file:
            # Build the binary distribution.
            try:
                raw_file = self.build_binary_dist(requirement)
            except BuildFailed:
                logger.warning("Build of %s failed, checking for missing dependencies ..", requirement)
                if self.system_package_manager.install_dependencies(requirement):
                    raw_file = self.build_binary_dist(requirement)
                else:
                    raise
            # Transform the binary distribution archive into a form that we can re-use.
            fd, transformed_file = tempfile.mkstemp(prefix='pip-accel-bdist-', suffix='.tar.gz')
            try:
                archive = tarfile.open(transformed_file, 'w:gz')
                try:
                    for member, from_handle in self.transform_binary_dist(raw_file):
                        archive.addfile(member, from_handle)
                finally:
                    archive.close()
                # Push the binary distribution archive to all available backends.
                with open(transformed_file, 'rb') as handle:
                    self.cache.put(requirement, handle)
            finally:
                # Close file descriptor before removing the temporary file.
                # Without closing Windows is complaining that the file cannot
                # be removed because it is used by another process.
                os.close(fd)
                # Cleanup the temporary file.
                os.remove(transformed_file)
            # Get the absolute pathname of the file in the local cache.
            cache_file = self.cache.get(requirement)
            # Enable checksum based cache invalidation.
            self.persist_checksum(requirement, cache_file)
        archive = tarfile.open(cache_file, 'r:gz')
        try:
            for member in archive.getmembers():
                yield member, archive.extractfile(member.name)
        finally:
            archive.close()

Response: Gets or creates a binary distribution archive for the given requirement.


Instruction:
How would you explain what the following Python 3 function does
def needs_invalidation(self, requirement, cache_file):
        if self.config.trust_mod_times:
            return requirement.last_modified > os.path.getmtime(cache_file)
        else:
            checksum = self.recall_checksum(cache_file)
            return checksum and checksum != requirement.checksum

Response: Checks whether a cached binary distribution needs to be invalidated.


Instruction:
Can you implement a function in Python 3 that
gets the checksum of the input used to generate a binary distribution archive.

Response:
def recall_checksum(self, cache_file):
        """
        Get the checksum of the input used to generate a binary distribution archive.

        :param cache_file: The pathname of the binary distribution archive (a string).
        :returns: The checksum (a string) or :data:`None` (when no checksum is available).
        """
        # EAFP instead of LBYL because of concurrency between pip-accel
        # processes (https://docs.python.org/2/glossary.html#term-lbyl).
        checksum_file = '%s.txt' % cache_file
        try:
            with open(checksum_file) as handle:
                contents = handle.read()
            return contents.strip()
        except IOError as e:
            if e.errno == errno.ENOENT:
                # Gracefully handle missing checksum files.
                return None
            else:
                # Don't swallow exceptions we don't expect!
                raise


Instruction:
Create a Python 3 function for
persisting the checksum of the input used to generate a binary distribution.

Response:
def persist_checksum(self, requirement, cache_file):
        """
        Persist the checksum of the input used to generate a binary distribution.

        :param requirement: A :class:`.Requirement` object.
        :param cache_file: The pathname of a cached binary distribution (a string).

        .. note:: The checksum is only calculated and persisted when
                  :attr:`~.Config.trust_mod_times` is :data:`False`.
        """
        if not self.config.trust_mod_times:
            checksum_file = '%s.txt' % cache_file
            with AtomicReplace(checksum_file) as temporary_file:
                with open(temporary_file, 'w') as handle:
                    handle.write('%s\n' % requirement.checksum)