Instruction:
Write a Python 3 script to
validate an object against its swagger model

Response:
def validate(self, model_name, object):
        """Validate an object against its swagger model"""
        if model_name not in self.swagger_dict['definitions']:
            raise ValidationError("Swagger spec has no definition for model %s" % model_name)
        model_def = self.swagger_dict['definitions'][model_name]
        log.debug("Validating %s" % model_name)
        return validate_schema_object(self.spec, model_def, object)


Instruction:
Can you generate the documentation for the following Python 3 function
def call_on_each_endpoint(self, callback):

        if 'paths' not in self.swagger_dict:
            return

        for path, d in list(self.swagger_dict['paths'].items()):
            for method, op_spec in list(d.items()):
                data = EndpointData(path, method)

                # Which server method handles this endpoint?
                if 'x-bind-server' not in op_spec:
                    if 'x-no-bind-server' in op_spec:
                        # That route should not be auto-generated
                        log.info("Skipping generation of %s %s" % (method, path))
                        continue
                    else:
                        raise Exception("Swagger api defines no x-bind-server for %s %s" % (method, path))
                data.handler_server = op_spec['x-bind-server']

                # Make sure that endpoint only produces 'application/json'
                if 'produces' not in op_spec:
                    raise Exception("Swagger api has no 'produces' section for %s %s" % (method, path))
                if len(op_spec['produces']) != 1:
                    raise Exception("Expecting only one type under 'produces' for %s %s" % (method, path))
                if op_spec['produces'][0] == 'application/json':
                    data.produces_json = True
                elif op_spec['produces'][0] == 'text/html':
                    data.produces_html = True
                else:
                    raise Exception("Only 'application/json' or 'text/html' are supported. See %s %s" % (method, path))

                # Which client method handles this endpoint?
                if 'x-bind-client' in op_spec:
                    data.handler_client = op_spec['x-bind-client']

                # Should we decorate the server handler?
                if 'x-decorate-server' in op_spec:
                    data.decorate_server = op_spec['x-decorate-server']

                # Should we manipulate the requests parameters?
                if 'x-decorate-request' in op_spec:
                    data.decorate_request = op_spec['x-decorate-request']

                # Generate a bravado-core operation object
                data.operation = Operation.from_spec(self.spec, path, method, op_spec)

                # Figure out how parameters are passed: one json in body? one or
                # more values in query?
                if 'parameters' in op_spec:
                    params = op_spec['parameters']
                    for p in params:
                        if p['in'] == 'body':
                            data.param_in_body = True
                        if p['in'] == 'query':
                            data.param_in_query = True
                        if p['in'] == 'path':
                            data.param_in_path = True

                    if data.param_in_path:
                        # Substitute {...} with <...> in path, to make a Flask friendly path
                        data.path = data.path.replace('{', '<').replace('}', '>')

                    if data.param_in_body and data.param_in_query:
                        raise Exception("Cannot support params in both body and param (%s %s)" % (method, path))

                else:
                    data.no_params = True

                callback(data)

Response: Find all server endpoints defined in the swagger spec and calls callback for each one with an instance of EndpointData as argument.


Instruction:
Can you generate the documentation for the following Python 3 function
def main(args=None):
    parser = argparse.ArgumentParser(description=main.__doc__)
    parser.add_argument(
        '--binary',
        dest='mode',
        action='store_const',
        const="wb",
        default="w",
        help='write in binary mode')
    parser.add_argument(
        'output', metavar='FILE', type=unicode, help='Output file')

    logging.basicConfig(
        level=logging.DEBUG,
        stream=sys.stderr,
        format='[%(levelname)s elapsed=%(relativeCreated)dms] %(message)s')

    args = parser.parse_args(args or sys.argv[1:])

    with open(args.output, args.mode) as fd:
        for line in sys.stdin:
            fd.write(line)

Response: Buffer stdin and flush and avoid incomplete files.


Instruction:
Implement a Python 3 function for
generating a list of basic C - style defines that can be used to generate a header file.

Response:
def basic_c_defines(
    layout,
    keyboard_prefix="KEY_",
    led_prefix="LED_",
    sysctrl_prefix="SYS_",
    cons_prefix="CONS_",
    code_suffix=True,
    all_caps=True,
    space_char="_"
):
    '''
    Generates a list of C defines that can be used to generate a header file

    @param layout: Layout object
    @keyboard_prefix: Prefix used for to_hid_keyboard
    @led_prefix: Prefix used for to_hid_led
    @sysctrl_prefix: Prefix used for to_hid_sysctrl
    @cons_prefix: Prefix used for to_hid_consumer
    @code_suffix: Append _<usb code> to each name
    @all_caps: Set to true if labels should be converted to all caps
    @space_char: Character to replace space with

    @returns: List of C tuples (<name>, <number>) that can be used to generate C-style defines. Each section has it's own list.
    '''
    # Keyboard Codes
    keyboard_defines = []
    for code, name in layout.json()['to_hid_keyboard'].items():
        new_name = "{}{}".format(keyboard_prefix, name.replace(' ', space_char))
        if all_caps:
            new_name = new_name.upper()
        if code_suffix:
            new_name = "{}_{}".format(new_name, int(code, 0))
        define = (new_name, code)
        keyboard_defines.append(define)

    # LED Codes
    led_defines = []
    for code, name in layout.json()['to_hid_led'].items():
        new_name = "{}{}".format(led_prefix, name.replace(' ', space_char))
        if all_caps:
            new_name = new_name.upper()
        if code_suffix:
            new_name = "{}_{}".format(new_name, int(code, 0))
        define = (new_name, code)
        led_defines.append(define)

    # System Control Codes
    sysctrl_defines = []
    for code, name in layout.json()['to_hid_sysctrl'].items():
        new_name = "{}{}".format(sysctrl_prefix, name.replace(' ', space_char))
        if all_caps:
            new_name = new_name.upper()
        if code_suffix:
            new_name = "{}_{}".format(new_name, int(code, 0))
        define = (new_name, code)
        sysctrl_defines.append(define)

    # Consumer Codes
    cons_defines = []
    for code, name in layout.json()['to_hid_consumer'].items():
        new_name = "{}{}".format(cons_prefix, name.replace(' ', space_char))
        if all_caps:
            new_name = new_name.upper()
        if code_suffix:
            new_name = "{}_{}".format(new_name, int(code, 0))
        define = (new_name, code)
        cons_defines.append(define)

    # Return list of list of tuples
    defines = [keyboard_defines, led_defines, sysctrl_defines, cons_defines]
    return defines


Instruction:
Can you tell what is the following Python 3 function doing
def new_email_marketing_campaign(self, name, email_content, from_email,
                                     from_name, reply_to_email, subject,
                                     text_content, address,
                                     is_view_as_webpage_enabled=False,
                                     view_as_web_page_link_text='',
                                     view_as_web_page_text='',
                                     is_permission_reminder_enabled=False,
                                     permission_reminder_text=''):
        """Create a Constant Contact email marketing campaign.
        Returns an EmailMarketingCampaign object.
        """
        url = self.api.join(self.EMAIL_MARKETING_CAMPAIGN_URL)

        inlined_email_content = self.inline_css(email_content)
        minified_email_content = html_minify(inlined_email_content)
        worked_around_email_content = work_around(minified_email_content)

        data = {
            'name': name,
            'subject': subject,
            'from_name': from_name,
            'from_email': from_email,
            'reply_to_email': reply_to_email,
            'email_content': worked_around_email_content,
            'email_content_format': 'HTML',
            'text_content': text_content,
            'message_footer': {
                'organization_name': address['organization_name'],
                'address_line_1': address['address_line_1'],
                'address_line_2': address['address_line_2'],
                'address_line_3': address['address_line_3'],
                'city': address['city'],
                'state': address['state'],
                'international_state': address['international_state'],
                'postal_code': address['postal_code'],
                'country': address['country']
            },
            'is_view_as_webpage_enabled': is_view_as_webpage_enabled,
            'view_as_web_page_link_text': view_as_web_page_link_text,
            'view_as_web_page_text': view_as_web_page_text,
            'is_permission_reminder_enabled': is_permission_reminder_enabled,
            'permission_reminder_text': permission_reminder_text
        }

        response = url.post(data=json.dumps(data),
                            headers={'content-type': 'application/json'})

        self.handle_response_status(response)

        return EmailMarketingCampaign.objects.create(data=response.json())

Response: Creates a new EmailMarketingCampaign object.


Instruction:
How would you explain what the following Python 3 function does
def update_email_marketing_campaign(self, email_marketing_campaign,
                                        name, email_content, from_email,
                                        from_name, reply_to_email, subject,
                                        text_content, address,
                                        is_view_as_webpage_enabled=False,
                                        view_as_web_page_link_text='',
                                        view_as_web_page_text='',
                                        is_permission_reminder_enabled=False,
                                        permission_reminder_text=''):
        """Update a Constant Contact email marketing campaign.
        Returns the updated EmailMarketingCampaign object.
        """
        url = self.api.join(
            '/'.join([self.EMAIL_MARKETING_CAMPAIGN_URL,
                      str(email_marketing_campaign.constant_contact_id)]))

        inlined_email_content = self.inline_css(email_content)
        minified_email_content = html_minify(inlined_email_content)
        worked_around_email_content = work_around(minified_email_content)

        data = {
            'name': name,
            'subject': subject,
            'from_name': from_name,
            'from_email': from_email,
            'reply_to_email': reply_to_email,
            'email_content': worked_around_email_content,
            'email_content_format': 'HTML',
            'text_content': text_content,
            'message_footer': {
                'organization_name': address['organization_name'],
                'address_line_1': address['address_line_1'],
                'address_line_2': address['address_line_2'],
                'address_line_3': address['address_line_3'],
                'city': address['city'],
                'state': address['state'],
                'international_state': address['international_state'],
                'postal_code': address['postal_code'],
                'country': address['country']
            },
            'is_view_as_webpage_enabled': is_view_as_webpage_enabled,
            'view_as_web_page_link_text': view_as_web_page_link_text,
            'view_as_web_page_text': view_as_web_page_text,
            'is_permission_reminder_enabled': is_permission_reminder_enabled,
            'permission_reminder_text': permission_reminder_text
        }

        response = url.put(data=json.dumps(data),
                           headers={'content-type': 'application/json'})

        self.handle_response_status(response)

        email_marketing_campaign.data = response.json()
        email_marketing_campaign.save()

        return email_marketing_campaign

Response: Updates an existing Constant Contact email marketing campaign.


Instruction:
Write a Python 3 function that can
delete a Constant Contact email marketing campaign.

Response:
def delete_email_marketing_campaign(self, email_marketing_campaign):
        """Deletes a Constant Contact email marketing campaign.
        """
        url = self.api.join('/'.join([
            self.EMAIL_MARKETING_CAMPAIGN_URL,
            str(email_marketing_campaign.constant_contact_id)]))
        response = url.delete()
        self.handle_response_status(response)
        return response


Instruction:
Given the following Python 3 function, write the documentation
def inline_css(self, html):
        premailer = Premailer(html)
        inlined_html = premailer.transform(pretty_print=True)
        return inlined_html

Response: Inlines CSS defined in external style sheets.


Instruction:
Can you tell what is the following Python 3 function doing
def preview_email_marketing_campaign(self, email_marketing_campaign):
        url = self.api.join('/'.join([
            self.EMAIL_MARKETING_CAMPAIGN_URL,
            str(email_marketing_campaign.constant_contact_id),
            'preview']))
        response = url.get()
        self.handle_response_status(response)
        return (response.json()['preview_email_content'],
                response.json()['preview_text_content'])

Response: Returns HTML and text previews of an EmailMarketingCampaign.


Instruction:
Implement a Python 3 function for
pulling constant_contact_id out of data.

Response:
def pre_save(cls, sender, instance, *args, **kwargs):
        """Pull constant_contact_id out of data.
        """
        instance.constant_contact_id = str(instance.data['id'])


Instruction:
Can you tell what is the following Python 3 function doing
def pre_delete(cls, sender, instance, *args, **kwargs):
        cc = ConstantContact()
        response = cc.delete_email_marketing_campaign(instance)
        response.raise_for_status()

Response: Deletes the CC email marketing campaign associated with me.


Instruction:
Create a Python 3 function to
run the necessary methods in the correct order.

Response:
def runner(self):
        """
        Run the necessary methods in the correct order
        """
        printtime('Starting {} analysis pipeline'.format(self.analysistype), self.starttime)
        if not self.pipeline:
            # If the metadata has been passed from the method script, self.pipeline must still be false in order to
            # get Sippr() to function correctly, but the metadata shouldn't be recreated
            try:
                _ = vars(self.runmetadata)['samples']
            except KeyError:
                # Create the objects to be used in the analyses
                objects = Objectprep(self)
                objects.objectprep()
                self.runmetadata = objects.samples
            # Run the analyses
            # Sippr(self, self.cutoff)
            ProbeSippr(self, self.cutoff)
            #
            # self.attributer()
            # Create the reports
            # self.sipprverse_reporter()
            # Print the metadata
            printer = MetadataPrinter(self)
            printer.printmetadata()
            quit()


Instruction:
Write a Python 3 function for
sending an email to the specified recipients.

Response:
def send_email(recipients, subject, text_content=None, html_content=None, from_email=None, use_base_template=True, category=None, fail_silently=False, language=None, cc=None, bcc=None, attachments=None, headers=None, bypass_queue=False, bypass_hijacking=False, attach_files=None):
    """
    Will send a multi-format email to recipients. Email may be queued through celery
    """
    from django.conf import settings
    if not bypass_queue and hasattr(settings, 'MAILING_USE_CELERY') and settings.MAILING_USE_CELERY:
        from celery.execute import send_task
        return send_task('mailing.queue_send_email',[recipients, subject, text_content, html_content, from_email, use_base_template, category, fail_silently, language if language else translation.get_language(), cc, bcc, attachments, headers, bypass_hijacking, attach_files])
    else:

        header_category_value = '%s%s' % (settings.MAILING_HEADER_CATEGORY_PREFIX if hasattr(settings, 'MAILING_HEADER_CATEGORY_PREFIX') else '', category)
        # Check for sendgrid support and add category header
        # --------------------------------
        if hasattr(settings, 'MAILING_USE_SENDGRID'):
            send_grid_support = settings.MAILING_USE_SENDGRID
        else:
            send_grid_support = False

        if not headers:
            headers = dict()
        if send_grid_support and category:
            headers['X-SMTPAPI'] = '{"category": "%s"}' % header_category_value

        # Check for Mailgun support and add label header
        # --------------------------------
        if hasattr(settings, 'MAILING_USE_MAILGUN'):
            mailgun_support = settings.MAILING_USE_MAILGUN
        else:
            mailgun_support = False

        if not headers:
            headers = dict()
        if mailgun_support and category:
            headers['X-Mailgun-Tag'] = header_category_value

        # Ensure recipients are in a list
        # --------------------------------
        if isinstance(recipients, basestring):
            recipients_list = [recipients]
        else:
            recipients_list = recipients

        # Check if we need to hijack the email
        # --------------------------------
        if hasattr(settings, 'MAILING_MAILTO_HIJACK') and not bypass_hijacking:
            headers['X-MAILER-ORIGINAL-MAILTO'] = ','.join(recipients_list)
            recipients_list = [settings.MAILING_MAILTO_HIJACK]

        if not subject:
            raise MailerMissingSubjectError('Subject not supplied')

        # Send ascii, html or multi-part email
        # --------------------------------
        if text_content or html_content:
            if use_base_template:
                prev_language = translation.get_language()
                language and translation.activate(language)
                text_content = render_to_string('mailing/base.txt', {'mailing_text_body': text_content, 'mailing_subject': subject, 'settings': settings}) if text_content else None
                html_content = render_to_string('mailing/base.html', {'mailing_html_body': html_content, 'mailing_subject': subject, 'settings': settings}) if html_content else None
                translation.activate(prev_language)
            msg = EmailMultiAlternatives(subject, text_content if text_content else html_content, from_email if from_email else settings.DEFAULT_FROM_EMAIL, recipients_list, cc=cc, bcc=bcc, attachments=attachments, headers = headers)
            if html_content and text_content:
                msg.attach_alternative(html_content, "text/html")
            elif html_content: # Only HTML
                msg.content_subtype = "html"

            # Attach files through attach_files helper
            # --------------------------------
            if attach_files:
                for att in attach_files:  # attachments are tuples of (filepath, mimetype, filename)
                    with open(att[0], 'rb') as f:
                        content = f.read()
                    msg.attach(att[2], content, att[1])

            # Send email
            # --------------------------------

            msg.send(fail_silently=fail_silently)
        else:
            raise MailerInvalidBodyError('No text or html body supplied.')


Instruction:
How would you explain what the following Python 3 function does
def initialize_connections(self, scopefunc=None):
        for connection_name, connection_string in\
                self.app.config['FLASK_PHILO_SQLALCHEMY'].items():
            engine = create_engine(connection_string)
            session = scoped_session(sessionmaker(), scopefunc=scopefunc)
            session.configure(bind=engine)
            self.connections[connection_name] = Connection(engine, session)

Response: Initialize a database connection by each connection string in the configuration file.


Instruction:
Can you write a function in Python 3 where it
sorts the list according to the attribute attribut

Response:
def sort(self, attribut, order=False):
        """
        Implément un tri par attrbut.

        :param str attribut: Nom du champ concerné
        :param bool order: Ordre croissant ou décroissant
        """
        value_default = formats.ASSOCIATION[attribut][3]

        if type(value_default) is str:  # case insensitive sort
            get = lambda d : (d[attribut] or value_default).casefold()
        elif type(value_default) is dict: #can't sort dicts
            def get(d):
                u = d[attribut] or value_default
                return [str(u[i]) for i in sorted(u.keys())]
        else:
            get = lambda d : d[attribut] or value_default

        list.sort(self, key=get, reverse=order)


Instruction:
Implement a Python 3 function for
returning the row of given Id if it exists otherwise None. Only works with pseudo - acces

Response:
def index_from_id(self,Id):
        """Return the row of given Id if it'exists, otherwise None. Only works with pseudo-acces"""
        try:
            return [a.Id for a in self].index(Id)
        except IndexError:
            return


Instruction:
Explain what the following Python 3 code does
def append(self, acces, **kwargs):
        if acces.Id in set(ac.Id for ac in self):
            raise ValueError("Acces id already in list !")
        list.append(self, acces)
        if kwargs:
            self.infos[acces.Id] = kwargs

Response: Append a new entry to the list.


Instruction:
Write a Python 3 function for
suppressing acces with id = key

Response:
def remove_id(self,key):
        """Suppress acces with id = key"""
        self.infos.pop(key, "")
        new_l = [a for a in self if not (a.Id == key)]
        list.__init__(self, new_l)


Instruction:
Write a Python 3 function for
returning information associated with Id or list index

Response:
def get_info(self, key=None, Id=None) -> dict:
        """Returns information associated with Id or list index"""
        if key is not None:
            Id = self[key].Id
        return self.infos.get(Id,{})


Instruction:
Explain what the following Python 3 code does
def recherche(self, pattern, entete):

        new_liste = []
        sub_patterns = pattern.split(" ")
        for p in self:
            d_font = {att: False for att in entete}
            row_valid = True
            for sub_pattern in sub_patterns:
                found = False
                for att in entete:
                    fonction_recherche = formats.ASSOCIATION[att][1]
                    attr_found = bool(fonction_recherche(p[att], sub_pattern))
                    if attr_found:
                        found = True
                        d_font[att] = True
                if not found:
                    row_valid = False
                    break
            if row_valid:
                new_liste.append(p)
                info = dict(self.get_info(Id=p.Id),font=d_font)
                self.infos[p.Id] = info

        list.__init__(self, new_liste)

Response: Performs a search field by field using functions defined in formats. ASSOCIATION.


Instruction:
Explain what the following Python 3 code does
def extend(self, collection):
        l_ids = set([a.Id for a in self])
        for acces in collection:
            if not acces.Id in l_ids:
                list.append(self,acces)
                info = collection.get_info(Id=acces.Id)
                if info:
                    self.infos[acces.Id] = info

Response: Merges the list with the items in the collection. Ensure uniqueness of ids.


Instruction:
Make a summary of the following Python 3 code
def isotime(at=None, subsecond=False):
    if not at:
        at = utcnow()
    st = at.strftime(_ISO8601_TIME_FORMAT
                     if not subsecond
                     else _ISO8601_TIME_FORMAT_SUBSECOND)
    tz = at.tzinfo.tzname(None) if at.tzinfo else 'UTC'
    st += ('Z' if tz == 'UTC' else tz)
    return st

Response: Stringify time in ISO 8601 format.


Instruction:
Can you create a Python 3 function that
parses time from ISO 8601 format.

Response:
def parse_isotime(timestr):
    """Parse time from ISO 8601 format."""
    try:
        return iso8601.parse_date(timestr)
    except iso8601.ParseError as e:
        raise ValueError(six.text_type(e))
    except TypeError as e:
        raise ValueError(six.text_type(e))


Instruction:
Given the following Python 3 function, write the documentation
def normalize_time(timestamp):
    offset = timestamp.utcoffset()
    if offset is None:
        return timestamp
    return timestamp.replace(tzinfo=None) - offset

Response: Normalize time in arbitrary timezone to UTC naive object.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def is_older_than(before, seconds):
    if isinstance(before, six.string_types):
        before = parse_strtime(before).replace(tzinfo=None)
    else:
        before = before.replace(tzinfo=None)

    return utcnow() - before > datetime.timedelta(seconds=seconds)

Response: Return True if before is older than seconds.


Instruction:
Can you tell what is the following Python 3 function doing
def is_newer_than(after, seconds):
    if isinstance(after, six.string_types):
        after = parse_strtime(after).replace(tzinfo=None)
    else:
        after = after.replace(tzinfo=None)

    return after - utcnow() > datetime.timedelta(seconds=seconds)

Response: Return True if after is newer than seconds.


Instruction:
Here you have a function in Python 3, explain what it does
def utcnow_ts():
    if utcnow.override_time is None:
        # NOTE(kgriffs): This is several times faster
        # than going through calendar.timegm(...)
        return int(time.time())

    return calendar.timegm(utcnow().timetuple())

Response: Timestamp version of our utcnow function.


Instruction:
Make a summary of the following Python 3 code
def utcnow():
    if utcnow.override_time:
        try:
            return utcnow.override_time.pop(0)
        except AttributeError:
            return utcnow.override_time
    return datetime.datetime.utcnow()

Response: Overridable version of utils. utcnow.


Instruction:
Make a summary of the following Python 3 code
def advance_time_delta(timedelta):
    assert(utcnow.override_time is not None)
    try:
        for dt in utcnow.override_time:
            dt += timedelta
    except TypeError:
        utcnow.override_time += timedelta

Response: Advance overridden time using a datetime. timedelta.


Instruction:
Here you have a function in Python 3, explain what it does
def marshall_now(now=None):
    if not now:
        now = utcnow()
    return dict(day=now.day, month=now.month, year=now.year, hour=now.hour,
                minute=now.minute, second=now.second,
                microsecond=now.microsecond)

Response: Make an rpc - safe datetime with microseconds.


Instruction:
Make a summary of the following Python 3 code
def unmarshall_time(tyme):
    return datetime.datetime(day=tyme['day'],
                             month=tyme['month'],
                             year=tyme['year'],
                             hour=tyme['hour'],
                             minute=tyme['minute'],
                             second=tyme['second'],
                             microsecond=tyme['microsecond'])

Response: Unmarshall a datetime dict.


Instruction:
Given the following Python 3 function, write the documentation
def total_seconds(delta):
    try:
        return delta.total_seconds()
    except AttributeError:
        return ((delta.days * 24 * 3600) + delta.seconds +
                float(delta.microseconds) / (10 ** 6))

Response: Return the total seconds of a datetime. timedelta object.


Instruction:
Here you have a function in Python 3, explain what it does
def is_soon(dt, window):
    soon = (utcnow() + datetime.timedelta(seconds=window))
    return normalize_time(dt) <= soon

Response: Determines if the given time is going to happen in the next window seconds.


Instruction:
Make a summary of the following Python 3 code
def download_file_powershell(url, target):
    '''
    Download the file at url to target using Powershell (which will validate
    trust). Raise an exception if the command cannot complete.
    '''
    target = os.path.abspath(target)
    cmd = [
        'powershell',
        '-Command',
        '(new-object System.Net.WebClient).DownloadFile(%(url)r, %(target)r)' % vars(),
    ]
    subprocess.check_call(cmd)

Response: Download the file at url to target using Powershell.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def download_file_insecure(url, target):
    '''
    Use Python to download the file, even though it cannot authenticate the
    connection.
    '''
    try:
        from urllib.request import urlopen
    except ImportError:
        from urllib2 import urlopen
    src = dst = None
    try:
        src = urlopen(url)
        # Read/write all in one block, so we don't create a corrupt file
        # if the download is interrupted.
        data = src.read()
        dst = open(target, 'wb')
        dst.write(data)
    finally:
        if src:
            src.close()
        if dst:
            dst.close()

Response: Download a file from a URL and save it to a file.


Instruction:
Can you generate the documentation for the following Python 3 function
def _build_install_args(options):
    '''
    Build the arguments to 'python setup.py install' on the setuptools package
    '''
    install_args = []
    if options.user_install:
        if sys.version_info < (2, 6):
            log.warn('--user requires Python 2.6 or later')
            raise SystemExit(1)
        install_args.append('--user')
    return install_args

Response: Build the arguments to python setup. py install on the setuptools package


Instruction:
Given the following Python 3 function, write the documentation
def write(name, value):
    def wrapped(func):
        @functools.wraps(func)
        def _decorator(*args, **kwargs):
            existing_env = core.read(name, allow_none=True)
            core.write(name, value)
            func_val = func(*args, **kwargs)
            core.write(name, existing_env)
            return func_val
        return _decorator
    return wrapped

Response: Decorator that changes or sets the environment variable for the specified resource.


Instruction:
Here you have a function in Python 3, explain what it does
def isset(name):
    def wrapped(func):
        @functools.wraps(func)
        def _decorator(*args, **kwargs):
            if core.isset(name):
                return func(*args, **kwargs)
        return _decorator
    return wrapped

Response: Only execute the function if the variable is set.


Instruction:
Can you tell what is the following Python 3 function doing
def bool(name, execute_bool=True, default=None):
    def wrapped(func):
        @functools.wraps(func)
        def _decorator(*args, **kwargs):
            if core.isset(name) and core.bool(name) == execute_bool:
                return func(*args, **kwargs)
            elif default is not None and default == execute_bool:
                return func(*args, **kwargs)
        return _decorator
    return wrapped

Response: Decorator to execute the function only if the boolean variable is set.


Instruction:
How would you explain what the following Python 3 function does
def read_cell(self, x, y):
        if isinstance(self.header[y], tuple):
            header = self.header[y][0]
        else:
            header = self.header[y]
        x += 1
        y += 1
        if self.strip:
            self._sheet.cell(x, y).value = self._sheet.cell(x, y).value.strip()
        else:
            return {header: self._sheet.cell(x, y).value}

Response: Reads the cell at position x and y and returns value


Instruction:
Create a Python 3 function to
write the value in the cell of x y to value

Response:
def write_cell(self, x, y, value):
        """
        Writing value in the cell of x+1 and y+1 position
        :param x: line index
        :param y: coll index
        :param value: value to be written
        :return:
        """
        x += 1
        y += 1
        self._sheet.update_cell(x, y, value)


Instruction:
Write a Python 3 script for
opening the file and get sheets

Response:
def _open(self):
        """
        Open the file; get sheets
        :return:
        """
        if not hasattr(self, '_file'):
            self._file = self.gc.open(self.name)
            self.sheet_names = self._file.worksheets()


Instruction:
How would you implement a function in Python 3 that
reads the sheet and set the header and number columns and rows.

Response:
def _open_sheet(self):
        """
        Read the sheet, get value the header, get number columns and rows
        :return:
        """
        if self.sheet_name and not self.header:
            self._sheet = self._file.worksheet(self.sheet_name.title)
            self.ncols = self._sheet.col_count
            self.nrows = self._sheet.row_count
            for i in range(1, self.ncols+1):
                self.header = self.header + [self._sheet.cell(1, i).value]


Instruction:
How would you implement a function in Python 3 that
makes imports Makes imports

Response:
def _import(self):
        """
        Makes imports
        :return:
        """
        import os.path
        import gspread
        self.path = os.path
        self.gspread = gspread
        self._login()


Instruction:
Can you tell what is the following Python 3 function doing
def _login(self):
        # TODO(dmvieira) login changed to oauth2
        self.gc = self.gspread.login(self.email, self.password)

Response: Login with your Google account


Instruction:
How would you explain what the following Python 3 function does
def flags(self, index: QModelIndex):
        if self.IS_EDITABLE and self.header[index.column()] in self.EDITABLE_FIELDS:
            return Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsEditable
        else:
            return super().flags(index) | Qt.ItemIsSelectable

Response: Flags for the item at the given index.


Instruction:
Given the following Python 3 function, write the documentation
def sort(self, section: int, order=None):
        attr = self.header[section]
        old_i, old_sort = self.sort_state
        self.beginResetModel()
        if section == old_i:
            self.collection.sort(attr, not old_sort)
            self.sort_state = (section, not old_sort)
        else:
            self.collection.sort(attr, True)
            self.sort_state = (section, True)
        self.endResetModel()

Response: Sort the entries in the specified section.


Instruction:
Create a Python 3 function for
basing implementation just pops the item from the collection and removes the section from the collection.

Response:
def remove_line(self, section):
        """Base implementation just pops the item from collection.
        Re-implements to add global behaviour
        """
        self.beginResetModel()
        self.collection.pop(section)
        self.endResetModel()


Instruction:
Implement a Python 3 function for
updating the data of the current instance of the class.

Response:
def _update(self):
        """Emit dataChanged signal on all cells"""
        self.dataChanged.emit(self.createIndex(0, 0), self.createIndex(
            len(self.collection), len(self.header)))


Instruction:
Can you generate a brief explanation for the following Python 3 code
def get_item(self, index):
        row = index.row() if hasattr(index, "row") else index
        try:
            return self.collection[row]
        except IndexError:  # invalid index for exemple
            return None

Response: Returns the item with the given index.


Instruction:
How would you explain what the following Python 3 function does
def set_collection(self, collection):
        self.beginResetModel()
        self.collection = collection
        self.sort_state = (-1, False)
        self.endResetModel()

Response: Reset sort state set collection and emit resetModel signal


Instruction:
Here you have a function in Python 3, explain what it does
def set_item(self, index, new_item):
        row = index.row() if hasattr(index, "row") else index
        self.collection[row] = new_item
        self.dataChanged.emit(self.index(
            row, 0), self.index(row, self.rowCount() - 1))

Response: Changes the item at index in collection. Emit dataChanged signal.


Instruction:
Make a summary of the following Python 3 code
def set_data(self, index, value):
        acces, field = self.get_item(index), self.header[index.column()]
        self.beginResetModel()
        self.set_data_hook(acces, field, value)
        self.endResetModel()

Response: Uses given data setter and emit modelReset signal


Instruction:
Create a Python 3 function to
update selected_ids and emit dataChanged

Response:
def _set_id(self, Id, is_added, index):
        """Update selected_ids and emit dataChanged"""
        if is_added:
            self.selected_ids.add(Id)
        else:
            self.selected_ids.remove(Id)
        self.dataChanged.emit(index, index)


Instruction:
Write a Python 3 script to
update selected_ids on click on index cell.

Response:
def setData(self, index: QModelIndex, value, role=None):
        """Update selected_ids on click on index cell."""
        if not (index.isValid() and role == Qt.CheckStateRole):
            return False
        c_id = self.get_item(index).Id
        self._set_id(c_id, value == Qt.Checked, index)
        return True


Instruction:
Create a Python 3 function to
update selected_ids with given Id

Response:
def set_by_Id(self, Id, is_added):
        """Update selected_ids with given Id"""
        row = self.collection.index_from_id(Id)
        if row is None:
            return
        self._set_id(Id, is_added, self.index(row, 0))


Instruction:
Here you have a function in Python 3, explain what it does
def _setup_delegate(self):
        delegate = self.DELEGATE_CLASS(self)
        self.setItemDelegate(delegate)
        delegate.sizeHintChanged.connect(
            lambda index: self.resizeRowToContents(index.row()))
        if self.RESIZE_COLUMN:
            delegate.sizeHintChanged.connect(
                lambda index: self.resizeColumnToContents(index.column()))
        delegate.closeEditor.connect(
            lambda ed: self.resizeRowToContents(delegate.row_done_))

Response: Add resize behavior on edit


Instruction:
Can you tell what is the following Python 3 function doing
def _draw_placeholder(self):
        if self.model().rowCount() == 0:
            painter = QPainter(self.viewport())
            painter.setFont(_custom_font(is_italic=True))
            painter.drawText(self.rect().adjusted(0, 0, -5, -5), Qt.AlignCenter | Qt.TextWordWrap,
                             self.PLACEHOLDER)

Response: Draw the placeholder text for the current item.


Instruction:
How would you explain what the following Python 3 function does
def get_current_item(self):
        l = self.selectedIndexes()
        if len(l) > 0:
            return self.model().get_item(l[0])

Response: Returns the currently selected item or None


Instruction:
How would you explain what the following Python 3 function does
def model_from_list(l, header):
        col = groups.sortableListe(PseudoAccesCategorie(n) for n in l)
        return MultiSelectModel(col, header)

Response: Return a model with a collection from a list of entries


Instruction:
Create a Python 3 function for
parsing the status code from the response.

Response:
def _parse_status_code(response):
    """
    Return error string code if the response is an error, otherwise ``"OK"``
    """

    # This happens when a status response is expected
    if isinstance(response, string_types):
        return response

    # This happens when a list of structs are expected
    is_single_list = isinstance(response, list) and len(response) == 1
    if is_single_list and isinstance(response[0], string_types):
        return response[0]

    # This happens when a struct of any kind is returned
    return "OK"


Instruction:
How would you implement a function in Python 3 that
removes the zone record with the given ID that belongs to the given domain and sub - domain.

Response:
def remove_zone_record(self, id, domain, subdomain=None):
        """
        Remove the zone record with the given ID that belongs to the given
        domain and sub domain. If no sub domain is given the wildcard sub-domain
        is assumed.
        """

        if subdomain is None:
            subdomain = "@"

        _validate_int("id", id)

        self._call("removeZoneRecord", domain, subdomain, id)


Instruction:
How would you explain what the following Python 3 function does
def parse_module_class(self):
        cname = self.class_name
        match = re.match(self.CLASS_REGEX, cname)
        if not match:
            raise ValueError(f'not a fully qualified class name: {cname}')
        return match.groups()

Response: Parse the module and class name part of the fully qualifed class name.


Instruction:
Create a Python 3 function to
return the module and class in the initializer.

Response:
def get_module_class(self):
        """Return the module and class as a tuple of the given class in the
        initializer.

        :param reload: if ``True`` then reload the module before returning the
        class

        """
        pkg, cname = self.parse_module_class()
        logger.debug(f'pkg: {pkg}, class: {cname}')
        pkg = pkg.split('.')
        mod = reduce(lambda m, n: getattr(m, n), pkg[1:], __import__(pkg[0]))
        logger.debug(f'mod: {mod}')
        if self.reload:
            importlib.reload(mod)
        cls = getattr(mod, cname)
        logger.debug(f'class: {cls}')
        return mod, cls


Instruction:
Can you tell what is the following Python 3 function doing
def instance(self, *args, **kwargs):
        mod, cls = self.get_module_class()
        inst = cls(*args, **kwargs)
        logger.debug(f'inst: {inst}')
        return inst

Response: Create an instance of the specified class in the initializer.


Instruction:
Given the following Python 3 function, write the documentation
def set_log_level(self, level=logging.INFO):
        mod, cls = self.parse_module_class()
        logging.getLogger(mod).setLevel(level)

Response:
Convenciene method to set the log level of the module given in the
        initializer of this class.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def register(cls, instance_class, name=None):
        if name is None:
            name = instance_class.__name__
        cls.INSTANCE_CLASSES[name] = instance_class

Response: Register a class with the factory.


Instruction:
Implement a function in Python 3 to
resolve the class from the name.

Response:
def _find_class(self, class_name):
        "Resolve the class from the name."
        classes = {}
        classes.update(globals())
        classes.update(self.INSTANCE_CLASSES)
        logger.debug(f'looking up class: {class_name}')
        cls = classes[class_name]
        logger.debug(f'found class: {cls}')
        return cls


Instruction:
Implement a function in Python 3 to
get the class name and parameters to use for __init__.

Response:
def _class_name_params(self, name):
        "Get the class name and parameters to use for ``__init__``."
        sec = self.pattern.format(**{'name': name})
        logger.debug(f'section: {sec}')
        params = {}
        params.update(self.config.populate({}, section=sec))
        class_name = params['class_name']
        del params['class_name']
        return class_name, params


Instruction:
Write a Python 3 script to
return whether the class has a config parameter in the __init__ method.

Response:
def _has_init_config(self, cls):
        """Return whether the class has a ``config`` parameter in the ``__init__``
        method.

        """
        args = inspect.signature(cls.__init__)
        return self.config_param_name in args.parameters


Instruction:
Can you tell what is the following Python 3 function doing
def _has_init_name(self, cls):
        args = inspect.signature(cls.__init__)
        return self.name_param_name in args.parameters

Response: Return whether the class has a name parameter in the __init__ method.


Instruction:
Create a Python 3 function for
returning the instance from the cache.

Response:
def _instance(self, cls, *args, **kwargs):
        """Return the instance.

        :param cls: the class to create the instance from
        :param args: given to the ``__init__`` method
        :param kwargs: given to the ``__init__`` method
        """
        logger.debug(f'args: {args}, kwargs: {kwargs}')
        return cls(*args, **kwargs)


Instruction:
Implement a function in Python 3 to
create a new instance of the class with the given name.

Response:
def instance(self, name=None, *args, **kwargs):
        """Create a new instance using key ``name``.

        :param name: the name of the class (by default) or the key name of the
            class used to find the class
        :param args: given to the ``__init__`` method
        :param kwargs: given to the ``__init__`` method

        """
        logger.info(f'new instance of {name}')
        t0 = time()
        name = self.default_name if name is None else name
        logger.debug(f'creating instance of {name}')
        class_name, params = self._class_name_params(name)
        cls = self._find_class(class_name)
        params.update(kwargs)
        if self._has_init_config(cls):
            logger.debug(f'found config parameter')
            params['config'] = self.config
        if self._has_init_name(cls):
            logger.debug(f'found name parameter')
            params['name'] = name
        if logger.level >= logging.DEBUG:
            for k, v in params.items():
                logger.debug(f'populating {k} -> {v} ({type(v)})')
        inst = self._instance(cls, *args, **params)
        logger.info(f'created {name} instance of {cls.__name__} ' +
                    f'in {(time() - t0):.2f}s')
        return inst


Instruction:
How would you code a function in Python 3 to
load the instance of the object from the stash.

Response:
def load(self, name=None, *args, **kwargs):
        "Load the instance of the object from the stash."
        inst = self.stash.load(name)
        if inst is None:
            inst = self.instance(name, *args, **kwargs)
        logger.debug(f'loaded (conf mng) instance: {inst}')
        return inst


Instruction:
Create a Python 3 function for
saving the object instance to the stash.

Response:
def dump(self, name: str, inst):
        "Save the object instance to the stash."
        self.stash.dump(name, inst)


Instruction:
Write a Python 3 function for
returning a Saltant API client configured from environment variables.

Response:
def from_env(cls, default_timeout=DEFAULT_TIMEOUT_SECONDS):
        """Return a client configured from environment variables.

        Essentially copying this:
        https://github.com/docker/docker-py/blob/master/docker/client.py#L43.

        The environment variables looked for are the following:

        .. envvar:: SALTANT_API_URL

            The URL of the saltant API. For example,
            https://shahlabjobs.ca/api/.

        .. envvar:: SALTANT_AUTH_TOKEN

            The registered saltant user's authentication token.

        Example:

            >>> from saltant.client import from_env
            >>> client = from_env()

        Args:
            default_timeout (int, optional): The maximum number of
                seconds to wait for a request to complete. Defaults to
                90 seconds.

        Returns:
            :class:`Client`: A saltant API client object.

        Raises:
            :class:`saltant.exceptions.BadEnvironmentError`: The user
                has an incorrectly configured environment.
        """
        # Get variables from environment
        try:
            base_api_url = os.environ["SALTANT_API_URL"]
        except KeyError:
            raise BadEnvironmentError("SALTANT_API_URL not defined!")

        try:
            # Try to get an auth token
            auth_token = os.environ["SALTANT_AUTH_TOKEN"]
        except KeyError:
            raise BadEnvironmentError("SALTANT_AUTH_TOKEN not defined!")

        # Return the configured client
        return cls(
            base_api_url=base_api_url,
            auth_token=auth_token,
            default_timeout=default_timeout,
        )


Instruction:
Create a Python 3 function for
clearing all global data.

Response:
def clear_global(self):
        """Clear only any cached global data.

        """
        vname = self.varname
        logger.debug(f'global clearning {vname}')
        if vname in globals():
            logger.debug('removing global instance var: {}'.format(vname))
            del globals()[vname]


Instruction:
Implement a Python 3 function for
clearing the data of the is and force it to be created on the next fetch.

Response:
def clear(self):
        """Clear the data, and thus, force it to be created on the next fetch.  This is
        done by removing the attribute from ``owner``, deleting it from globals
        and removing the file from the disk.

        """
        vname = self.varname
        if self.path.exists():
            logger.debug('deleting cached work: {}'.format(self.path))
            self.path.unlink()
        if self.owner is not None and hasattr(self.owner, vname):
            logger.debug('removing instance var: {}'.format(vname))
            delattr(self.owner, vname)
        self.clear_global()


Instruction:
Create a Python 3 function for
loading the data from the file system and create it if it does not exist.

Response:
def _load_or_create(self, *argv, **kwargs):
        """Invoke the file system operations to get the data, or create work.

        If the file does not exist, calling ``__do_work__`` and save it.
        """
        if self.path.exists():
            self._info('loading work from {}'.format(self.path))
            with open(self.path, 'rb') as f:
                obj = pickle.load(f)
        else:
            self._info('saving work to {}'.format(self.path))
            with open(self.path, 'wb') as f:
                obj = self._do_work(*argv, **kwargs)
                pickle.dump(obj, f)
        return obj


Instruction:
Explain what the following Python 3 code does
def has_data(self):
        if not hasattr(self, '_has_data'):
            try:
                next(iter(self.delegate.keys()))
                self._has_data = True
            except StopIteration:
                self._has_data = False
        return self._has_data

Response: Return whether or not the stash has any data available or not.


Instruction:
How would you implement a function in Python 3 that
returns a path to the pickled data with key name.

Response:
def _get_instance_path(self, name):
        "Return a path to the pickled data with key ``name``."
        fname = self.pattern.format(**{'name': name})
        logger.debug(f'path {self.create_path}: {self.create_path.exists()}')
        self._create_path_dir()
        return Path(self.create_path, fname)


Instruction:
Explain what the following Python 3 code does
def shelve(self):
        logger.info('creating shelve data')
        fname = str(self.create_path.absolute())
        inst = sh.open(fname, writeback=self.writeback)
        self.is_open = True
        return inst

Response: Return an opened shelve object.


Instruction:
Can you tell what is the following Python 3 function doing
def delete(self, name=None):
        "Delete the shelve data file."
        logger.info('clearing shelve data')
        self.close()
        for path in Path(self.create_path.parent, self.create_path.name), \
            Path(self.create_path.parent, self.create_path.name + '.db'):
            logger.debug(f'clearing {path} if exists: {path.exists()}')
            if path.exists():
                path.unlink()
                break

Response: Delete the shelve data file.


Instruction:
Explain what the following Python 3 code does
def close(self):
        "Close the shelve object, which is needed for data consistency."
        if self.is_open:
            logger.info('closing shelve data')
            try:
                self.shelve.close()
                self._shelve.clear()
            except Exception:
                self.is_open = False

Response: Close the shelve object which is needed for data consistency.


Instruction:
Explain what the following Python 3 code does
def _map(self, data_item):
        "Map ``data_item`` separately in each thread."
        delegate = self.delegate
        logger.debug(f'mapping: {data_item}')
        if self.clobber or not self.exists(data_item.id):
            logger.debug(f'exist: {data_item.id}: {self.exists(data_item.id)}')
            delegate.dump(data_item.id, data_item)

Response: Map data_item separately in each thread.


Instruction:
Explain what the following Python 3 code does
def load_all(self, workers=None, limit=None, n_expected=None):
        if not self.has_data:
            self._preempt(True)
            # we did the best we could (avoid repeat later in this method)
            n_expected = 0
        keys = tuple(self.delegate.keys())
        if n_expected is not None and len(keys) < n_expected:
            self._preempt(True)
            keys = self.delegate.keys()
        keys = it.islice(limit, keys) if limit is not None else keys
        pool = self._create_thread_pool(workers)
        logger.debug(f'workers={workers}, keys: {keys}')
        try:
            return iter(pool.map(self.delegate.load, keys))
        finally:
            pool.close()

Response: Load all instances witih multiple threads.


Instruction:
Can you generate the documentation for the following Python 3 function
def _make_persistent(self, model_name, pkg_name):

        #
        # WARNING: ugly piece of monkey-patching below. Hopefully will replace
        # with native bravado-core code in the future...
        #

        # Load class at path pkg_name
        c = get_function(pkg_name)
        for name in ('load_from_db', 'save_to_db'):
            if not hasattr(c, name):
                raise PyMacaronCoreException("Class %s has no static method '%s'" % (pkg_name, name))

        log.info("Making %s persistent via %s" % (model_name, pkg_name))

        # Replace model generator with one that adds 'save_to_db' to every instance
        model = getattr(self.model, model_name)
        n = self._wrap_bravado_model_generator(model, c.save_to_db, pkg_name)
        setattr(self.model, model_name, n)

        # Add class method load_from_db to model generator
        model = getattr(self.model, model_name)
        setattr(model, 'load_from_db', c.load_from_db)

Response: Monkey - patch object persistence to avoid unnecessary modification of the model class.


Instruction:
Write a Python 3 function for
spawning a new API endpoint for this application.

Response:
def spawn_api(self, app, decorator=None):
        """Auto-generate server endpoints implementing the API into this Flask app"""
        if decorator:
            assert type(decorator).__name__ == 'function'
        self.is_server = True
        self.app = app

        if self.local:
            # Re-generate client callers, this time as local and passing them the app
            self._generate_client_callers(app)

        return spawn_server_api(self.name, app, self.api_spec, self.error_callback, decorator)


Instruction:
Write a Python 3 script to
take a json strust and a model name and return a model instance

Response:
def json_to_model(self, model_name, j, validate=False):
        """Take a json strust and a model name, and return a model instance"""
        if validate:
            self.api_spec.validate(model_name, j)
        return self.api_spec.json_to_model(model_name, j)


Instruction:
Can you write a function in Python 3 where it
assembles items in iterable into discreet collections.

Response:
def assemble(
    iterable, patterns=None, minimum_items=2, case_sensitive=True,
    assume_padded_when_ambiguous=False
):
    '''Assemble items in *iterable* into discreet collections.

    *patterns* may be specified as a list of regular expressions to limit
    the returned collection possibilities. Use this when interested in
    collections that only match specific patterns. Each pattern must contain
    the expression from :py:data:`DIGITS_PATTERN` exactly once.

    A selection of common expressions are available in :py:data:`PATTERNS`.

    .. note::

        If a pattern is supplied as a string it will be automatically compiled
        to a :py:class:`re.RegexObject` instance for convenience.

    When *patterns* is not specified, collections are formed by examining all
    possible groupings of the items in *iterable* based around common numerical
    components.

    *minimum_items* dictates the minimum number of items a collection must have
    in order to be included in the result. The default is 2, filtering out
    single item collections.

    If *case_sensitive* is False, then items will be treated as part of the same
    collection when they only differ in casing. To avoid ambiguity, the
    resulting collection will always be lowercase. For example, "item.0001.dpx"
    and "Item.0002.dpx" would be part of the same collection, "item.%04d.dpx".

    .. note::

        Any compiled *patterns* will also respect the set case sensitivity.

    For certain collections it may be ambiguous whether they are padded or not.
    For example, 1000-1010 can be considered either an unpadded collection or a
    four padded collection. By default, Clique is conservative and assumes that
    the collection is unpadded. To change this behaviour, set
    *assume_padded_when_ambiguous* to True and any ambiguous collection will have
    a relevant padding set.

    .. note::

        *assume_padded_when_ambiguous* has no effect on collections that are
        unambiguous. For example, 1-100 will always be considered unpadded
        regardless of the *assume_padded_when_ambiguous* setting.

    Return tuple of two lists (collections, remainder) where 'collections' is a
    list of assembled :py:class:`~clique.collection.Collection` instances and
    'remainder' is a list of items that did not belong to any collection.

    '''
    collection_map = defaultdict(set)
    collections = []
    remainder = []

    # Compile patterns.
    flags = 0
    if not case_sensitive:
        flags |= re.IGNORECASE

    compiled_patterns = []

    if patterns is not None:
        if not patterns:
            return collections, list(iterable)

        for pattern in patterns:
            if isinstance(pattern, basestring):
                compiled_patterns.append(re.compile(pattern, flags=flags))
            else:
                compiled_patterns.append(pattern)

    else:
        compiled_patterns.append(re.compile(DIGITS_PATTERN, flags=flags))

    # Process iterable.
    for item in iterable:
        matched = False

        for pattern in compiled_patterns:
            for match in pattern.finditer(item):
                index = match.group('index')

                head = item[:match.start('index')]
                tail = item[match.end('index'):]

                if not case_sensitive:
                    head = head.lower()
                    tail = tail.lower()

                padding = match.group('padding')
                if padding:
                    padding = len(index)
                else:
                    padding = 0

                key = (head, tail, padding)
                collection_map[key].add(int(index))
                matched = True

        if not matched:
            remainder.append(item)

    # Form collections.
    merge_candidates = []
    for (head, tail, padding), indexes in collection_map.items():
        collection = Collection(head, tail, padding, indexes)
        collections.append(collection)

        if collection.padding == 0:
            merge_candidates.append(collection)

    # Merge together collections that align on padding boundaries. For example,
    # 0998-0999 and 1000-1001 can be merged into 0998-1001. Note that only
    # indexes within the padding width limit are merged. If a collection is
    # entirely merged into another then it will not be included as a separate
    # collection in the results.
    fully_merged = []
    for collection in collections:
        if collection.padding == 0:
            continue

        for candidate in merge_candidates:
            if (
                candidate.head == collection.head and
                candidate.tail == collection.tail
            ):
                merged_index_count = 0
                for index in candidate.indexes:
                    if len(str(abs(index))) == collection.padding:
                        collection.indexes.add(index)
                        merged_index_count += 1

                if merged_index_count == len(candidate.indexes):
                    fully_merged.append(candidate)

    # Filter out fully merged collections.
    collections = [collection for collection in collections
                   if collection not in fully_merged]

    # Filter out collections that do not have at least as many indexes as
    # minimum_items. In addition, add any members of a filtered collection,
    # which are not members of an unfiltered collection, to the remainder.
    filtered = []
    remainder_candidates = []
    for collection in collections:
        if len(collection.indexes) >= minimum_items:
            filtered.append(collection)
        else:
            for member in collection:
                remainder_candidates.append(member)

    for candidate in remainder_candidates:
        # Check if candidate has already been added to remainder to avoid
        # duplicate entries.
        if candidate in remainder:
            continue

        has_membership = False

        for collection in filtered:
            if candidate in collection:
                has_membership = True
                break

        if not has_membership:
            remainder.append(candidate)

    # Set padding for all ambiguous collections according to the
    # assume_padded_when_ambiguous setting.
    if assume_padded_when_ambiguous:
        for collection in filtered:
            if (
                not collection.padding and collection.indexes
            ):
                indexes = list(collection.indexes)
                first_index_width = len(str(indexes[0]))
                last_index_width = len(str(indexes[-1]))
                if first_index_width == last_index_width:
                    collection.padding = first_index_width

    return filtered, remainder


Instruction:
Given the following Python 3 function, write the documentation
def parse(value, pattern='{head}{padding}{tail} [{ranges}]'):
    '''Parse *value* into a :py:class:`~clique.collection.Collection`.

    Use *pattern* to extract information from *value*. It may make use of the
    following keys:

        * *head* - Common leading part of the collection.
        * *tail* - Common trailing part of the collection.
        * *padding* - Padding value in ``%0d`` format.
        * *range* - Total range in the form ``start-end``.
        * *ranges* - Comma separated ranges of indexes.
        * *holes* - Comma separated ranges of missing indexes.

    .. note::

        *holes* only makes sense if *range* or *ranges* is also present.

    '''
    # Construct regular expression for given pattern.
    expressions = {
        'head': '(?P<head>.*)',
        'tail': '(?P<tail>.*)',
        'padding': '%(?P<padding>\d*)d',
        'range': '(?P<range>\d+-\d+)?',
        'ranges': '(?P<ranges>[\d ,\-]+)?',
        'holes': '(?P<holes>[\d ,\-]+)'
    }

    pattern_regex = re.escape(pattern)
    for key, expression in expressions.items():
        pattern_regex = pattern_regex.replace(
            '\{{{0}\}}'.format(key),
            expression
        )
    pattern_regex = '^{0}$'.format(pattern_regex)

    # Match pattern against value and use results to construct collection.
    match = re.search(pattern_regex, value)
    if match is None:
        raise ValueError('Value did not match pattern.')

    groups = match.groupdict()
    if 'padding' in groups and groups['padding']:
        groups['padding'] = int(groups['padding'])
    else:
        groups['padding'] = 0

    # Create collection and then add indexes.
    collection = Collection(
        groups.get('head', ''),
        groups.get('tail', ''),
        groups['padding']
    )

    if groups.get('range', None) is not None:
        start, end = map(int, groups['range'].split('-'))
        collection.indexes.update(range(start, end + 1))

    if groups.get('ranges', None) is not None:
        parts = [part.strip() for part in groups['ranges'].split(',')]
        for part in parts:
            index_range = list(map(int, part.split('-', 2)))

            if len(index_range) > 1:
                # Index range.
                for index in range(index_range[0], index_range[1] + 1):
                    collection.indexes.add(index)
            else:
                # Single index.
                collection.indexes.add(index_range[0])

    if 'holes' in groups:
        parts = [part.strip() for part in groups['holes'].split(',')]
        for part in parts:
            index_range = map(int, part.split('-', 2))

            if len(index_range) > 1:
                # Index range.
                for index in range(index_range[0], index_range[1] + 1):
                    collection.indexes.remove(index)
            else:
                # Single index.
                collection.indexes.remove(index_range[0])

    return collection

Response: Parse a string into a : py : class ~clique. collection. Collection.


Instruction:
Explain what the following Python 3 code does
def add(self, item):
        '''Add *item*.'''
        if not item in self:
            index = bisect.bisect_right(self._members, item)
            self._members.insert(index, item)

Response: Add item to the list.


Instruction:
How would you code a function in Python 3 to
remove the specified item from the set.

Response:
def discard(self, item):
        '''Remove *item*.'''
        index = self._index(item)
        if index >= 0:
            del self._members[index]


Instruction:
Given the following Python 3 function, write the documentation
def _index(self, item):
        '''Return index of *item* in member list or -1 if not present.'''
        index = bisect.bisect_left(self._members, item)
        if index != len(self) and self._members[index] == item:
            return index

        return -1

Response: Return index of item in member list or - 1 if not present.


Instruction:
Can you create a Python 3 function that
returns whether the item matches this collection expression.

Response:
def match(self, item):
        '''Return whether *item* matches this collection expression.

        If a match is successful return data about the match otherwise return
        None.

        '''
        match = self._expression.match(item)
        if not match:
            return None

        index = match.group('index')
        padded = False
        if match.group('padding'):
            padded = True

        if self.padding == 0:
            if padded:
                return None

        elif len(index) != self.padding:
            return None

        return match


Instruction:
Can you generate a brief explanation for the following Python 3 code
def add(self, item):
        '''Add *item* to collection.

        raise :py:class:`~clique.error.CollectionError` if *item* cannot be
        added to the collection.

        '''
        match = self.match(item)
        if match is None:
            raise clique.error.CollectionError(
                'Item does not match collection expression.'
            )

        self.indexes.add(int(match.group('index')))

Response: Add item to the collection.


Instruction:
Write a Python 3 function that can
remove item from the collection.

Response:
def remove(self, item):
        '''Remove *item* from collection.

        raise :py:class:`~clique.error.CollectionError` if *item* cannot be
        removed from the collection.

        '''
        match = self.match(item)
        if match is None:
            raise clique.error.CollectionError(
                'Item not present in collection.'
            )

        index = int(match.group('index'))
        try:
            self.indexes.remove(index)
        except KeyError:
            raise clique.error.CollectionError(
                'Item not present in collection.'
            )


Instruction:
How would you code a function in Python 3 to
return string representation as specified by pattern.

Response:
def format(self, pattern='{head}{padding}{tail} [{ranges}]'):
        '''Return string representation as specified by *pattern*.

        Pattern can be any format accepted by Python's standard format function
        and will receive the following keyword arguments as context:

            * *head* - Common leading part of the collection.
            * *tail* - Common trailing part of the collection.
            * *padding* - Padding value in ``%0d`` format.
            * *range* - Total range in the form ``start-end``
            * *ranges* - Comma separated ranges of indexes.
            * *holes* - Comma separated ranges of missing indexes.

        '''
        data = {}
        data['head'] = self.head
        data['tail'] = self.tail

        if self.padding:
            data['padding'] = '%0{0}d'.format(self.padding)
        else:
            data['padding'] = '%d'

        if '{holes}' in pattern:
            data['holes'] = self.holes().format('{ranges}')

        if '{range}' in pattern or '{ranges}' in pattern:
            indexes = list(self.indexes)
            indexes_count = len(indexes)

            if indexes_count == 0:
                data['range'] = ''

            elif indexes_count == 1:
                data['range'] = '{0}'.format(indexes[0])

            else:
                data['range'] = '{0}-{1}'.format(
                    indexes[0], indexes[-1]
                )

        if '{ranges}' in pattern:
            separated = self.separate()
            if len(separated) > 1:
                ranges = [collection.format('{range}')
                          for collection in separated]

            else:
                ranges = [data['range']]

            data['ranges'] = ', '.join(ranges)

        return pattern.format(**data)


Instruction:
Write a Python 3 function that can
return whether entire collection is contiguous.

Response:
def is_contiguous(self):
        '''Return whether entire collection is contiguous.'''
        previous = None
        for index in self.indexes:
            if previous is None:
                previous = index
                continue

            if index != (previous + 1):
                return False

            previous = index

        return True


Instruction:
Explain what the following Python 3 code does
def holes(self):
        '''Return holes in collection.

        Return :py:class:`~clique.collection.Collection` of missing indexes.

        '''
        missing = set([])
        previous = None
        for index in self.indexes:
            if previous is None:
                previous = index
                continue

            if index != (previous + 1):
                missing.update(range(previous + 1, index))

            previous = index

        return Collection(self.head, self.tail, self.padding, indexes=missing)

Response: Return a new collection with holes in self.


Instruction:
Here you have a function in Python 3, explain what it does
def is_compatible(self, collection):
        '''Return whether *collection* is compatible with this collection.

        To be compatible *collection* must have the same head, tail and padding
        properties as this collection.

        '''
        return all([
            isinstance(collection, Collection),
            collection.head == self.head,
            collection.tail == self.tail,
            collection.padding == self.padding
        ])

Response: Return whether the given collection is compatible with this one.


Instruction:
Make a summary of the following Python 3 code
def merge(self, collection):
        '''Merge *collection* into this collection.

        If the *collection* is compatible with this collection then update
        indexes with all indexes in *collection*.

        raise :py:class:`~clique.error.CollectionError` if *collection* is not
        compatible with this collection.

        '''
        if not self.is_compatible(collection):
            raise clique.error.CollectionError('Collection is not compatible '
                                               'with this collection.')

        self.indexes.update(collection.indexes)

Response: Merge the current collection into the given collection.


Instruction:
Implement a Python 3 function for
returning contiguous parts of collection as separate collections.

Response:
def separate(self):
        '''Return contiguous parts of collection as separate collections.

        Return as list of :py:class:`~clique.collection.Collection` instances.

        '''
        collections = []
        start = None
        end = None

        for index in self.indexes:
            if start is None:
                start = index
                end = start
                continue

            if index != (end + 1):
                collections.append(
                    Collection(self.head, self.tail, self.padding,
                               indexes=set(range(start, end + 1)))
                )
                start = index

            end = index

        if start is None:
            collections.append(
                Collection(self.head, self.tail, self.padding)
            )
        else:
            collections.append(
                Collection(self.head, self.tail, self.padding,
                           indexes=range(start, end + 1))
            )

        return collections


Instruction:
Given the following Python 3 function, write the documentation
def format_check(settings):

    valid_keys = ['logs_folder', 'log_file', 'log_console', 'log_name',
                  'log_filename', 'keep_osm_tags']

    for key in list(settings.keys()):
        assert key in valid_keys, \
            ('{} not found in list of valid configuation keys').format(key)
        assert isinstance(key, str), ('{} must be a string').format(key)
        if key == 'keep_osm_tags':
            assert isinstance(settings[key], list), \
                ('{} must be a list').format(key)
            for value in settings[key]:
                assert all(isinstance(element, str) for element in value), \
                    'all elements must be a string'
        if key == 'log_file' or key == 'log_console':
            assert isinstance(settings[key], bool), \
                ('{} must be boolean').format(key)

Response: Check the format of a osmnet_config object.


Instruction:
Implement a function in Python 3 to
return a dict representation of an osmnet osmnet_config instance.

Response:
def to_dict(self):
        """
        Return a dict representation of an osmnet osmnet_config instance.
        """
        return {'logs_folder': self.logs_folder,
                'log_file': self.log_file,
                'log_console': self.log_console,
                'log_name': self.log_name,
                'log_filename': self.log_filename,
                'keep_osm_tags': self.keep_osm_tags
                }


Instruction:
Make a summary of the following Python 3 code
def great_circle_dist(lat1, lon1, lat2, lon2):
    radius = 6372795  # meters

    lat1 = math.radians(lat1)
    lon1 = math.radians(lon1)
    lat2 = math.radians(lat2)
    lon2 = math.radians(lon2)

    dlat = lat2 - lat1
    dlon = lon2 - lon1

    # formula from:
    # http://en.wikipedia.org/wiki/Haversine_formula#The_haversine_formula
    a = math.pow(math.sin(dlat / 2), 2)
    b = math.cos(lat1) * math.cos(lat2) * math.pow(math.sin(dlon / 2), 2)
    d = 2 * radius * math.asin(math.sqrt(a + b))

    return d

Response: Calculates the great circle distance between two lat / lon points and returns the distance in meters.


Instruction:
Create a Python 3 function for
creating a filter to query Overpass API for the specified OSM network type.

Response:
def osm_filter(network_type):
    """
    Create a filter to query Overpass API for the specified OSM network type.

    Parameters
    ----------
    network_type : string, {'walk', 'drive'} denoting the type of street
    network to extract

    Returns
    -------
    osm_filter : string
    """
    filters = {}

    # drive: select only roads that are drivable by normal 2 wheel drive
    # passenger vehicles both private and public
    # roads. Filter out un-drivable roads and service roads tagged as parking,
    # driveway, or emergency-access
    filters['drive'] = ('["highway"!~"cycleway|footway|path|pedestrian|steps'
                        '|track|proposed|construction|bridleway|abandoned'
                        '|platform|raceway|service"]'
                        '["motor_vehicle"!~"no"]["motorcar"!~"no"]'
                        '["service"!~"parking|parking_aisle|driveway'
                        '|emergency_access"]')

    # walk: select only roads and pathways that allow pedestrian access both
    # private and public pathways and roads.
    # Filter out limited access roadways and allow service roads
    filters['walk'] = ('["highway"!~"motor|proposed|construction|abandoned'
                       '|platform|raceway"]["foot"!~"no"]'
                       '["pedestrians"!~"no"]')

    if network_type in filters:
        osm_filter = filters[network_type]
    else:
        raise ValueError('unknown network_type "{}"'.format(network_type))

    return osm_filter


Instruction:
How would you explain what the following Python 3 function does
def osm_net_download(lat_min=None, lng_min=None, lat_max=None, lng_max=None,
                     network_type='walk', timeout=180, memory=None,
                     max_query_area_size=50*1000*50*1000,
                     custom_osm_filter=None):
    """
    Download OSM ways and nodes within a bounding box from the Overpass API.

    Parameters
    ----------
    lat_min : float
        southern latitude of bounding box
    lng_min : float
        eastern longitude of bounding box
    lat_max : float
        northern latitude of bounding box
    lng_max : float
        western longitude of bounding box
    network_type : string
        Specify the network type where value of 'walk' includes roadways
        where pedestrians are allowed and pedestrian
        pathways and 'drive' includes driveable roadways.
    timeout : int
        the timeout interval for requests and to pass to Overpass API
    memory : int
        server memory allocation size for the query, in bytes. If none,
        server will use its default allocation size
    max_query_area_size : float
        max area for any part of the geometry, in the units the geometry is
        in: any polygon bigger will get divided up for multiple queries to
        Overpass API (default is 50,000 * 50,000 units (ie, 50km x 50km in
        area, if units are meters))
    custom_osm_filter : string, optional
        specify custom arguments for the way["highway"] query to OSM. Must
        follow Overpass API schema. For
        example to request highway ways that are service roads use:
        '["highway"="service"]'

    Returns
    -------
    response_json : dict
    """

    # create a filter to exclude certain kinds of ways based on the requested
    # network_type
    if custom_osm_filter is None:
        request_filter = osm_filter(network_type)
    else:
        request_filter = custom_osm_filter

    response_jsons_list = []
    response_jsons = []

    # server memory allocation in bytes formatted for Overpass API query
    if memory is None:
        maxsize = ''
    else:
        maxsize = '[maxsize:{}]'.format(memory)

    # define the Overpass API query
    # way["highway"] denotes ways with highway keys and {filters} returns
    # ways with the requested key/value. the '>' makes it recurse so we get
    # ways and way nodes. maxsize is in bytes.

    # turn bbox into a polygon and project to local UTM
    polygon = Polygon([(lng_max, lat_min), (lng_min, lat_min),
                       (lng_min, lat_max), (lng_max, lat_max)])
    geometry_proj, crs_proj = project_geometry(polygon,
                                               crs={'init': 'epsg:4326'})

    # subdivide the bbox area poly if it exceeds the max area size
    # (in meters), then project back to WGS84
    geometry_proj_consolidated_subdivided = consolidate_subdivide_geometry(
        geometry_proj, max_query_area_size=max_query_area_size)
    geometry, crs = project_geometry(geometry_proj_consolidated_subdivided,
                                     crs=crs_proj, to_latlong=True)
    log('Requesting network data within bounding box from Overpass API '
        'in {:,} request(s)'.format(len(geometry)))
    start_time = time.time()

    # loop through each polygon in the geometry
    for poly in geometry:
        # represent bbox as lng_max, lat_min, lng_min, lat_max and round
        # lat-longs to 8 decimal places to create
        # consistent URL strings
        lng_max, lat_min, lng_min, lat_max = poly.bounds
        query_template = '[out:json][timeout:{timeout}]{maxsize};' \
                         '(way["highway"]' \
                         '{filters}({lat_min:.8f},{lng_max:.8f},' \
                         '{lat_max:.8f},{lng_min:.8f});>;);out;'
        query_str = query_template.format(lat_max=lat_max, lat_min=lat_min,
                                          lng_min=lng_min, lng_max=lng_max,
                                          filters=request_filter,
                                          timeout=timeout, maxsize=maxsize)
        response_json = overpass_request(data={'data': query_str},
                                         timeout=timeout)

        response_jsons_list.append(response_json)

    log('Downloaded OSM network data within bounding box from Overpass '
        'API in {:,} request(s) and'
        ' {:,.2f} seconds'.format(len(geometry), time.time()-start_time))

    # stitch together individual json results
    for json in response_jsons_list:
        try:
            response_jsons.extend(json['elements'])
        except KeyError:
            pass

    # remove duplicate records resulting from the json stitching
    start_time = time.time()
    record_count = len(response_jsons)

    if record_count == 0:
        raise Exception('Query resulted in no data. Check your query '
                        'parameters: {}'.format(query_str))
    else:
        response_jsons_df = pd.DataFrame.from_records(response_jsons,
                                                      index='id')
        nodes = response_jsons_df[response_jsons_df['type'] == 'node']
        nodes = nodes[~nodes.index.duplicated(keep='first')]
        ways = response_jsons_df[response_jsons_df['type'] == 'way']
        ways = ways[~ways.index.duplicated(keep='first')]
        response_jsons_df = pd.concat([nodes, ways], axis=0)
        response_jsons_df.reset_index(inplace=True)
        response_jsons = response_jsons_df.to_dict(orient='records')
        if record_count - len(response_jsons) > 0:
            log('{:,} duplicate records removed. Took {:,.2f} seconds'.format(
                record_count - len(response_jsons), time.time() - start_time))

    return {'elements': response_jsons}

Response: Download OSM ways and nodes within a bounding box from the Overpass API.


Instruction:
How would you explain what the following Python 3 function does
def overpass_request(data, pause_duration=None, timeout=180,
                     error_pause_duration=None):
    """
    Send a request to the Overpass API via HTTP POST and return the
    JSON response

    Parameters
    ----------
    data : dict or OrderedDict
        key-value pairs of parameters to post to Overpass API
    pause_duration : int
        how long to pause in seconds before requests, if None, will query
        Overpass API status endpoint
        to find when next slot is available
    timeout : int
        the timeout interval for the requests library
    error_pause_duration : int
        how long to pause in seconds before re-trying requests if error

    Returns
    -------
    response_json : dict
    """

    # define the Overpass API URL, then construct a GET-style URL
    url = 'http://www.overpass-api.de/api/interpreter'

    start_time = time.time()
    log('Posting to {} with timeout={}, "{}"'.format(url, timeout, data))
    response = requests.post(url, data=data, timeout=timeout)

    # get the response size and the domain, log result
    size_kb = len(response.content) / 1000.
    domain = re.findall(r'//(?s)(.*?)/', url)[0]
    log('Downloaded {:,.1f}KB from {} in {:,.2f} seconds'
        .format(size_kb, domain, time.time()-start_time))

    try:
        response_json = response.json()
        if 'remark' in response_json:
            log('Server remark: "{}"'.format(response_json['remark'],
                                             level=lg.WARNING))

    except Exception:
        # 429 = 'too many requests' and 504 = 'gateway timeout' from server
        # overload. handle these errors by recursively
        # calling overpass_request until a valid response is achieved
        if response.status_code in [429, 504]:
            # pause for error_pause_duration seconds before re-trying request
            if error_pause_duration is None:
                error_pause_duration = get_pause_duration()
            log('Server at {} returned status code {} and no JSON data. '
                'Re-trying request in {:.2f} seconds.'
                .format(domain, response.status_code, error_pause_duration),
                level=lg.WARNING)
            time.sleep(error_pause_duration)
            response_json = overpass_request(data=data,
                                             pause_duration=pause_duration,
                                             timeout=timeout)

        # else, this was an unhandled status_code, throw an exception
        else:
            log('Server at {} returned status code {} and no JSON data'
                .format(domain, response.status_code), level=lg.ERROR)
            raise Exception('Server returned no JSON data.\n{} {}\n{}'
                            .format(response, response.reason, response.text))

    return response_json

Response: Send a request to the Overpass API and return the JSON response


Instruction:
How would you explain what the following Python 3 function does
def get_pause_duration(recursive_delay=5, default_duration=10):
    try:
        response = requests.get('http://overpass-api.de/api/status')
        status = response.text.split('\n')[3]
        status_first_token = status.split(' ')[0]
    except Exception:
        # if status endpoint cannot be reached or output parsed, log error
        # and return default duration
        log('Unable to query http://overpass-api.de/api/status',
            level=lg.ERROR)
        return default_duration

    try:
        # if first token is numeric, it indicates the number of slots
        # available - no wait required
        available_slots = int(status_first_token)
        pause_duration = 0
    except Exception:
        # if first token is 'Slot', it tells you when your slot will be free
        if status_first_token == 'Slot':
            utc_time_str = status.split(' ')[3]
            utc_time = date_parser.parse(utc_time_str).replace(tzinfo=None)
            pause_duration = math.ceil(
                (utc_time - dt.datetime.utcnow()).total_seconds())
            pause_duration = max(pause_duration, 1)

        # if first token is 'Currently', it is currently running a query so
        # check back in recursive_delay seconds
        elif status_first_token == 'Currently':
            time.sleep(recursive_delay)
            pause_duration = get_pause_duration()

        else:
            # any other status is unrecognized - log an error and return
            # default duration
            log('Unrecognized server status: "{}"'.format(status),
                level=lg.ERROR)
            return default_duration

    return pause_duration

Response: Get the pause duration of the current item in the order they are available.


Instruction:
Explain what the following Python 3 code does
def consolidate_subdivide_geometry(geometry, max_query_area_size):

    # let the linear length of the quadrats (with which to subdivide the
    # geometry) be the square root of max area size
    quadrat_width = math.sqrt(max_query_area_size)

    if not isinstance(geometry, (Polygon, MultiPolygon)):
        raise ValueError('Geometry must be a shapely Polygon or MultiPolygon')

    # if geometry is a MultiPolygon OR a single Polygon whose area exceeds
    # the max size, get the convex hull around the geometry
    if isinstance(
            geometry, MultiPolygon) or \
            (isinstance(
                geometry, Polygon) and geometry.area > max_query_area_size):
        geometry = geometry.convex_hull

    # if geometry area exceeds max size, subdivide it into smaller sub-polygons
    if geometry.area > max_query_area_size:
        geometry = quadrat_cut_geometry(geometry, quadrat_width=quadrat_width)

    if isinstance(geometry, Polygon):
        geometry = MultiPolygon([geometry])

    return geometry

Response: Consolidate a geometry into a convex hull then subdivide it into smaller sub - polygons if it exceeds max_query_area_size.


Instruction:
Can you tell what is the following Python 3 function doing
def quadrat_cut_geometry(geometry, quadrat_width, min_num=3,
                         buffer_amount=1e-9):
    """
    Split a Polygon or MultiPolygon up into sub-polygons of a specified size,
    using quadrats.

    Parameters
    ----------
    geometry : shapely Polygon or MultiPolygon
        the geometry to split up into smaller sub-polygons
    quadrat_width : float
        the linear width of the quadrats with which to cut up the geometry
        (in the units the geometry is in)
    min_num : float
        the minimum number of linear quadrat lines (e.g., min_num=3 would
        produce a quadrat grid of 4 squares)
    buffer_amount : float
        buffer the quadrat grid lines by quadrat_width times buffer_amount

    Returns
    -------
    multipoly : shapely MultiPolygon
    """

    # create n evenly spaced points between the min and max x and y bounds
    lng_max, lat_min, lng_min, lat_max = geometry.bounds
    x_num = math.ceil((lng_min-lng_max) / quadrat_width) + 1
    y_num = math.ceil((lat_max-lat_min) / quadrat_width) + 1
    x_points = np.linspace(lng_max, lng_min, num=max(x_num, min_num))
    y_points = np.linspace(lat_min, lat_max, num=max(y_num, min_num))

    # create a quadrat grid of lines at each of the evenly spaced points
    vertical_lines = [LineString([(x, y_points[0]), (x, y_points[-1])])
                      for x in x_points]
    horizont_lines = [LineString([(x_points[0], y), (x_points[-1], y)])
                      for y in y_points]
    lines = vertical_lines + horizont_lines

    # buffer each line to distance of the quadrat width divided by 1 billion,
    # take their union, then cut geometry into pieces by these quadrats
    buffer_size = quadrat_width * buffer_amount
    lines_buffered = [line.buffer(buffer_size) for line in lines]
    quadrats = unary_union(lines_buffered)
    multipoly = geometry.difference(quadrats)

    return multipoly

Response: Split a shapely Polygon or MultiPolygon into smaller sub - polygons and buffer them into smaller quadrats.


Instruction:
Create a Python 3 function for
projecting a shapely geometry to a shapely polygon or MultiPolygon from WGS84 to UTM or vice - versa.

Response:
def project_geometry(geometry, crs, to_latlong=False):
    """
    Project a shapely Polygon or MultiPolygon from WGS84 to UTM, or vice-versa

    Parameters
    ----------
    geometry : shapely Polygon or MultiPolygon
        the geometry to project
    crs : int
        the starting coordinate reference system of the passed-in geometry
    to_latlong : bool
        if True, project from crs to WGS84, if False, project
        from crs to local UTM zone

    Returns
    -------
    geometry_proj, crs : tuple (projected shapely geometry, crs of the
    projected geometry)
    """
    gdf = gpd.GeoDataFrame()
    gdf.crs = crs
    gdf.name = 'geometry to project'
    gdf['geometry'] = None
    gdf.loc[0, 'geometry'] = geometry
    gdf_proj = project_gdf(gdf, to_latlong=to_latlong)
    geometry_proj = gdf_proj['geometry'].iloc[0]
    return geometry_proj, gdf_proj.crs


Instruction:
Can you generate a brief explanation for the following Python 3 code
def process_node(e):
    node = {'id': e['id'],
            'lat': e['lat'],
            'lon': e['lon']}

    if 'tags' in e:
        if e['tags'] is not np.nan:
            for t, v in list(e['tags'].items()):
                if t in config.settings.keep_osm_tags:
                    node[t] = v

    return node

Response: Process a node element entry into a dict suitable for going into a Pandas DataFrame.


Instruction:
How would you explain what the following Python 3 function does
def process_way(e):
    way = {'id': e['id']}

    if 'tags' in e:
        if e['tags'] is not np.nan:
            for t, v in list(e['tags'].items()):
                if t in config.settings.keep_osm_tags:
                    way[t] = v

    # nodes that make up a way
    waynodes = []

    for n in e['nodes']:
        waynodes.append({'way_id': e['id'], 'node_id': n})

    return way, waynodes

Response: Process a way element entry into a list of dicts suitable for going into a Pandas DataFrame.


Instruction:
Explain what the following Python 3 code does
def parse_network_osm_query(data):
    if len(data['elements']) == 0:
        raise RuntimeError('OSM query results contain no data.')

    nodes = []
    ways = []
    waynodes = []

    for e in data['elements']:
        if e['type'] == 'node':
            nodes.append(process_node(e))
        elif e['type'] == 'way':
            w, wn = process_way(e)
            ways.append(w)
            waynodes.extend(wn)

    nodes = pd.DataFrame.from_records(nodes, index='id')
    ways = pd.DataFrame.from_records(ways, index='id')
    waynodes = pd.DataFrame.from_records(waynodes, index='way_id')

    return (nodes, ways, waynodes)

Response: Convert OSM query data to DataFrames of ways and way - nodes.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def ways_in_bbox(lat_min, lng_min, lat_max, lng_max, network_type,
                 timeout=180, memory=None,
                 max_query_area_size=50*1000*50*1000,
                 custom_osm_filter=None):
    """
    Get DataFrames of OSM data in a bounding box.

    Parameters
    ----------
    lat_min : float
        southern latitude of bounding box
    lng_min : float
        eastern longitude of bounding box
    lat_max : float
        northern latitude of bounding box
    lng_max : float
        western longitude of bounding box
    network_type : {'walk', 'drive'}, optional
        Specify the network type where value of 'walk' includes roadways
        where pedestrians are allowed and pedestrian pathways and 'drive'
        includes driveable roadways.
    timeout : int
        the timeout interval for requests and to pass to Overpass API
    memory : int
        server memory allocation size for the query, in bytes. If none,
        server will use its default allocation size
    max_query_area_size : float
        max area for any part of the geometry, in the units the geometry is
        in: any polygon bigger will get divided up for multiple queries to
        Overpass API (default is 50,000 * 50,000 units (ie, 50km x 50km in
        area, if units are meters))
    custom_osm_filter : string, optional
        specify custom arguments for the way["highway"] query to OSM. Must
        follow Overpass API schema. For
        example to request highway ways that are service roads use:
        '["highway"="service"]'

    Returns
    -------
    nodes, ways, waynodes : pandas.DataFrame

    """
    return parse_network_osm_query(
        osm_net_download(lat_max=lat_max, lat_min=lat_min, lng_min=lng_min,
                         lng_max=lng_max, network_type=network_type,
                         timeout=timeout, memory=memory,
                         max_query_area_size=max_query_area_size,
                         custom_osm_filter=custom_osm_filter))

Response: Get DataFrames of OSM data in a bounding box.


Instruction:
Make a summary of the following Python 3 code
def intersection_nodes(waynodes):
    counts = waynodes.node_id.value_counts()
    return set(counts[counts > 1].index.values)

Response: Returns a set of all the nodes that appear in 2 or more ways.