Instruction:
How would you explain what the following Python 3 function does
def calcHairpin(seq, mv_conc=50.0, dv_conc=0.0, dntp_conc=0.8, dna_conc=50.0,
                temp_c=37, max_loop=30):
    ''' Calculate the hairpin formation thermodynamics of a DNA sequence.

    **Note that the maximum length of `seq` is 60 bp.** This is a cap suggested
    by the Primer3 team as the longest reasonable sequence length for which
    a two-state NN model produces reliable results (see primer3/src/libnano/thal.h:50).

    Args:
        seq (str): DNA sequence to analyze for hairpin formation

        mv_conc (float/int, optional): Monovalent cation conc. (mM)
        dv_conc (float/int, optional): Divalent cation conc. (mM)
        dntp_conc (float/int, optional): dNTP conc. (mM)
        dna_conc (float/int, optional): DNA conc. (nM)
        temp_c (int, optional): Simulation temperature for dG (Celsius)
        max_loop(int, optional): Maximum size of loops in the structure

    Returns:
        A `ThermoResult` object with thermodynamic characteristics of the
        hairpin formation.

    Raises:
        ``RuntimeError``

    '''
    _setThermoArgs(**locals())
    return _THERMO_ANALYSIS.calcHairpin(seq).checkExc()

Response: Calculates the hairpin formation thermodynamics of a sequence.


Instruction:
Explain what the following Python 3 code does
def calcEndStability(seq1, seq2, mv_conc=50, dv_conc=0, dntp_conc=0.8,
                     dna_conc=50, temp_c=37, max_loop=30):
    ''' Calculate the 3' end stability of DNA sequence `seq1` against DNA
    sequence `seq2`.

    **Note that at least one of the two sequences must by <60 bp in length.**
    This is a cap imposed by Primer3 as the longest reasonable sequence length
    for which a two-state NN model produces reliable results (see
    primer3/src/libnano/thal.h:50).

    Args:
        seq1 (str)                        : DNA sequence to analyze for 3' end
                                            hybridization against the target
                                            sequence
        seq2 (str)                        : Target DNA sequence to analyze for
                                            seq1 3' end hybridization

        mv_conc (float/int, optional)     : Monovalent cation conc. (mM)
        dv_conc (float/int, optional)     : Divalent cation conc. (mM)
        dntp_conc (float/int, optional)   : dNTP conc. (mM)
        dna_conc (float/int, optional)    : DNA conc. (nM)
        temp_c (int, optional)            : Simulation temperature for dG (C)
        max_loop(int, optional)           : Maximum size of loops in the
                                            structure

    Returns:
        A `ThermoResult` object with thermodynamic characteristics of the
        3' hybridization interaction.

    Raises:
        ``RuntimeError``

    '''
    _setThermoArgs(**locals())
    return _THERMO_ANALYSIS.calcEndStability(seq1, seq2).checkExc()

Response: Calculates the 3 end stability of seq1 against seq2.


Instruction:
How would you implement a function in Python 3 that
calculates the melting temperature of a sequence.

Response:
def calcTm(seq, mv_conc=50, dv_conc=0, dntp_conc=0.8, dna_conc=50,
           max_nn_length=60, tm_method='santalucia',
           salt_corrections_method='santalucia'):
    ''' Calculate the melting temperature (Tm) of a DNA sequence.

    Note that NN thermodynamics will be used to calculate the Tm of sequences
    up to 60 bp in length, after which point the following formula will be
    used::

        Tm = 81.5 + 16.6(log10([mv_conc])) + 0.41(%GC) - 600/length

    Args:
        seq (str)                               : DNA sequence
        mv_conc (float/int, optional)           : Monovalent cation conc. (mM)
        dv_conc (float/int, optional)           : Divalent cation conc. (mM)
        dntp_conc (float/int, optional)         : dNTP conc. (mM)
        dna_conc (float/int, optional)          : DNA conc. (nM)
        max_nn_length (int, optional)           : Maximum length for
                                                  nearest-neighbor calcs
        tm_method (str, optional)               : Tm calculation method
                                                  (breslauer or santalucia)
        salt_corrections_method (str, optional) : Salt correction method
                                                  (schildkraut, owczarzy,
                                                  santalucia)

    Returns:
        The melting temperature in degrees Celsius (float).

    '''
    _setThermoArgs(**locals())
    return _THERMO_ANALYSIS.calcTm(seq)


Instruction:
Write a Python 3 script to
run the Primer3 design process.

Response:
def designPrimers(seq_args, global_args=None, misprime_lib=None,
                  mishyb_lib=None, debug=False):
    ''' Run the Primer3 design process.

    If the global args have been previously set (either by a pervious
    `designPrimers` call or by a `setGlobals` call), `designPrimers` may be
    called with seqArgs alone (as a means of optimization).

    Args:
        seq_args (dict)               : Primer3 sequence/design args as per
                                        Primer3 docs

        global_args (dict, optional)  : Primer3 global args as per Primer3 docs
        misprime_lib (dict, optional) : `Sequence name: sequence` dictionary
                                        for mispriming checks.
        mishyb_lib (dict, optional)   : `Sequence name: sequence` dictionary
                                        for mishybridization checks.

    Returns:
        A dictionary of Primer3 results (should be identical to the expected
        BoulderIO output from primer3_main)

    '''
    if global_args:
        primerdesign.setGlobals(global_args, misprime_lib, mishyb_lib)
    primerdesign.setSeqArgs(seq_args)
    return primerdesign.runDesign(debug)


Instruction:
Given the following Python 3 function, write the documentation
def unravel_sections(section_data):
        sections = []
        for type, subsection_list in section_data.items():
            for section in subsection_list:
                section['sectionType'] = type
                sections.append(section)
        return sections

Response: Unravels section type dictionary into flat list of sections with sectionType set as an attribute.


Instruction:
Here you have a function in Python 3, explain what it does
def unravel_staff(staff_data):
        staff_list = []
        for role, staff_members in staff_data['data'].items():
            for member in staff_members:
                member['role'] = role
                staff_list.append(member)
        return staff_list

Response:
Unravels staff role dictionary into flat list of staff
         members with role set as an attribute.


Instruction:
Write a Python 3 function for
getting the gradebook id for a given gradebook uuid.

Response:
def get_gradebook_id(self, gbuuid):
        """Return gradebookid for a given gradebook uuid.

        Args:
            gbuuid (str): gradebook uuid, i.e. ``STELLAR:/project/gbngtest``

        Raises:
            PyLmodUnexpectedData: No gradebook id returned
            requests.RequestException: Exception connection error
            ValueError: Unable to decode response content

        Returns:
            str: value of gradebook id
        """
        gradebook = self.get('gradebook', params={'uuid': gbuuid})
        if 'data' not in gradebook:
            failure_messsage = ('Error in get_gradebook_id '
                                'for {0} - no data'.format(
                                    gradebook
                                ))
            log.error(failure_messsage)
            raise PyLmodUnexpectedData(failure_messsage)
        return gradebook['data']['gradebookId']


Instruction:
Explain what the following Python 3 code does
def get_options(self, gradebook_id):
        end_point = 'gradebook/options/{gradebookId}'.format(
            gradebookId=gradebook_id or self.gradebook_id)
        options = self.get(end_point)
        return options['data']

Response: Get options dictionary for a gradebook.


Instruction:
Write a Python 3 script for
getting assignments for a given gradebook.

Response:
def get_assignments(
            self,
            gradebook_id='',
            simple=False,
            max_points=True,
            avg_stats=False,
            grading_stats=False
    ):
        """Get assignments for a gradebook.

        Return list of assignments for a given gradebook,
        specified by a py:attribute::gradebook_id.  You can control
        if additional parameters are returned, but the response
        time with py:attribute::avg_stats and py:attribute::grading_stats
        enabled is significantly longer.

        Args:
            gradebook_id (str): unique identifier for gradebook, i.e. ``2314``
            simple (bool): return just assignment names, default= ``False``
            max_points (bool):
                Max points is a property of the grading scheme for the
                assignment rather than a property of the assignment itself,
                default= ``True``
            avg_stats (bool): return average grade, default= ``False``
            grading_stats (bool):
                return grading statistics, i.e. number of approved grades,
                unapproved grades, etc., default= ``False``

        Raises:
            requests.RequestException: Exception connection error
            ValueError: Unable to decode response content

        Returns:
            list: list of assignment dictionaries

            An example return value is:

            .. code-block:: python

                [
                    {
                        u'assignmentId': 2431240,
                        u'categoryId': 1293820,
                        u'description': u'',
                        u'dueDate': 1372392000000,
                        u'dueDateString': u'06-28-2013',
                        u'gradebookId': 1293808,
                        u'graderVisible': True,
                        u'gradingSchemeId': 2431243,
                        u'gradingSchemeType': u'NUMERIC',
                        u'isComposite': False,
                        u'isHomework': False,
                        u'maxPointsTotal': 10.0,
                        u'name': u'Homework 1',
                        u'shortName': u'HW1',
                        u'userDeleted': False,
                        u'weight': 1.0
                    },
                    {
                        u'assignmentId': 16708850,
                        u'categoryId': 1293820,
                        u'description': u'',
                        u'dueDate': 1383541200000,
                        u'dueDateString': u'11-04-2013',
                        u'gradebookId': 1293808,
                        u'graderVisible': False,
                        u'gradingSchemeId': 16708851,
                        u'gradingSchemeType': u'NUMERIC',
                        u'isComposite': False,
                        u'isHomework': False,
                        u'maxPointsTotal': 100.0,
                        u'name': u'midterm1',
                        u'shortName': u'mid1',
                        u'userDeleted': False,
                        u'weight': 1.0
                    },
                ]

       """
        # These are parameters required for the remote API call, so
        # there aren't too many arguments
        # pylint: disable=too-many-arguments
        params = dict(
            includeMaxPoints=json.dumps(max_points),
            includeAvgStats=json.dumps(avg_stats),
            includeGradingStats=json.dumps(grading_stats)
        )

        assignments = self.get(
            'assignments/{gradebookId}'.format(
                gradebookId=gradebook_id or self.gradebook_id
            ),
            params=params,
        )
        if simple:
            return [{'AssignmentName': x['name']}
                    for x in assignments['data']]
        return assignments['data']


Instruction:
How would you explain what the following Python 3 function does
def get_assignment_by_name(self, assignment_name, assignments=None):
        if assignments is None:
            assignments = self.get_assignments()
        for assignment in assignments:
            if assignment['name'] == assignment_name:
                return assignment['assignmentId'], assignment
        return None, None

Response: Get an assignment by name. It works by retrieving all assignments from the service and returning the first matching assignment.


Instruction:
Create a Python 3 function to
create a new assignment.

Response:
def create_assignment(  # pylint: disable=too-many-arguments
            self,
            name,
            short_name,
            weight,
            max_points,
            due_date_str,
            gradebook_id='',
            **kwargs
    ):
        """Create a new assignment.

        Create a new assignment. By default, assignments are created
        under the `Uncategorized` category.

        Args:
            name (str): descriptive assignment name,
                i.e. ``new NUMERIC SIMPLE ASSIGNMENT``
            short_name (str): short name of assignment, one word of
                no more than 5 characters,  i.e. ``SAnew``
            weight (str): floating point value for weight, i.e. ``1.0``
            max_points (str): floating point value for maximum point
                total, i.e. ``100.0``
            due_date_str (str): due date as string in ``mm-dd-yyyy``
                format, i.e. ``08-21-2011``
            gradebook_id (str): unique identifier for gradebook, i.e. ``2314``
            kwargs (dict): dictionary containing additional parameters,
                i.e. ``graderVisible``, ``totalAverage``, and ``categoryId``.

                For example:

                .. code-block:: python

                    {
                        u'graderVisible': True,
                        u'totalAverage': None
                        u'categoryId': 1007964,
                    }

        Raises:
            requests.RequestException: Exception connection error
            ValueError: Unable to decode response content

        Returns:
            dict: dictionary containing ``data``, ``status`` and ``message``
                for example:

            .. code-block:: python

                {
                    u'data':
                    {
                        u'assignmentId': 18490492,
                        u'categoryId': 1293820,
                        u'description': u'',
                        u'dueDate': 1312171200000,
                        u'dueDateString': u'08-01-2011',
                        u'gradebookId': 1293808,
                        u'graderVisible': False,
                        u'gradingSchemeId': 18490493,
                        u'gradingSchemeType': u'NUMERIC',
                        u'isComposite': False,
                        u'isHomework': False,
                        u'maxPointsTotal': 100.0,
                        u'name': u'new NUMERIC SIMPLE ASSIGNMENT',
                        u'numStudentGradesToBeApproved': 0,
                        u'numStudentsToBeGraded': 614,
                        u'shortName': u'SAnew',
                        u'userDeleted': False,
                        u'weight': 1.0
                    },
                    u'message': u'assignment is created successfully',
                    u'status': 1
                }

        """
        data = {
            'name': name,
            'shortName': short_name,
            'weight': weight,
            'graderVisible': False,
            'gradingSchemeType': 'NUMERIC',
            'gradebookId': gradebook_id or self.gradebook_id,
            'maxPointsTotal': max_points,
            'dueDateString': due_date_str
        }
        data.update(kwargs)
        log.info("Creating assignment %s", name)
        response = self.post('assignment', data)
        log.debug('Received response data: %s', response)
        return response


Instruction:
Explain what the following Python 3 code does
def set_grade(
            self,
            assignment_id,
            student_id,
            grade_value,
            gradebook_id='',
            **kwargs
    ):
        """Set numerical grade for student and assignment.

        Set a numerical grade for for a student and assignment. Additional
        options
        for grade ``mode`` are: OVERALL_GRADE = ``1``, REGULAR_GRADE = ``2``
        To set 'excused' as the grade, enter ``None`` for letter and
        numeric grade values,
        and pass ``x`` as the ``specialGradeValue``.
        ``ReturnAffectedValues`` flag determines whether or not to return
        student cumulative points and
        impacted assignment category grades (average and student grade).

        Args:
            assignment_id (str): numerical ID for assignment
            student_id (str): numerical ID for student
            grade_value (str): numerical grade value
            gradebook_id (str): unique identifier for gradebook, i.e. ``2314``
            kwargs (dict): dictionary of additional parameters

                .. code-block:: python

                    {
                        u'letterGradeValue':None,
                        u'booleanGradeValue':None,
                        u'specialGradeValue':None,
                        u'mode':2,
                        u'isGradeApproved':False,
                        u'comment':None,
                        u'returnAffectedValues': True,
                    }

        Raises:
            requests.RequestException: Exception connection error
            ValueError: Unable to decode response content

        Returns:
            dict: dictionary containing response ``status`` and ``message``

            .. code-block:: python

                {
                    u'message': u'grade saved successfully',
                    u'status': 1
                }

        """
        # pylint: disable=too-many-arguments

        # numericGradeValue stringified because 'x' is a possible
        # value for excused grades.
        grade_info = {
            'studentId': student_id,
            'assignmentId': assignment_id,
            'mode': 2,
            'comment': 'from MITx {0}'.format(time.ctime(time.time())),
            'numericGradeValue': str(grade_value),
            'isGradeApproved': False
        }
        grade_info.update(kwargs)
        log.info(
            "student %s set_grade=%s for assignment %s",
            student_id,
            grade_value,
            assignment_id)
        return self.post(
            'grades/{gradebookId}'.format(
                gradebookId=gradebook_id or self.gradebook_id
            ),
            data=grade_info,
        )

Response: Set a numerical grade for a student and assignment.


Instruction:
Here you have a function in Python 3, explain what it does
def multi_grade(self, grade_array, gradebook_id=''):
        log.info('Sending grades: %r', grade_array)
        return self.post(
            'multiGrades/{gradebookId}'.format(
                gradebookId=gradebook_id or self.gradebook_id
            ),
            data=grade_array,
        )

Response: Set multiple grades for students.


Instruction:
Given the following Python 3 function, write the documentation
def get_sections(self, gradebook_id='', simple=False):
        params = dict(includeMembers='false')

        section_data = self.get(
            'sections/{gradebookId}'.format(
                gradebookId=gradebook_id or self.gradebook_id
            ),
            params=params
        )

        if simple:
            sections = self.unravel_sections(section_data['data'])
            return [{'SectionName': x['name']} for x in sections]
        return section_data['data']

Response: Get the sections for a given gradebook.


Instruction:
Can you generate the documentation for the following Python 3 function
def get_section_by_name(self, section_name):
        sections = self.unravel_sections(self.get_sections())
        for section in sections:
            if section['name'] == section_name:
                return section['groupId'], section
        return None, None

Response: Get a section by its name.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def get_students(
            self,
            gradebook_id='',
            simple=False,
            section_name='',
            include_photo=False,
            include_grade_info=False,
            include_grade_history=False,
            include_makeup_grades=False
    ):
        """Get students for a gradebook.

        Get a list of students for a given gradebook,
        specified by a gradebook id. Does not include grade data.

        Args:
            gradebook_id (str): unique identifier for gradebook, i.e. ``2314``
            simple (bool):
                if ``True``, just return dictionary with keys ``email``,
                ``name``, ``section``, default = ``False``
            section_name (str): section name
            include_photo (bool): include student photo, default= ``False``
            include_grade_info (bool):
                include student's grade info, default= ``False``
            include_grade_history (bool):
                include student's grade history, default= ``False``
            include_makeup_grades (bool):
                include student's makeup grades, default= ``False``

        Raises:
            requests.RequestException: Exception connection error
            ValueError: Unable to decode response content

        Returns:
            list: list of student dictionaries

        .. code-block:: python

            [{
                u'accountEmail': u'stellar.test2@gmail.com',
                u'displayName': u'Molly Parker',
                u'photoUrl': None,
                u'middleName': None,
                u'section': u'Unassigned',
                u'sectionId': 1293925,
                u'editable': False,
                u'overallGradeInformation': None,
                u'studentId': 1145,
                u'studentAssignmentInfo': None,
                u'sortableName': u'Parker, Molly',
                u'surname': u'Parker',
                u'givenName': u'Molly',
                u'nickName': u'Molly',
                u'email': u'stellar.test2@gmail.com'
            },]

        """
        # These are parameters required for the remote API call, so
        # there aren't too many arguments, or too many variables
        # pylint: disable=too-many-arguments,too-many-locals

        # Set params by arguments
        params = dict(
            includePhoto=json.dumps(include_photo),
            includeGradeInfo=json.dumps(include_grade_info),
            includeGradeHistory=json.dumps(include_grade_history),
            includeMakeupGrades=json.dumps(include_makeup_grades),
        )

        url = 'students/{gradebookId}'
        if section_name:
            group_id, _ = self.get_section_by_name(section_name)
            if group_id is None:
                failure_message = (
                    'in get_students -- Error: '
                    'No such section %s' % section_name
                )
                log.critical(failure_message)
                raise PyLmodNoSuchSection(failure_message)
            url += '/section/{0}'.format(group_id)

        student_data = self.get(
            url.format(
                gradebookId=gradebook_id or self.gradebook_id
            ),
            params=params,
        )

        if simple:
            # just return dict with keys email, name, section
            student_map = dict(
                accountEmail='email',
                displayName='name',
                section='section'
            )

            def remap(students):
                """Convert mit.edu domain to upper-case for student emails.

                The mit.edu domain for user email must be upper-case,
                i.e. MIT.EDU.

                Args:
                    students (list): list of students

                Returns:
                    dict: dictionary of updated student email domains
                """
                newx = dict((student_map[k], students[k]) for k in student_map)
                # match certs
                newx['email'] = newx['email'].replace('@mit.edu', '@MIT.EDU')
                return newx

            return [remap(x) for x in student_data['data']]

        return student_data['data']

Response: Get a list of students for a given gradebook.


Instruction:
Create a Python 3 function for
getting a student based on an email address.

Response:
def get_student_by_email(self, email, students=None):
        """Get a student based on an email address.

        Calls ``self.get_students()`` to get list of all students,
        if not passed as the ``students`` parameter.

        Args:
            email (str): student email
            students (list): dictionary of students to search, default: None
                When ``students`` is unspecified, all students in gradebook
                are retrieved.

        Raises:
            requests.RequestException: Exception connection error
            ValueError: Unable to decode response content

        Returns:
            tuple: tuple of student id and student dictionary.
        """
        if students is None:
            students = self.get_students()

        email = email.lower()
        for student in students:
            if student['accountEmail'].lower() == email:
                return student['studentId'], student
        return None, None


Instruction:
Write a Python 3 function that can
transfer grades from spreadsheet to array. Helper function that transfer grades from spreadsheet using ``multi_grade()`` (multiple students at a time). We do this by creating a large array containing all grades to transfer, then make one call to the Gradebook API. Args: csv_reader (csv.DictReader): list of rows in CSV file email_field (str): The name of the email field non_assignment_fields (list): list of column names in CSV file which should not be treated as assignment names approve_grades (bool): Should grades be auto approved? use_max_points_column (bool): If true, read the max points and normalize values from the CSV and use the max points value in place of the default if normalized is False. max_points_column (str): The name of the max_pts column. All rows contain the same number, the max points for the assignment. normalize_column (str): The name of the normalize column which indicates whether to use the max points value. Raises: PyLmodFailedAssignmentCreation: Failed to create assignment requests.RequestException: Exception connection error ValueError: Unable to decode response content Returns: tuple: tuple of dictionary containing response ``status`` and ``message``, and duration of operation

Response:
def _spreadsheet2gradebook_multi(
            self,
            csv_reader,
            email_field,
            non_assignment_fields,
            approve_grades=False,
            use_max_points_column=False,
            max_points_column=None,
            normalize_column=None
    ):
        """Transfer grades from spreadsheet to array.

        Helper function that transfer grades from spreadsheet using
        ``multi_grade()`` (multiple students at a time). We do this by
        creating a large array containing all grades to transfer, then
        make one call to the Gradebook API.

        Args:
            csv_reader (csv.DictReader): list of rows in CSV file
            email_field (str): The name of the email field
            non_assignment_fields (list): list of column names in CSV file
                which should not be treated as assignment names
            approve_grades (bool): Should grades be auto approved?
            use_max_points_column (bool): If true, read the max points
                and normalize values from the CSV and use the max points value
                in place of the default if normalized is False.
            max_points_column (str): The name of the max_pts column. All
                rows contain the same number, the max points for
                the assignment.
            normalize_column (str): The name of the normalize column which
                indicates whether to use the max points value.

        Raises:
            PyLmodFailedAssignmentCreation: Failed to create assignment
            requests.RequestException: Exception connection error
            ValueError: Unable to decode response content

        Returns:
            tuple: tuple of dictionary containing response ``status``
            and ``message``, and duration of operation

        """
        # pylint: disable=too-many-locals
        if use_max_points_column:
            if max_points_column is None:
                raise ValueError(
                    "max_points_column must be set "
                    "if use_max_points_column is set"
                )
            if normalize_column is None:
                raise ValueError(
                    "normalize_column must be set "
                    "if use_max_points_column is set"
                )

        assignments = self.get_assignments()
        students = self.get_students()
        assignment2id = {}
        grade_array = []
        for row in csv_reader:
            email = row[email_field]
            sid, _ = self.get_student_by_email(email, students)
            if sid is None:
                log.warning(
                    'Error in spreadsheet2gradebook: cannot find '
                    'student id for email="%s"\n', email
                )
                continue
            for field in row.keys():
                if field in non_assignment_fields:
                    continue
                if field not in assignment2id:
                    assignment_id, _ = self.get_assignment_by_name(
                        field, assignments=assignments
                    )
                    # If no assignment found, try creating it.
                    if assignment_id is None:
                        name = field
                        shortname = field[0:3] + field[-2:]
                        log.info('calling create_assignment from multi')

                        # If the max_pts and normalize columns are present,
                        # and use_max_points_column is True,
                        # replace the default value for max points.
                        max_points = DEFAULT_MAX_POINTS
                        if use_max_points_column:
                            # This value means it was already normalized, and
                            # we should use the default max points
                            # instead of the one in the CSV.
                            normalize_value = True
                            normalize_value_str = row.get(normalize_column)
                            if normalize_value_str is not None:
                                try:
                                    normalize_value = bool(
                                        int(normalize_value_str)
                                    )
                                except ValueError as ex:
                                    # Value is already normalized
                                    log.warning(
                                        'Bool conversion error '
                                        ' in normalize column for '
                                        'value: %s, exception: %s',
                                        normalize_value_str,
                                        ex
                                    )

                            if not normalize_value:
                                max_points_str = row.get(max_points_column)
                                if max_points_str is not None:
                                    try:
                                        max_points = float(max_points_str)
                                    except ValueError as ex:
                                        log.warning(
                                            'Floating point conversion error '
                                            'in max points column for '
                                            'value: %s, exception: %s',
                                            max_points_str,
                                            ex
                                        )

                        response = self.create_assignment(
                            name, shortname, 1.0, max_points, '12-15-2013'
                        )
                        if (
                                not response.get('data', '') or
                                'assignmentId' not in response.get('data')
                        ):
                            failure_message = (
                                "Error! Failed to create assignment {0}"
                                ", got {1}".format(
                                    name, response
                                )
                            )
                            log.critical(failure_message)
                            raise PyLmodFailedAssignmentCreation(
                                failure_message
                            )
                        assignment_id = response['data']['assignmentId']
                    log.info("Assignment %s has Id=%s", field, assignment_id)
                    assignment2id[field] = assignment_id

                assignment_id = assignment2id[field]
                successful = True
                try:
                    # Try to convert to numeric, but grade the
                    # rest anyway if any particular grade isn't a
                    # number
                    gradeval = float(row[field]) * 1.0
                    log.debug(
                        'Received grade value %s(converted to %s) for '
                        'student %s on assignment %s',
                        row[field],
                        gradeval,
                        sid,
                        assignment_id,
                    )
                except ValueError as err:
                    log.exception(
                        "Failed in converting grade for student %s"
                        ", row=%s, err=%s", sid, row, err
                    )
                    successful = False
                if successful:
                    grade_array.append({
                        "studentId": sid,
                        "assignmentId": assignment_id,
                        "numericGradeValue": gradeval,
                        "mode": 2,
                        "isGradeApproved": approve_grades
                    })
        # Everything is setup to post, do the post and track the time
        # it takes.
        log.info(
            'Data read from file, doing multiGrades API '
            'call (%d grades)', len(grade_array)
        )
        tstart = time.time()
        response = self.multi_grade(grade_array)
        duration = time.time() - tstart
        log.info(
            'multiGrades API call done (%d bytes returned) '
            'dt=%6.2f seconds.', len(json.dumps(response)), duration
        )
        return response, duration


Instruction:
Implement a function in Python 3 to
upload grades from CSV format spreadsheet file into Learning Modules gradebook.

Response:
def spreadsheet2gradebook(
            self,
            csv_file,
            email_field=None,
            approve_grades=False,
            use_max_points_column=False,
            max_points_column=None,
            normalize_column=None
    ):
        """Upload grade spreadsheet to gradebook.

        Upload grades from CSV format spreadsheet file into the
        Learning Modules gradebook.  The spreadsheet must have a column
        named ``External email`` which is used as the student's email
        address (for looking up and matching studentId).

        These columns are disregarded: ``ID``, ``Username``,
        ``Full Name``, ``edX email``, ``External email``,
        as well as the strings passed in ``max_points_column``
        and ``normalize_column``, if any.
        All other columns are taken as assignments.

        If ``email_field`` is specified, then that field name is taken as
        the student's email.

        .. code-block:: none

            External email,AB Assignment 01,AB Assignment 02
            jeannechiang@gmail.com,1.0,0.9
            stellar.test2@gmail.com,0.2,0.4
            stellar.test1@gmail.com,0.93,0.77

        Args:
            csv_reader (str): filename of csv data, or readable file object
            email_field (str): student's email
            approve_grades (bool): Should grades be auto approved?
            use_max_points_column (bool):
                If ``True``, read the max points and normalize values
                from the CSV and use the max points value in place of
                the default if normalized is ``False``.
            max_points_column (str): The name of the max_pts column. All
                rows contain the same number, the max points for
                the assignment.
            normalize_column (str): The name of the normalize column which
                indicates whether to use the max points value.

        Raises:
            PyLmodFailedAssignmentCreation: Failed to create assignment
            requests.RequestException: Exception connection error
            ValueError: Unable to decode response content

        Returns:
            tuple: tuple of dictionary containing response ``status``
            and ``message``, and duration of operation

        """
        non_assignment_fields = [
            'ID', 'Username', 'Full Name', 'edX email', 'External email'
        ]
        if max_points_column is not None:
            non_assignment_fields.append(max_points_column)
        if normalize_column is not None:
            non_assignment_fields.append(normalize_column)

        if email_field is not None:
            non_assignment_fields.append(email_field)
        else:
            email_field = 'External email'

        if not hasattr(csv_file, 'read'):
            file_pointer = open(csv_file)
        else:
            file_pointer = csv_file
        csv_reader = csv.DictReader(file_pointer, dialect='excel')

        response = self._spreadsheet2gradebook_multi(
            csv_reader,
            email_field,
            non_assignment_fields,
            approve_grades=approve_grades,
            use_max_points_column=use_max_points_column,
            max_points_column=max_points_column,
            normalize_column=normalize_column
        )
        return response


Instruction:
Create a Python 3 function for
returning a list of dictionaries one for each member of the gradebook and one for each role.

Response:
def get_staff(self, gradebook_id, simple=False):
        """Get staff list for gradebook.

        Get staff list for the gradebook specified. Optionally, return
        a less detailed list by specifying ``simple = True``.

        If simple=True, return a list of dictionaries, one dictionary
        for each member. The dictionary contains a member's ``email``,
        ``displayName``, and ``role``. Members with multiple roles will
        appear in the list once for each role.

        Args:
            gradebook_id (str): unique identifier for gradebook, i.e. ``2314``
            simple (bool): Return a staff list with less detail. Default
                is ``False``.

        Returns:

            An example return value is:

            .. code-block:: python

                {
                    u'data': {
                        u'COURSE_ADMIN': [
                            {
                                u'accountEmail': u'benfranklin@mit.edu',
                                u'displayName': u'Benjamin Franklin',
                                u'editable': False,
                                u'email': u'benfranklin@mit.edu',
                                u'givenName': u'Benjamin',
                                u'middleName': None,
                                u'mitId': u'921344431',
                                u'nickName': u'Benjamin',
                                u'personId': 10710616,
                                u'sortableName': u'Franklin, Benjamin',
                                u'surname': u'Franklin',
                                u'year': None
                            },
                        ],
                        u'COURSE_PROF': [
                            {
                                u'accountEmail': u'dduck@mit.edu',
                                u'displayName': u'Donald Duck',
                                u'editable': False,
                                u'email': u'dduck@mit.edu',
                                u'givenName': u'Donald',
                                u'middleName': None,
                                u'mitId': u'916144889',
                                u'nickName': u'Donald',
                                u'personId': 8117160,
                                u'sortableName': u'Duck, Donald',
                                u'surname': u'Duck',
                                u'year': None
                            },
                        ],
                        u'COURSE_TA': [
                            {
                                u'accountEmail': u'hduck@mit.edu',
                                u'displayName': u'Huey Duck',
                                u'editable': False,
                                u'email': u'hduck@mit.edu',
                                u'givenName': u'Huey',
                                u'middleName': None,
                                u'mitId': u'920445024',
                                u'nickName': u'Huey',
                                u'personId': 1299059,
                                u'sortableName': u'Duck, Huey',
                                u'surname': u'Duck',
                                u'year': None
                            },
                        ]
                    },
                }

        """
        staff_data = self.get(
            'staff/{gradebookId}'.format(
                gradebookId=gradebook_id or self.gradebook_id
            ),
            params=None,
        )
        if simple:
            simple_list = []
            unraveled_list = self.unravel_staff(staff_data)
            for member in unraveled_list.__iter__():
                simple_list.append({
                    'accountEmail': member['accountEmail'],
                    'displayName': member['displayName'],
                    'role': member['role'],
                })
            return simple_list
        return staff_data['data']


Instruction:
Explain what the following Python 3 code does
def get_group(self, uuid=None):
        if uuid is None:
            uuid = self.uuid
        group_data = self.get('group', params={'uuid': uuid})
        return group_data

Response: Get group data based on uuid.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def get_group_id(self, uuid=None):
        group_data = self.get_group(uuid)
        try:
            return group_data['response']['docs'][0]['id']
        except (KeyError, IndexError):
            failure_message = ('Error in get_group response data - '
                               'got {0}'.format(group_data))
            log.exception(failure_message)
            raise PyLmodUnexpectedData(failure_message)

Response: Get group id based on uuid.


Instruction:
Here you have a function in Python 3, explain what it does
def get_membership(self, uuid=None):
        group_id = self.get_group_id(uuid=uuid)
        uri = 'group/{group_id}/member'
        mbr_data = self.get(uri.format(group_id=group_id), params=None)
        return mbr_data

Response: Get the membership data based on uuid.


Instruction:
Write a Python 3 function for
returning True if an email is associated with a role.

Response:
def email_has_role(self, email, role_name, uuid=None):
        """Determine if an email is associated with a role.

        Args:
            email (str): user email
            role_name (str): user role
            uuid (str): optional uuid. defaults to self.cuuid

        Raises:
            PyLmodUnexpectedData: Unexpected data was returned.
            requests.RequestException: Exception connection error

        Returns:
            bool: True or False if email has role_name

        """
        mbr_data = self.get_membership(uuid=uuid)
        docs = []
        try:
            docs = mbr_data['response']['docs']
        except KeyError:
            failure_message = ('KeyError in membership data - '
                               'got {0}'.format(mbr_data))
            log.exception(failure_message)
            raise PyLmodUnexpectedData(failure_message)
        if len(docs) == 0:
            return False
        has_role = any(
            (x.get('email') == email and x.get('roleType') == role_name)
            for x in docs
        )
        if has_role:
            return True
        return False


Instruction:
Can you create a Python 3 function that
gets course id based on uuid.

Response:
def get_course_id(self, course_uuid):
        """Get course id based on uuid.

        Args:
            uuid (str): course uuid, i.e. /project/mitxdemosite

        Raises:
            PyLmodUnexpectedData: No course data was returned.
            requests.RequestException: Exception connection error

        Returns:
            int: numeric course id

        """
        course_data = self.get(
            'courseguide/course?uuid={uuid}'.format(
                uuid=course_uuid or self.course_id
            ),
            params=None
        )
        try:
            return course_data['response']['docs'][0]['id']
        except KeyError:
            failure_message = ('KeyError in get_course_id - '
                               'got {0}'.format(course_data))
            log.exception(failure_message)
            raise PyLmodUnexpectedData(failure_message)
        except TypeError:
            failure_message = ('TypeError in get_course_id - '
                               'got {0}'.format(course_data))
            log.exception(failure_message)
            raise PyLmodUnexpectedData(failure_message)


Instruction:
How would you implement a function in Python 3 that
gets a list of staff roster members for a given course.

Response:
def get_course_guide_staff(self, course_id=''):
        """Get the staff roster for a course.

        Get a list of staff members for a given course,
        specified by a course id.

        Args:
            course_id (int): unique identifier for course, i.e. ``2314``

        Raises:
            requests.RequestException: Exception connection error
            ValueError: Unable to decode response content

        Returns:
            list: list of dictionaries containing staff data

            An example return value is:

            .. code-block:: python

                [
                    {
                        u'displayName': u'Huey Duck',
                        u'role': u'TA',
                        u'sortableDisplayName': u'Duck, Huey'
                    },
                    {
                        u'displayName': u'Louie Duck',
                        u'role': u'CourseAdmin',
                        u'sortableDisplayName': u'Duck, Louie'
                    },
                    {
                        u'displayName': u'Benjamin Franklin',
                        u'role': u'CourseAdmin',
                        u'sortableDisplayName': u'Franklin, Benjamin'
                    },
                    {
                        u'displayName': u'George Washington',
                        u'role': u'Instructor',
                        u'sortableDisplayName': u'Washington, George'
                    },
                ]
    """
        staff_data = self.get(
            'courseguide/course/{courseId}/staff'.format(
                courseId=course_id or self.course_id
            ),
            params=None
        )
        return staff_data['response']['docs']


Instruction:
How would you explain what the following Python 3 function does
def _data_to_json(data):
        if type(data) not in [str, unicode]:
            data = json.dumps(data)
        return data

Response: Convert to json if it isn t already a string.


Instruction:
How would you code a function in Python 3 to
generate URL from urlbase and service.

Response:
def _url_format(self, service):
        """Generate URL from urlbase and service.

        Args:
            service (str): The endpoint service to use, i.e. gradebook
        Returns:
            str: URL to where the request should be made
        """
        base_service_url = '{base}{service}'.format(
            base=self.urlbase,
            service=service
        )
        return base_service_url


Instruction:
Given the following Python 3 function, write the documentation
def post(self, service, data):
        url = self._url_format(service)
        data = Base._data_to_json(data)
        # Add content-type for body in POST.
        headers = {'content-type': 'application/json'}
        return self.rest_action(self._session.post, url,
                                data=data, headers=headers)

Response: Generic POST operation for sending data to Learning Modules API.


Instruction:
Here you have a function in Python 3, explain what it does
def create_token(secret, data, options=None):
    if not isinstance(secret, basestring):
        raise ValueError("firebase_token_generator.create_token: secret must be a string.")
    if not options and not data:
        raise ValueError("firebase_token_generator.create_token: data is empty and no options are set.  This token will have no effect on Firebase.");
    if not options:
        options = {}
    is_admin_token = ('admin' in options and options['admin'] == True)
    _validate_data(data, is_admin_token)
    claims = _create_options_claims(options)
    claims['v'] = TOKEN_VERSION
    claims['iat'] = int(time.time())
    claims['d'] = data

    token = _encode_token(secret, claims)
    if len(token) > 1024:
        raise RuntimeError("firebase_token_generator.create_token: generated token is too long.")
    return token

Response: Generates a secure authentication token.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def parse_html(fileobj, encoding):
    parser = HTMLParser(encoding=encoding, remove_blank_text=True)
    return parse(fileobj, parser)

Response: Given a file object and an encoding return an ElementTree instance.


Instruction:
Write a Python 3 function that can
fetch sequence by seq_id optionally with start end bounds

Response:
def fetch(self, seq_id, start=None, end=None):
        """fetch sequence by seq_id, optionally with start, end bounds

        """
        rec = self._db.execute("""select * from seqinfo where seq_id = ? order by added desc""", [seq_id]).fetchone()

        if rec is None:
            raise KeyError(seq_id)

        if self._writing and self._writing["relpath"] == rec["relpath"]:
            logger.warning("""Fetching from file opened for writing;
            closing first ({})""".format(rec["relpath"]))
            self.commit()

        path = os.path.join(self._root_dir, rec["relpath"])
        fabgz = self._open_for_reading(path)
        return fabgz.fetch(seq_id, start, end)


Instruction:
How would you implement a function in Python 3 that
stores a sequence with key seq_id in the sqlite3 database and return the seq_id.

Response:
def store(self, seq_id, seq):
        """store a sequence with key seq_id.  The sequence itself is stored in
        a fasta file and a reference to it in the sqlite3 database.

        """

        if not self._writeable:
            raise RuntimeError("Cannot write -- opened read-only")

        # open a file for writing if necessary
        # path: <root_dir>/<reldir>/<basename>
        #                  <---- relpath ---->
        #       <------ dir_ ----->
        #       <----------- path ----------->
        if self._writing is None:
            reldir = datetime.datetime.utcnow().strftime("%Y/%m%d/%H%M")
            basename = str(time.time()) + ".fa.bgz"
            relpath = os.path.join(reldir, basename)

            dir_ = os.path.join(self._root_dir, reldir)
            path = os.path.join(self._root_dir, reldir, basename)
            makedirs(dir_, exist_ok=True)
            fabgz = FabgzWriter(path)
            self._writing = {"relpath": relpath, "fabgz": fabgz}
            logger.info("Opened for writing: " + path)

        self._writing["fabgz"].store(seq_id, seq)
        alpha = "".join(sorted(set(seq)))
        self._db.execute("""insert into seqinfo (seq_id, len, alpha, relpath)
                         values (?, ?, ?,?)""", (seq_id, len(seq), alpha, self._writing["relpath"]))
        return seq_id


Instruction:
Can you generate a brief explanation for the following Python 3 code
def copy_to(source, dest, engine_or_conn, **flags):
    dialect = postgresql.dialect()
    statement = getattr(source, 'statement', source)
    compiled = statement.compile(dialect=dialect)
    conn, autoclose = raw_connection_from(engine_or_conn)
    cursor = conn.cursor()
    query = cursor.mogrify(compiled.string, compiled.params).decode()
    formatted_flags = '({})'.format(format_flags(flags)) if flags else ''
    copy = 'COPY ({}) TO STDOUT {}'.format(query, formatted_flags)
    cursor.copy_expert(copy, dest)
    if autoclose:
        conn.close()

Response: Export a SQLAlchemy query or select to a file.


Instruction:
Create a Python 3 function for
copying a table from a source file to a destination file.

Response:
def copy_from(source, dest, engine_or_conn, columns=(), **flags):
    """Import a table from a file. For flags, see the PostgreSQL documentation
    at http://www.postgresql.org/docs/9.5/static/sql-copy.html.

    Examples: ::
        with open('/path/to/file.tsv') as fp:
            copy_from(fp, MyTable, conn)

        with open('/path/to/file.csv') as fp:
            copy_from(fp, MyModel, engine, format='csv')

    :param source: Source file pointer, in read mode
    :param dest: SQLAlchemy model or table
    :param engine_or_conn: SQLAlchemy engine, connection, or raw_connection
    :param columns: Optional tuple of columns
    :param **flags: Options passed through to COPY

    If an existing connection is passed to `engine_or_conn`, it is the caller's
    responsibility to commit and close.

    The `columns` flag can be set to a tuple of strings to specify the column
    order. Passing `header` alone will not handle out of order columns, it simply tells
    postgres to ignore the first line of `source`.
    """
    tbl = dest.__table__ if is_model(dest) else dest
    conn, autoclose = raw_connection_from(engine_or_conn)
    cursor = conn.cursor()
    relation = '.'.join('"{}"'.format(part) for part in (tbl.schema, tbl.name) if part)
    formatted_columns = '({})'.format(','.join(columns)) if columns else ''
    formatted_flags = '({})'.format(format_flags(flags)) if flags else ''
    copy = 'COPY {} {} FROM STDIN {}'.format(
        relation,
        formatted_columns,
        formatted_flags,
    )
    cursor.copy_expert(copy, source)
    if autoclose:
        conn.commit()
        conn.close()


Instruction:
How would you implement a function in Python 3 that
extracts a raw_connection and determine if it should be automatically closed.

Response:
def raw_connection_from(engine_or_conn):
    """Extract a raw_connection and determine if it should be automatically closed.

    Only connections opened by this package will be closed automatically.
    """
    if hasattr(engine_or_conn, 'cursor'):
        return engine_or_conn, False
    if hasattr(engine_or_conn, 'connection'):
        return engine_or_conn.connection, False
    return engine_or_conn.raw_connection(), True


Instruction:
Can you generate the documentation for the following Python 3 function
def fetch_in_thread(sr, nsa):

    def fetch_seq(q, nsa):
        pid, ppid = os.getpid(), os.getppid()
        q.put((pid, ppid, sr[nsa]))

    q = Queue()
    p = Process(target=fetch_seq, args=(q, nsa))
    p.start()
    pid, ppid, seq = q.get()
    p.join()

    assert pid != ppid, "sequence was not fetched from thread"
    return pid, ppid, seq

Response: fetch a sequence in a thread


Instruction:
Write a Python 3 function for
downloading and install RPM Python binding.

Response:
def download_and_install(self):
        """Download and install RPM Python binding."""
        if self.is_installed_from_bin:
            try:
                self.installer.install_from_rpm_py_package()
                return
            except RpmPyPackageNotFoundError as e:
                Log.warn('RPM Py Package not found. reason: {0}'.format(e))

                # Pass to try to install from the source.
                pass

        # Download and install from the source.
        top_dir_name = self.downloader.download_and_expand()
        rpm_py_dir = os.path.join(top_dir_name, 'python')

        setup_py_in_found = False
        with Cmd.pushd(rpm_py_dir):
            if self.installer.setup_py.exists_in_path():
                setup_py_in_found = True
                self.installer.run()

        if not setup_py_in_found:
            self.installer.install_from_rpm_py_package()


Instruction:
Can you tell what is the following Python 3 function doing
def add_patchs_to_build_without_pkg_config(self, lib_dir, include_dir):
        additional_patches = [
            {
                'src': r"pkgconfig\('--libs-only-L'\)",
                'dest': "['{0}']".format(lib_dir),
            },
            # Considering -libs-only-l and -libs-only-L
            # https://github.com/rpm-software-management/rpm/pull/327
            {
                'src': r"pkgconfig\('--libs(-only-l)?'\)",
                'dest': "['rpm', 'rpmio']",
                'required': True,
            },
            {
                'src': r"pkgconfig\('--cflags'\)",
                'dest': "['{0}']".format(include_dir),
                'required': True,
            },
        ]
        self.patches.extend(additional_patches)

Response: Add patches to remove pkg - config command and rpm. pc part.


Instruction:
Can you create a Python 3 function that
applies replaced words and patches and save setup. py file.

Response:
def apply_and_save(self):
        """Apply replaced words and patches, and save setup.py file."""
        patches = self.patches

        content = None
        with open(self.IN_PATH) as f_in:
            # As setup.py.in file size is 2.4 KByte.
            # it's fine to read entire content.
            content = f_in.read()

        # Replace words.
        for key in self.replaced_word_dict:
            content = content.replace(key, self.replaced_word_dict[key])

        # Apply patches.
        out_patches = []
        for patch in patches:
            pattern = re.compile(patch['src'], re.MULTILINE)
            (content, subs_num) = re.subn(pattern, patch['dest'],
                                          content)
            if subs_num > 0:
                patch['applied'] = True
            out_patches.append(patch)

        for patch in out_patches:
            if patch.get('required') and not patch.get('applied'):
                Log.warn('Patch not applied {0}'.format(patch['src']))

        with open(self.OUT_PATH, 'w') as f_out:
            f_out.write(content)

        self.pathces = out_patches
        # Release content data to make it released by GC quickly.
        content = None


Instruction:
Given the following Python 3 function, write the documentation
def download_and_expand(self):
        top_dir_name = None
        if self.git_branch:
            # Download a source by git clone.
            top_dir_name = self._download_and_expand_by_git()
        else:
            # Download a source from the arcihve URL.
            # Downloading the compressed archive is better than "git clone",
            # because it is faster.
            # If download failed due to URL not found, try "git clone".
            try:
                top_dir_name = self._download_and_expand_from_archive_url()
            except RemoteFileNotFoundError:
                Log.info('Try to download by git clone.')
                top_dir_name = self._download_and_expand_by_git()
        return top_dir_name

Response: Download and expand RPM Python binding.


Instruction:
Create a Python 3 function to
run the install main logic.

Response:
def run(self):
        """Run install main logic."""
        self._make_lib_file_symbolic_links()
        self._copy_each_include_files_to_include_dir()
        self._make_dep_lib_file_sym_links_and_copy_include_files()
        self.setup_py.add_patchs_to_build_without_pkg_config(
            self.rpm.lib_dir, self.rpm.include_dir
        )
        self.setup_py.apply_and_save()
        self._build_and_install()


Instruction:
Can you implement a function in Python 3 that
makes symbolic links for lib files.

Response:
def _make_lib_file_symbolic_links(self):
        """Make symbolic links for lib files.

        Make symbolic links from system library files or downloaded lib files
        to downloaded source library files.

        For example, case: Fedora x86_64
        Make symbolic links
        from
            a. /usr/lib64/librpmio.so* (one of them)
            b. /usr/lib64/librpm.so* (one of them)
            c. If rpm-build-libs package is installed,
               /usr/lib64/librpmbuild.so* (one of them)
               otherwise, downloaded and extracted rpm-build-libs.
               ./usr/lib64/librpmbuild.so* (one of them)
            c. If rpm-build-libs package is installed,
               /usr/lib64/librpmsign.so* (one of them)
               otherwise, downloaded and extracted rpm-build-libs.
               ./usr/lib64/librpmsign.so* (one of them)
        to
            a. rpm/rpmio/.libs/librpmio.so
            b. rpm/lib/.libs/librpm.so
            c. rpm/build/.libs/librpmbuild.so
            d. rpm/sign/.libs/librpmsign.so
        .
        This is a status after running "make" on actual rpm build process.
        """
        so_file_dict = {
            'rpmio': {
                'sym_src_dir': self.rpm.lib_dir,
                'sym_dst_dir': 'rpmio/.libs',
                'require': True,
            },
            'rpm': {
                'sym_src_dir': self.rpm.lib_dir,
                'sym_dst_dir': 'lib/.libs',
                'require': True,
            },
            'rpmbuild': {
                'sym_src_dir': self.rpm.lib_dir,
                'sym_dst_dir': 'build/.libs',
                'require': True,
            },
            'rpmsign': {
                'sym_src_dir': self.rpm.lib_dir,
                'sym_dst_dir': 'sign/.libs',
            },
        }

        self._update_sym_src_dirs_conditionally(so_file_dict)

        for name in so_file_dict:
            so_dict = so_file_dict[name]
            pattern = 'lib{0}.so*'.format(name)
            so_files = Cmd.find(so_dict['sym_src_dir'], pattern)
            if not so_files:
                is_required = so_dict.get('require', False)
                if not is_required:
                    message_format = (
                        "Skip creating symbolic link of "
                        "not existing so file '{0}'"
                    )
                    Log.debug(message_format.format(name))
                    continue

                message = 'so file pattern {0} not found at {1}'.format(
                    pattern, so_dict['sym_src_dir']
                )
                raise InstallError(message)
            sym_dst_dir = os.path.abspath('../{0}'.format(
                                           so_dict['sym_dst_dir']))
            if not os.path.isdir(sym_dst_dir):
                Cmd.mkdir_p(sym_dst_dir)

            cmd = 'ln -sf {0} {1}/lib{2}.so'.format(so_files[0],
                                                    sym_dst_dir,
                                                    name)
            Cmd.sh_e(cmd)


Instruction:
Make a summary of the following Python 3 code
def _copy_each_include_files_to_include_dir(self):
        src_header_dirs = [
            'rpmio',
            'lib',
            'build',
            'sign',
        ]
        with Cmd.pushd('..'):
            src_include_dir = os.path.abspath('./include')
            for header_dir in src_header_dirs:
                if not os.path.isdir(header_dir):
                    message_format = "Skip not existing header directory '{0}'"
                    Log.debug(message_format.format(header_dir))
                    continue
                header_files = Cmd.find(header_dir, '*.h')
                for header_file in header_files:
                    pattern = '^{0}/'.format(header_dir)
                    (dst_header_file, subs_num) = re.subn(pattern,
                                                          '', header_file)
                    if subs_num == 0:
                        message = 'Failed to replace header_file: {0}'.format(
                            header_file)
                        raise ValueError(message)
                    dst_header_file = os.path.abspath(
                        os.path.join(src_include_dir, 'rpm', dst_header_file)
                    )
                    dst_dir = os.path.dirname(dst_header_file)
                    if not os.path.isdir(dst_dir):
                        Cmd.mkdir_p(dst_dir)
                    shutil.copyfile(header_file, dst_header_file)

Response: Copy each header file from the source directory to the destination directory.


Instruction:
Explain what the following Python 3 code does
def _make_dep_lib_file_sym_links_and_copy_include_files(self):
        if not self._rpm_py_has_popt_devel_dep():
            message = (
                'The RPM Python binding does not have popt-devel dependency'
            )
            Log.debug(message)
            return
        if self._is_popt_devel_installed():
            message = '{0} package is installed.'.format(
                self.pacakge_popt_devel_name)
            Log.debug(message)
            return
        if not self._is_package_downloadable():
            message = '''
Install a {0} download plugin or
install the {0} pacakge [{1}].
'''.format(self.package_sys_name, self.pacakge_popt_devel_name)
            raise InstallError(message)
        if not self._is_popt_installed():
            message = '''
Required {0} not installed: [{1}],
Install the {0} package.
'''.format(self.package_sys_name, self.pacakge_popt_name)
            raise InstallError(message)

        self._download_and_extract_popt_devel()

        # Copy libpopt.so to rpm_root/lib/.libs/.
        popt_lib_dirs = [
            self.rpm.lib_dir,
            # /lib64/libpopt.so* installed at popt-1.13-7.el6.x86_64.
            '/lib64',
            # /lib/*/libpopt.so* installed at libpopt0-1.16-8ubuntu1
            '/lib',
        ]
        pattern = 'libpopt.so*'
        popt_so_file = None
        for popt_lib_dir in popt_lib_dirs:
            so_files = Cmd.find(popt_lib_dir, pattern)
            if so_files:
                popt_so_file = so_files[0]
                break

        if not popt_so_file:
            message = 'so file pattern {0} not found at {1}'.format(
                pattern, str(popt_lib_dirs)
            )
            raise InstallError(message)

        cmd = 'ln -sf {0} ../lib/.libs/libpopt.so'.format(
               popt_so_file)
        Cmd.sh_e(cmd)

        # Copy popt.h to rpm_root/include
        shutil.copy('./usr/include/popt.h', '../include')

Response: Make symbolic links for lib files and copy include files.


Instruction:
Create a Python 3 function for
checking if the RPM Python binding has a depndency to popt - devel.

Response:
def _rpm_py_has_popt_devel_dep(self):
        """Check if the RPM Python binding has a depndency to popt-devel.

        Search include header files in the source code to check it.
        """
        found = False
        with open('../include/rpm/rpmlib.h') as f_in:
            for line in f_in:
                if re.match(r'^#include .*popt.h.*$', line):
                    found = True
                    break
        return found


Instruction:
Make a summary of the following Python 3 code
def run(self):
        try:
            if not self._is_rpm_all_lib_include_files_installed():
                self._make_lib_file_symbolic_links()
                self._copy_each_include_files_to_include_dir()
                self._make_dep_lib_file_sym_links_and_copy_include_files()
                self.setup_py.add_patchs_to_build_without_pkg_config(
                    self.rpm.lib_dir, self.rpm.include_dir
                )
            self.setup_py.apply_and_save()
            self._build_and_install()
        except InstallError as e:
            if not self._is_rpm_all_lib_include_files_installed():
                org_message = str(e)
                message = '''
Install failed without rpm-devel package by below reason.
Can you install the RPM package, and run this installer again?
'''
                message += org_message
                raise InstallError(message)
            else:
                raise e

Response: Run the main logic.


Instruction:
Explain what the following Python 3 code does
def install_from_rpm_py_package(self):
        self._download_and_extract_rpm_py_package()

        # Find ./usr/lib64/pythonN.N/site-packages/rpm directory.
        # A binary built by same version Python with used Python is target
        # for the safe installation.

        if self.rpm.has_set_up_py_in():
            # If RPM has setup.py.in, this strict check is okay.
            # Because we can still install from the source.
            py_dir_name = 'python{0}.{1}'.format(
                          sys.version_info[0], sys.version_info[1])
        else:
            # If RPM does not have setup.py.in such as CentOS6,
            # Only way to install is by different Python's RPM package.
            py_dir_name = '*'

        python_lib_dir_pattern = os.path.join(
                                'usr', '*', py_dir_name, 'site-packages')
        rpm_dir_pattern = os.path.join(python_lib_dir_pattern, 'rpm')
        downloaded_rpm_dirs = glob.glob(rpm_dir_pattern)
        if not downloaded_rpm_dirs:
            message = 'Directory with a pattern: {0} not found.'.format(
                    rpm_dir_pattern)
            raise RpmPyPackageNotFoundError(message)
        src_rpm_dir = downloaded_rpm_dirs[0]

        # Remove rpm directory for the possible installed directories.
        for rpm_dir in self.python.python_lib_rpm_dirs:
            if os.path.isdir(rpm_dir):
                Log.debug("Remove existing rpm directory {0}".format(rpm_dir))
                shutil.rmtree(rpm_dir)

        dst_rpm_dir = self.python.python_lib_rpm_dir
        Log.debug("Copy directory from '{0}' to '{1}'".format(
                  src_rpm_dir, dst_rpm_dir))
        shutil.copytree(src_rpm_dir, dst_rpm_dir)

        file_name_pattern = 'rpm-*.egg-info'
        rpm_egg_info_pattern = os.path.join(
                               python_lib_dir_pattern, file_name_pattern)
        downloaded_rpm_egg_infos = glob.glob(rpm_egg_info_pattern)
        if downloaded_rpm_egg_infos:
            existing_rpm_egg_info_pattern = os.path.join(
                self.python.python_lib_dir, file_name_pattern)
            existing_rpm_egg_infos = glob.glob(existing_rpm_egg_info_pattern)
            for existing_rpm_egg_info in existing_rpm_egg_infos:
                Log.debug("Remove existing rpm egg info file '{0}'".format(
                          existing_rpm_egg_info))
                os.remove(existing_rpm_egg_info)

            Log.debug("Copy file from '{0}' to '{1}'".format(
                      downloaded_rpm_egg_infos[0], self.python.python_lib_dir))
            shutil.copy2(downloaded_rpm_egg_infos[0],
                         self.python.python_lib_dir)

Response: Run install from RPM Python binding RPM package.


Instruction:
How would you code a function in Python 3 to
verify dependency RPM package status.

Response:
def verify_package_status(self):
        """Verify dependency RPM package status."""
        # rpm-libs is required for /usr/lib64/librpm*.so
        self.rpm.verify_packages_installed(['rpm-libs'])

        # Check RPM so files to build the Python binding.
        message_format = '''
RPM: {0} or
RPM download tool (dnf-plugins-core (dnf) or yum-utils (yum)) required.
Install any of those.
'''
        if self.rpm.has_composed_rpm_bulid_libs():
            if (not self.rpm.is_package_installed('rpm-build-libs')
               and not self.rpm.is_downloadable()):
                raise InstallError(message_format.format('rpm-build-libs'))
        else:
            # All the needed so files are included in rpm-libs package.
            pass


Instruction:
How would you explain what the following Python 3 function does
def create_installer(self, rpm_py_version, **kwargs):
        return FedoraInstaller(rpm_py_version, self.python, self.rpm, **kwargs)

Response: Create an Installer object.


Instruction:
Can you generate the documentation for the following Python 3 function
def python_lib_rpm_dirs(self):
        libs = [self.python_lib_arch_dir, self.python_lib_non_arch_dir]

        def append_rpm(path):
            return os.path.join(path, 'rpm')

        return map(append_rpm, libs)

Response: Both arch and non - arch site - packages directories.


Instruction:
Can you tell what is the following Python 3 function doing
def is_python_binding_installed(self):
        is_installed = False
        is_install_error = False

        try:
            is_installed = self.is_python_binding_installed_on_pip()
        except InstallError:
            # Consider a case of pip is not installed in old Python (<= 2.6).
            is_install_error = True
        if not is_installed or is_install_error:
            for rpm_dir in self.python_lib_rpm_dirs:
                init_py = os.path.join(rpm_dir, '__init__.py')
                if os.path.isfile(init_py):
                    is_installed = True
                    break

        return is_installed

Response: Check if the Python binding is already installed.


Instruction:
Implement a function in Python 3 to
check if the Python binding has already been installed on pip.

Response:
def is_python_binding_installed_on_pip(self):
        """Check if the Python binding has already installed."""
        pip_version = self._get_pip_version()
        Log.debug('Pip version: {0}'.format(pip_version))
        pip_major_version = int(pip_version.split('.')[0])

        installed = False
        # --format is from pip v9.0.0
        # https://pip.pypa.io/en/stable/news/
        if pip_major_version >= 9:
            json_obj = self._get_pip_list_json_obj()

            for package in json_obj:
                Log.debug('pip list: {0}'.format(package))
                if package['name'] in ('rpm-python', 'rpm'):
                    installed = True
                    Log.debug('Package installed: {0}, {1}'.format(
                              package['name'], package['version']))
                    break
        else:
            # Implementation for pip old version.
            # It will be removed in the future.
            lines = self._get_pip_list_lines()
            for line in lines:
                if re.match('^rpm(-python)? ', line):
                    installed = True
                    Log.debug('Package installed.')
                    break

        return installed


Instruction:
Can you implement a function in Python 3 that
gets the version of the RPM.

Response:
def version(self):
        """RPM vesion string."""
        stdout = Cmd.sh_e_out('{0} --version'.format(self.rpm_path))
        rpm_version = stdout.split()[2]
        return rpm_version


Instruction:
Implement a function in Python 3 to
check if the RPM is system RPM.

Response:
def is_system_rpm(self):
        """Check if the RPM is system RPM."""
        sys_rpm_paths = [
            '/usr/bin/rpm',
            # On CentOS6, system RPM is installed in this directory.
            '/bin/rpm',
        ]
        matched = False
        for sys_rpm_path in sys_rpm_paths:
            if self.rpm_path.startswith(sys_rpm_path):
                matched = True
                break
        return matched


Instruction:
Can you create a Python 3 function that
checks if the RPM package is installed.

Response:
def is_package_installed(self, package_name):
        """Check if the RPM package is installed."""
        if not package_name:
            raise ValueError('package_name required.')

        installed = True
        try:
            Cmd.sh_e('{0} --query {1} --quiet'.format(self.rpm_path,
                                                      package_name))
        except InstallError:
            installed = False
        return installed


Instruction:
How would you code a function in Python 3 to
check if the RPM packages are installed. Raise InstallError if any of the packages are not installed.

Response:
def verify_packages_installed(self, package_names):
        """Check if the RPM packages are installed.

        Raise InstallError if any of the packages is not installed.
        """
        if not package_names:
            raise ValueError('package_names required.')

        missing_packages = []
        for package_name in package_names:
            if not self.is_package_installed(package_name):
                missing_packages.append(package_name)

        if missing_packages:
            comma_packages = ', '.join(missing_packages)
            message = '''
Required RPM not installed: [{0}].
Install the RPM package.
'''.format(comma_packages)
            raise InstallError(message)


Instruction:
Can you generate the documentation for the following Python 3 function
def lib_dir(self):
        if not self._lib_dir:
            rpm_lib_dir = None
            cmd = '{0} -ql rpm-libs'.format(self.rpm_path)
            out = Cmd.sh_e_out(cmd)
            lines = out.split('\n')
            for line in lines:
                if 'librpm.so' in line:
                    rpm_lib_dir = os.path.dirname(line)
                    break
            self._lib_dir = rpm_lib_dir
        return self._lib_dir

Response: Return the path to the standard library directory used by RPM libs.


Instruction:
Write a Python 3 script for
returning if rpm is downloadable by the package command.

Response:
def is_downloadable(self):
        """Return if rpm is downloadable by the package command.

        Check if dnf or yum plugin package exists.
        """
        is_plugin_avaiable = False
        if self.is_dnf:
            is_plugin_avaiable = self.is_package_installed(
                                 'dnf-plugins-core')
        else:
            """ yum environment.
            Make sure
            # yum -y --downloadonly --downloaddir=. install package_name
            is only available for root user.

            yumdownloader in yum-utils is available for normal user.
            https://access.redhat.com/solutions/10154
            """
            is_plugin_avaiable = self.is_package_installed(
                                 'yum-utils')
        return is_plugin_avaiable


Instruction:
Given the following Python 3 function, write the documentation
def lib_dir(self):
        if not self._lib_dir:
            lib_files = glob.glob("/usr/lib/*/librpm.so*")
            if not lib_files:
                raise InstallError("Can not find lib directory.")
            self._lib_dir = os.path.dirname(lib_files[0])
        return self._lib_dir

Response: Return standard library directory path used by RPM libs.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def sh_e(cls, cmd, **kwargs):
        Log.debug('CMD: {0}'.format(cmd))
        cmd_kwargs = {
            'shell': True,
        }
        cmd_kwargs.update(kwargs)

        env = os.environ.copy()
        # Better to parse English output
        env['LC_ALL'] = 'en_US.utf-8'
        if 'env' in kwargs:
            env.update(kwargs['env'])
        cmd_kwargs['env'] = env
        # Capture stderr to show it on error message.
        cmd_kwargs['stderr'] = subprocess.PIPE

        proc = None
        try:
            proc = subprocess.Popen(cmd, **cmd_kwargs)
            stdout, stderr = proc.communicate()
            returncode = proc.returncode
            message_format = (
                'CMD Return Code: [{0}], Stdout: [{1}], Stderr: [{2}]'
            )
            Log.debug(message_format.format(returncode, stdout, stderr))

            if stdout is not None:
                stdout = stdout.decode('utf-8')
            if stderr is not None:
                stderr = stderr.decode('utf-8')

            if returncode != 0:
                message = 'CMD: [{0}], Return Code: [{1}] at [{2}]'.format(
                    cmd, returncode, os.getcwd())
                if stderr is not None:
                    message += ' Stderr: [{0}]'.format(stderr)
                ie = CmdError(message)
                ie.stdout = stdout
                ie.stderr = stderr
                raise ie

            return (stdout, stderr)
        except Exception as e:
            try:
                proc.kill()
            except Exception:
                pass
            raise e

Response: Runs the command and returns stdout and stderr.


Instruction:
Create a Python 3 function for
running the command and returns the stdout.

Response:
def sh_e_out(cls, cmd, **kwargs):
        """Run the command. and returns the stdout."""
        cmd_kwargs = {
            'stdout': subprocess.PIPE,
        }
        cmd_kwargs.update(kwargs)
        return cls.sh_e(cmd, **cmd_kwargs)[0]


Instruction:
Create a Python 3 function to
change directory. It behaves like cd directory

Response:
def cd(cls, directory):
        """Change directory. It behaves like "cd directory"."""
        Log.debug('CMD: cd {0}'.format(directory))
        os.chdir(directory)


Instruction:
Write a Python 3 function for
changing directory and back to previous directory.

Response:
def pushd(cls, new_dir):
        """Change directory, and back to previous directory.

        It behaves like "pushd directory; something; popd".
        """
        previous_dir = os.getcwd()
        try:
            new_ab_dir = None
            if os.path.isabs(new_dir):
                new_ab_dir = new_dir
            else:
                new_ab_dir = os.path.join(previous_dir, new_dir)
            # Use absolute path to show it on FileNotFoundError message.
            cls.cd(new_ab_dir)
            yield
        finally:
            cls.cd(previous_dir)


Instruction:
Write a Python 3 function that can
return an absolute path of the command. It behaves like which command.

Response:
def which(cls, cmd):
        """Return an absolute path of the command.

        It behaves like "which command".
        """
        abs_path_cmd = None
        if sys.version_info >= (3, 3):
            abs_path_cmd = shutil.which(cmd)
        else:
            abs_path_cmd = find_executable(cmd)
        return abs_path_cmd


Instruction:
How would you explain what the following Python 3 function does
def curl_remote_name(cls, file_url):
        tar_gz_file_name = file_url.split('/')[-1]

        if sys.version_info >= (3, 2):
            from urllib.request import urlopen
            from urllib.error import HTTPError
        else:
            from urllib2 import urlopen
            from urllib2 import HTTPError

        response = None
        try:
            response = urlopen(file_url)
        except HTTPError as e:
            message = 'Download failed: URL: {0}, reason: {1}'.format(
                      file_url, e)
            if 'HTTP Error 404' in str(e):
                raise RemoteFileNotFoundError(message)
            else:
                raise InstallError(message)

        tar_gz_file_obj = io.BytesIO(response.read())
        with open(tar_gz_file_name, 'wb') as f_out:
            f_out.write(tar_gz_file_obj.read())
        return tar_gz_file_name

Response: Download file_url and save as a file name of the URL. It behaves like curl - O or -- remote - name.


Instruction:
Implement a Python 3 function for
extracting tar. gz or tar. bz2 file.

Response:
def tar_extract(cls, tar_comp_file_path):
        """Extract tar.gz or tar bz2 file.

        It behaves like
          - tar xzf tar_gz_file_path
          - tar xjf tar_bz2_file_path
        It raises tarfile.ReadError if the file is broken.
        """
        try:
            with contextlib.closing(tarfile.open(tar_comp_file_path)) as tar:
                tar.extractall()
        except tarfile.ReadError as e:
            message_format = (
                'Extract failed: '
                'tar_comp_file_path: {0}, reason: {1}'
            )
            raise InstallError(message_format.format(tar_comp_file_path, e))


Instruction:
Can you write a function in Python 3 where it
finds matched files. It does not include symbolic file in the result.

Response:
def find(cls, searched_dir, pattern):
        """Find matched files.

        It does not include symbolic file in the result.
        """
        Log.debug('find {0} with pattern: {1}'.format(searched_dir, pattern))
        matched_files = []
        for root_dir, dir_names, file_names in os.walk(searched_dir,
                                                       followlinks=False):
            for file_name in file_names:
                if fnmatch.fnmatch(file_name, pattern):
                    file_path = os.path.join(root_dir, file_name)
                    if not os.path.islink(file_path):
                        matched_files.append(file_path)
        matched_files.sort()
        return matched_files


Instruction:
Can you generate a brief explanation for the following Python 3 code
def version_str2tuple(cls, version_str):
        if not isinstance(version_str, str):
            ValueError('version_str invalid instance.')
        version_info_list = re.findall(r'[0-9a-zA-Z]+', version_str)

        def convert_to_int(string):
            value = None
            if re.match(r'^\d+$', string):
                value = int(string)
            else:
                value = string
            return value

        version_info_list = [convert_to_int(s) for s in version_info_list]

        return tuple(version_info_list)

Response: Convert version string to tuple object. ex. 4 14 0 rc1.


Instruction:
How would you explain what the following Python 3 function does
def which(file):
    for path in os.environ["PATH"].split(os.pathsep):
        if os.path.exists(os.path.join(path, file)):
                return os.path.join(path, file)
    return None

Response: Return the path to a file in the system.


Instruction:
Given the following Python 3 function, write the documentation
def install_rpm_py():
    python_path = sys.executable
    cmd = '{0} install.py'.format(python_path)
    exit_status = os.system(cmd)
    if exit_status != 0:
        raise Exception('Command failed: {0}'.format(cmd))

Response: Install RPM Python binding.


Instruction:
Create a Python 3 function to
return bgzip version as string

Response:
def _get_bgzip_version(exe):
    """return bgzip version as string"""
    p = subprocess.Popen([exe, "-h"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True)
    output = p.communicate()
    version_line = output[0].splitlines()[1]
    version = re.match(r"(?:Version:|bgzip \(htslib\))\s+(\d+\.\d+(\.\d+)?)", version_line).group(1)
    return version


Instruction:
Write a Python 3 script for
finding the bgzip executable and check if it meets version requirements

Response:
def _find_bgzip():
    """return path to bgzip if found and meets version requirements, else exception"""
    missing_file_exception = OSError if six.PY2 else FileNotFoundError
    min_bgzip_version = ".".join(map(str, min_bgzip_version_info))
    exe = os.environ.get("SEQREPO_BGZIP_PATH", which("bgzip") or "/usr/bin/bgzip")

    try:
        bgzip_version = _get_bgzip_version(exe)
    except AttributeError:
        raise RuntimeError("Didn't find version string in bgzip executable ({exe})".format(exe=exe))
    except missing_file_exception:
        raise RuntimeError("{exe} doesn't exist; you need to install htslib (See https://github.com/biocommons/biocommons.seqrepo#requirements)".format(exe=exe))
    except Exception:
        raise RuntimeError("Unknown error while executing {exe}".format(exe=exe))
    bgzip_version_info = tuple(map(int, bgzip_version.split(".")))
    if bgzip_version_info < min_bgzip_version_info:
        raise RuntimeError("bgzip ({exe}) {ev} is too old; >= {rv} is required; please upgrade".format(
            exe=exe, ev=bgzip_version, rv=min_bgzip_version))
    logger.info("Using bgzip {ev} ({exe})".format(ev=bgzip_version, exe=exe))
    return exe


Instruction:
Can you generate a brief explanation for the following Python 3 code
def fetch_uri(self, uri, start=None, end=None):

        namespace, alias = uri_re.match(uri).groups()
        return self.fetch(alias=alias, namespace=namespace, start=start, end=end)

Response: fetch sequence for URI


Instruction:
Can you tell what is the following Python 3 function doing
def store(self, seq, nsaliases):
        if not self._writeable:
            raise RuntimeError("Cannot write -- opened read-only")

        if self._upcase:
            seq = seq.upper()

        try:
            seqhash = bioutils.digests.seq_seqhash(seq)
        except Exception as e:
            import pprint
            _logger.critical("Exception raised for " + pprint.pformat(nsaliases))
            raise
        seq_id = seqhash

        # add sequence if not present
        n_seqs_added = n_aliases_added = 0
        msg = "sh{nsa_sep}{seq_id:.10s}... ({l} residues; {na} aliases {aliases})".format(
            seq_id=seq_id,
            l=len(seq),
            na=len(nsaliases),
            nsa_sep=nsa_sep,
            aliases=", ".join("{nsa[namespace]}:{nsa[alias]}".format(nsa=nsa) for nsa in nsaliases))
        if seq_id not in self.sequences:
            _logger.info("Storing " + msg)
            if len(seq) > ct_n_residues:    # pragma: no cover
                _logger.debug("Precommit for large sequence")
                self.commit()
            self.sequences.store(seq_id, seq)
            n_seqs_added += 1
            self._pending_sequences += 1
            self._pending_sequences_len += len(seq)
            self._pending_aliases += self._update_digest_aliases(seq_id, seq)
        else:
            _logger.debug("Sequence exists: " + msg)

        # add/update external aliases for new and existing sequences
        # updating is optimized to load only new <seq_id,ns,alias> tuples
        existing_aliases = self.aliases.fetch_aliases(seq_id)
        ea_tuples = [(r["seq_id"], r["namespace"], r["alias"]) for r in existing_aliases]
        new_tuples = [(seq_id, r["namespace"], r["alias"]) for r in nsaliases]
        upd_tuples = set(new_tuples) - set(ea_tuples)
        if upd_tuples:
            _logger.info("{} new aliases for {}".format(len(upd_tuples), msg))
            for _, namespace, alias in upd_tuples:
                self.aliases.store_alias(seq_id=seq_id, namespace=namespace, alias=alias)
            self._pending_aliases += len(upd_tuples)
            n_aliases_added += len(upd_tuples)
        if (self._pending_sequences > ct_n_seqs or self._pending_aliases > ct_n_aliases
                or self._pending_sequences_len > ct_n_residues):    # pragma: no cover
            _logger.info("Hit commit thresholds ({self._pending_sequences} sequences, "
                        "{self._pending_aliases} aliases, {self._pending_sequences_len} residues)".format(self=self))
            self.commit()
        return n_seqs_added, n_aliases_added

Response: Store a sequence into the internal cache.


Instruction:
Create a Python 3 function to
give an alias and optional namespace return a list of all other aliases for same sequence

Response:
def translate_alias(self, alias, namespace=None, target_namespaces=None, translate_ncbi_namespace=None):
        """given an alias and optional namespace, return a list of all other
        aliases for same sequence

        """

        if translate_ncbi_namespace is None:
            translate_ncbi_namespace = self.translate_ncbi_namespace
        seq_id = self._get_unique_seqid(alias=alias, namespace=namespace)
        aliases = self.aliases.fetch_aliases(seq_id=seq_id,
                                             translate_ncbi_namespace=translate_ncbi_namespace)
        if target_namespaces:
            aliases = [a for a in aliases if a["namespace"] in target_namespaces]
        return aliases


Instruction:
Write a Python 3 function that can
give a string identifier return a list of aliases that refer to the same sequence.

Response:
def translate_identifier(self, identifier, target_namespaces=None, translate_ncbi_namespace=None):
        """Given a string identifier, return a list of aliases (as
        identifiers) that refer to the same sequence.

        """
        namespace, alias = identifier.split(nsa_sep) if nsa_sep in identifier else (None, identifier)
        aliases = self.translate_alias(alias=alias,
                                       namespace=namespace,
                                       target_namespaces=target_namespaces,
                                       translate_ncbi_namespace=translate_ncbi_namespace)
        return [nsa_sep.join((a["namespace"], a["alias"])) for a in aliases]


Instruction:
Can you tell what is the following Python 3 function doing
def _get_unique_seqid(self, alias, namespace):

        recs = self.aliases.find_aliases(alias=alias, namespace=namespace)
        seq_ids = set(r["seq_id"] for r in recs)
        if len(seq_ids) == 0:
            raise KeyError("Alias {} (namespace: {})".format(alias, namespace))
        if len(seq_ids) > 1:
            # This should only happen when namespace is None
            raise KeyError("Alias {} (namespace: {}): not unique".format(alias, namespace))
        return seq_ids.pop()

Response: given alias and namespace return unique sequence id


Instruction:
Create a Python 3 function for
computing digest aliases for seq and update

Response:
def _update_digest_aliases(self, seq_id, seq):

        """compute digest aliases for seq and update; returns number of digest
        aliases (some of which may have already existed)

        For the moment, sha512 is computed for seq_id separately from
        the sha512 here.  We should fix that.

        """

        ir = bioutils.digests.seq_vmc_identifier(seq)
        seq_aliases = [
            {
                "namespace": ir["namespace"],
                "alias": ir["accession"],
            },
            {
                "namespace": "SHA1",
                "alias": bioutils.digests.seq_sha1(seq)
            },
            {
                "namespace": "MD5",
                "alias": bioutils.digests.seq_md5(seq)
            },
            {
                "namespace": "SEGUID",
                "alias": bioutils.digests.seq_seguid(seq)
            },
        ]
        for sa in seq_aliases:
            self.aliases.store_alias(seq_id=seq_id, **sa)
        return len(seq_aliases)


Instruction:
Here you have a function in Python 3, explain what it does
def fetch_aliases(self, seq_id, current_only=True, translate_ncbi_namespace=None):
        return [dict(r) for r in self.find_aliases(seq_id=seq_id,
                                                   current_only=current_only,
                                                   translate_ncbi_namespace=translate_ncbi_namespace)]

Response: return list of alias annotation records for a given sequence id


Instruction:
Write a Python 3 script to
return iterator over alias annotation records that match criteria

Response:
def find_aliases(self, seq_id=None, namespace=None, alias=None, current_only=True, translate_ncbi_namespace=None):
        """returns iterator over alias annotation records that match criteria

        The arguments, all optional, restrict the records that are
        returned.  Without arguments, all aliases are returned.

        If arguments contain %, the `like` comparison operator is
        used.  Otherwise arguments must match exactly.

        """
        clauses = []
        params = []

        def eq_or_like(s):
            return "like" if "%" in s else "="

        if translate_ncbi_namespace is None:
            translate_ncbi_namespace = self.translate_ncbi_namespace
        if alias is not None:
            clauses += ["alias {} ?".format(eq_or_like(alias))]
            params += [alias]
        if namespace is not None:
            # Switch to using RefSeq for RefSeq accessions
            # issue #38: translate "RefSeq" to "NCBI" to enable RefSeq lookups
            # issue #31: later breaking change, translate database
            if namespace == "RefSeq":
                namespace = "NCBI"
            clauses += ["namespace {} ?".format(eq_or_like(namespace))]
            params += [namespace]
        if seq_id is not None:
            clauses += ["seq_id {} ?".format(eq_or_like(seq_id))]
            params += [seq_id]
        if current_only:
            clauses += ["is_current = 1"]

        cols = ["seqalias_id", "seq_id", "alias", "added", "is_current"]
        if translate_ncbi_namespace:
            cols += ["case namespace when 'NCBI' then 'RefSeq' else namespace end as namespace"]
        else:
            cols += ["namespace"]
        sql = "select {cols} from seqalias".format(cols=", ".join(cols))
        if clauses:
            sql += " where " + " and ".join("(" + c + ")" for c in clauses)
        sql += " order by seq_id, namespace, alias"

        _logger.debug("Executing: " + sql)
        return self._db.execute(sql, params)