Instruction:
How would you implement a function in Python 3 that
generates a wildcard certificate valid for otope 10 years.

Response:
def generate_wildcard_pem_bytes():
    """
    Generate a wildcard (subject name '*') self-signed certificate valid for
    10 years.

    https://cryptography.io/en/latest/x509/tutorial/#creating-a-self-signed-certificate

    :return: Bytes representation of the PEM certificate data
    """
    key = generate_private_key(u'rsa')
    name = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, u'*')])
    cert = (
        x509.CertificateBuilder()
        .issuer_name(name)
        .subject_name(name)
        .not_valid_before(datetime.today() - timedelta(days=1))
        .not_valid_after(datetime.now() + timedelta(days=3650))
        .serial_number(int(uuid.uuid4()))
        .public_key(key.public_key())
        .sign(
            private_key=key,
            algorithm=hashes.SHA256(),
            backend=default_backend())
        )

    return b''.join((
        key.private_bytes(
            encoding=serialization.Encoding.PEM,
            format=serialization.PrivateFormat.TraditionalOpenSSL,
            encryption_algorithm=serialization.NoEncryption()),
        cert.public_bytes(serialization.Encoding.PEM)
    ))


Instruction:
How would you explain what the following Python 3 function does
def from_env(cls, reactor=None, env=os.environ):
        address = env.get('VAULT_ADDR', 'https://127.0.0.1:8200')
        # This seems to be what the Vault CLI defaults to
        token = env.get('VAULT_TOKEN', 'TEST')

        ca_cert = env.get('VAULT_CACERT')
        tls_server_name = env.get('VAULT_TLS_SERVER_NAME')
        client_cert = env.get('VAULT_CLIENT_CERT')
        client_key = env.get('VAULT_CLIENT_KEY')
        cf = ClientPolicyForHTTPS.from_pem_files(
            caKey=ca_cert, privateKey=client_key, certKey=client_cert,
            tls_server_name=tls_server_name
        )
        client, reactor = default_client(reactor, contextFactory=cf)

        return cls(address, token, client=client, reactor=reactor)

Response: Create a new client with configuration from the environment variables.


Instruction:
Create a Python 3 function for
reading data from Vault. Returns the JSON - decoded response.

Response:
def read(self, path, **params):
        """
        Read data from Vault. Returns the JSON-decoded response.
        """
        d = self.request('GET', '/v1/' + path, params=params)
        return d.addCallback(self._handle_response)


Instruction:
Can you generate a brief explanation for the following Python 3 code
def write(self, path, **data):
        d = self.request('PUT', '/v1/' + path, json=data)
        return d.addCallback(self._handle_response, check_cas=True)

Response: Write data to Vault. Returns the JSON - decoded response.


Instruction:
Can you write a function in Python 3 where it
reads some data from a key value version 2 secret engine.

Response:
def read_kv2(self, path, version=None, mount_path='secret'):
        """
        Read some data from a key/value version 2 secret engine.
        """
        params = {}
        if version is not None:
            params['version'] = version

        read_path = '{}/data/{}'.format(mount_path, path)
        return self.read(read_path, **params)


Instruction:
How would you explain what the following Python 3 function does
def create_or_update_kv2(self, path, data, cas=None, mount_path='secret'):
        params = {
            'options': {},
            'data': data
        }
        if cas is not None:
            params['options']['cas'] = cas

        write_path = '{}/data/{}'.format(mount_path, path)
        return self.write(write_path, **params)

Response: Create or update a key - value entry in a key - value version 2 secret engine.


Instruction:
How would you code a function in Python 3 to
get a single value for the given key out of the given set of headers.

Response:
def get_single_header(headers, key):
    """
    Get a single value for the given key out of the given set of headers.

    :param twisted.web.http_headers.Headers headers:
        The set of headers in which to look for the header value
    :param str key:
        The header key
    """
    raw_headers = headers.getRawHeaders(key)
    if raw_headers is None:
        return None

    # Take the final header as the authorative
    header, _ = cgi.parse_header(raw_headers[-1])
    return header


Instruction:
Write a Python 3 function for
raising an exception if the response did not succeed.

Response:
def raise_for_status(response):
    """
    Raises a `requests.exceptions.HTTPError` if the response did not succeed.
    Adapted from the Requests library:
    https://github.com/kennethreitz/requests/blob/v2.8.1/requests/models.py#L825-L837
    """
    http_error_msg = ''

    if 400 <= response.code < 500:
        http_error_msg = '%s Client Error for url: %s' % (
            response.code, uridecode(response.request.absoluteURI))

    elif 500 <= response.code < 600:
        http_error_msg = '%s Server Error for url: %s' % (
            response.code, uridecode(response.request.absoluteURI))

    if http_error_msg:
        raise HTTPError(http_error_msg, response=response)

    return response


Instruction:
Can you tell what is the following Python 3 function doing
def _compose_url(self, url, kwargs):
        if url is None:
            url = self.url

        if url is None:
            raise ValueError(
                'url not provided and this client has no url attribute')

        split_result = urisplit(url)
        userinfo = split_result.userinfo

        # Build up the kwargs to pass to uricompose
        compose_kwargs = {}
        for key in ['scheme', 'host', 'port', 'path', 'fragment']:
            if key in kwargs:
                compose_kwargs[key] = kwargs.pop(key)
            else:
                compose_kwargs[key] = getattr(split_result, key)

        if 'params' in kwargs:
            compose_kwargs['query'] = kwargs.pop('params')
        else:
            compose_kwargs['query'] = split_result.query

        # Take the userinfo out of the URL and pass as 'auth' to treq so it can
        # be used for HTTP basic auth headers
        if 'auth' not in kwargs and userinfo is not None:
            # treq expects a 2-tuple (username, password)
            kwargs['auth'] = tuple(userinfo.split(':', 2))

        return uricompose(**compose_kwargs)

Response: Compose a URL with the given kwargs.


Instruction:
Create a Python 3 function for
performing a request to the specified URL.

Response:
def request(self, method, url=None, **kwargs):
        """
        Perform a request.

        :param: method:
            The HTTP method to use (example is `GET`).
        :param: url:
            The URL to use. The default value is the URL this client was
            created with (`self.url`) (example is `http://localhost:8080`)
        :param: kwargs:
            Any other parameters that will be passed to `treq.request`, for
            example headers. Or any URL parameters to override, for example
            path, query or fragment.
        """
        url = self._compose_url(url, kwargs)

        kwargs.setdefault('timeout', self._timeout)

        d = self._client.request(method, url, reactor=self._reactor, **kwargs)

        d.addCallback(self._log_request_response, method, url, kwargs)
        d.addErrback(self._log_request_error, url)

        return d


Instruction:
Can you tell what is the following Python 3 function doing
def listen(self, reactor, endpoint_description):
        endpoint = serverFromString(reactor, endpoint_description)
        return endpoint.listen(Site(self.app.resource()))

Response: Start the server listening for requests on the given host and port.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def health(self, request):
        if self.health_handler is None:
            return self._no_health_handler(request)

        health = self.health_handler()
        response_code = OK if health.healthy else SERVICE_UNAVAILABLE
        request.setResponseCode(response_code)
        write_request_json(request, health.json_message)

Response: Listens to incoming health checks from Marathon on / health.


Instruction:
Make a summary of the following Python 3 code
def parse_listen_addr(listen_addr):
    if ':' not in listen_addr:
        raise ValueError(
            "'%s' does not have the correct form for a listen address: "
            '[ipaddress]:port' % (listen_addr,))
    host, port = listen_addr.rsplit(':', 1)

    # Validate the host
    if host == '':
        protocol = 'tcp'
        interface = None
    else:
        if host.startswith('[') and host.endswith(']'):  # IPv6 wrapped in []
            host = host[1:-1]
        ip_address = ipaddress.ip_address(_to_unicode(host))
        protocol = 'tcp6' if ip_address.version == 6 else 'tcp'
        interface = str(ip_address)

    # Validate the port
    if not port.isdigit() or int(port) < 1 or int(port) > 65535:
        raise ValueError(
            "'%s' does not appear to be a valid port number" % (port,))

    args = [protocol, port]
    kwargs = {'interface': interface} if interface is not None else {}

    return _create_tx_endpoints_string(args, kwargs)

Response:
Parses a listen address into a Twisted
    endpoint description string for use with with
   .


Instruction:
Here you have a function in Python 3, explain what it does
def create_marathon_acme(
    client_creator, cert_store, acme_email, allow_multiple_certs,
    marathon_addrs, marathon_timeout, sse_timeout, mlb_addrs, group,
        reactor):
    """
    Create a marathon-acme instance.

    :param client_creator:
        The txacme client creator function.
    :param cert_store:
        The txacme certificate store instance.
    :param acme_email:
        Email address to use when registering with the ACME service.
    :param allow_multiple_certs:
        Whether to allow multiple certificates per app port.
    :param marathon_addr:
        Address for the Marathon instance to find app domains that require
        certificates.
    :param marathon_timeout:
        Amount of time in seconds to wait for response headers to be received
        from Marathon.
    :param sse_timeout:
        Amount of time in seconds to wait for some event data to be received
        from Marathon.
    :param mlb_addrs:
        List of addresses for marathon-lb instances to reload when a new
        certificate is issued.
    :param group:
        The marathon-lb group (``HAPROXY_GROUP``) to consider when finding
        app domains.
    :param reactor: The reactor to use.
    """
    marathon_client = MarathonClient(marathon_addrs, timeout=marathon_timeout,
                                     sse_kwargs={'timeout': sse_timeout},
                                     reactor=reactor)
    marathon_lb_client = MarathonLbClient(mlb_addrs, reactor=reactor)

    return MarathonAcme(
        marathon_client,
        group,
        cert_store,
        marathon_lb_client,
        client_creator,
        reactor,
        acme_email,
        allow_multiple_certs
    )

Response: Create a Marathon - acme instance.


Instruction:
How would you code a function in Python 3 to
initialise the storage directory with the certificates directory and the default wildcard self - signed certificate for HAProxy.

Response:
def init_storage_dir(storage_dir):
    """
    Initialise the storage directory with the certificates directory and a
    default wildcard self-signed certificate for HAProxy.

    :return: the storage path and certs path
    """
    storage_path = FilePath(storage_dir)

    # Create the default wildcard certificate if it doesn't already exist
    default_cert_path = storage_path.child('default.pem')
    if not default_cert_path.exists():
        default_cert_path.setContent(generate_wildcard_pem_bytes())

    # Create a directory for unmanaged certs. We don't touch this again, but it
    # needs to be there and it makes sense to create it at the same time as
    # everything else.
    unmanaged_certs_path = storage_path.child('unmanaged-certs')
    if not unmanaged_certs_path.exists():
        unmanaged_certs_path.createDirectory()

    # Store certificates in a directory inside the storage directory, so
    # HAProxy will read just the certificates there.
    certs_path = storage_path.child('certs')
    if not certs_path.exists():
        certs_path.createDirectory()

    return storage_path, certs_path


Instruction:
How would you code a function in Python 3 to
initialise the logging by adding an observer to the global log publisher.

Response:
def init_logging(log_level):
    """
    Initialise the logging by adding an observer to the global log publisher.

    :param str log_level: The minimum log level to log messages for.
    """
    log_level_filter = LogLevelFilterPredicate(
        LogLevel.levelWithName(log_level))
    log_level_filter.setLogLevelForNamespace(
        'twisted.web.client._HTTP11ClientFactory', LogLevel.warn)
    log_observer = FilteringLogObserver(
        textFileLogObserver(sys.stdout), [log_level_filter])
    globalLogPublisher.addObserver(log_observer)


Instruction:
Can you tell what is the following Python 3 function doing
def _parse_field_value(line):
    if line.startswith(':'):
        # Ignore the line
        return None, None

    if ':' not in line:
        # Treat the entire line as the field, use empty string as value
        return line, ''

    # Else field is before the ':' and value is after
    field, value = line.split(':', 1)

    # If value starts with a space, remove it.
    value = value[1:] if value.startswith(' ') else value

    return field, value

Response: Parse the field and value from a line.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def _abortConnection(self):
        transport = self.transport
        if isinstance(transport, TransportProxyProducer):
            transport = transport._producer

        if hasattr(transport, 'abortConnection'):
            transport.abortConnection()
        else:
            self.log.error(
                'Transport {} has no abortConnection method'.format(transport))

Response: Aborts the connection to the specified object.


Instruction:
Create a Python 3 function to
call by the protocol class when data is received.

Response:
def dataReceived(self, data):
        """
        Translates bytes into lines, and calls lineReceived.

        Copied from ``twisted.protocols.basic.LineOnlyReceiver`` but using
        str.splitlines() to split on ``\r\n``, ``\n``, and ``\r``.
        """
        self.resetTimeout()
        lines = (self._buffer + data).splitlines()

        # str.splitlines() doesn't split the string after a trailing newline
        # character so we must check if there is a trailing newline and, if so,
        # clear the buffer as the line is "complete". Else, the line is
        # incomplete and we keep the last line in the buffer.
        if data.endswith(b'\n') or data.endswith(b'\r'):
            self._buffer = b''
        else:
            self._buffer = lines.pop(-1)

        for line in lines:
            if self.transport.disconnecting:
                # this is necessary because the transport may be told to lose
                # the connection by a line within a larger packet, and it is
                # important to disregard all the lines in that packet following
                # the one that told it to close.
                return
            if len(line) > self._max_length:
                self.lineLengthExceeded(line)
                return
            else:
                self.lineReceived(line)
        if len(self._buffer) > self._max_length:
            self.lineLengthExceeded(self._buffer)
            return


Instruction:
Can you create a Python 3 function that
handles the field and value pair.

Response:
def _handle_field_value(self, field, value):
        """ Handle the field, value pair. """
        if field == 'event':
            self._event = value
        elif field == 'data':
            self._data_lines.append(value)
        elif field == 'id':
            # Not implemented
            pass
        elif field == 'retry':
            # Not implemented
            pass


Instruction:
Make a summary of the following Python 3 code
def _dispatch_event(self):
        data = self._prepare_data()
        if data is not None:
            self._handler(self._event, data)

        self._reset_event_data()

Response: Dispatch the event to the handler.


Instruction:
Create a Python 3 function to
listen for events from Marathon.

Response:
def listen_events(self, reconnects=0):
        """
        Start listening for events from Marathon, running a sync when we first
        successfully subscribe and triggering a sync on API request events.
        """
        self.log.info('Listening for events from Marathon...')
        self._attached = False

        def on_finished(result, reconnects):
            # If the callback fires then the HTTP request to the event stream
            # went fine, but the persistent connection for the SSE stream was
            # dropped. Just reconnect for now- if we can't actually connect
            # then the errback will fire rather.
            self.log.warn('Connection lost listening for events, '
                          'reconnecting... ({reconnects} so far)',
                          reconnects=reconnects)
            reconnects += 1
            return self.listen_events(reconnects)

        def log_failure(failure):
            self.log.failure('Failed to listen for events', failure)
            return failure

        return self.marathon_client.get_events({
            'event_stream_attached': self._sync_on_event_stream_attached,
            'api_post_event': self._sync_on_api_post_event
        }).addCallbacks(on_finished, log_failure, callbackArgs=[reconnects])


Instruction:
Can you generate a brief explanation for the following Python 3 code
def sync(self):
        self.log.info('Starting a sync...')

        def log_success(result):
            self.log.info('Sync completed successfully')
            return result

        def log_failure(failure):
            self.log.failure('Sync failed', failure, LogLevel.error)
            return failure

        return (self.marathon_client.get_apps()
                .addCallback(self._apps_acme_domains)
                .addCallback(self._filter_new_domains)
                .addCallback(self._issue_certs)
                .addCallbacks(log_success, log_failure))

Response: Fetch the list of apps from Marathon and issue certificates for any domains that require a certificate.


Instruction:
Make a summary of the following Python 3 code
def _issue_cert(self, domain):
        def errback(failure):
            # Don't fail on some of the errors we could get from the ACME
            # server, rather just log an error so that we can continue with
            # other domains.
            failure.trap(txacme_ServerError)
            acme_error = failure.value.message

            if acme_error.code in ['rateLimited', 'serverInternal',
                                   'connection', 'unknownHost']:
                # TODO: Fire off an error to Sentry or something?
                self.log.error(
                    'Error ({code}) issuing certificate for "{domain}": '
                    '{detail}', code=acme_error.code, domain=domain,
                    detail=acme_error.detail)
            else:
                # There are more error codes but if they happen then something
                # serious has gone wrong-- carry on error-ing.
                return failure

        d = self.txacme_service.issue_cert(domain)
        return d.addErrback(errback)

Response: Issue a certificate for the given domain.


Instruction:
Explain what the following Python 3 code does
def warn_if_detached(func):
    @wraps(func)
    def wrapped(this, *args, **kwargs):
        # Check for _detached in __dict__ instead of using hasattr
        # to avoid infinite loop in __getattr__
        if '_detached' in this.__dict__ and this._detached:
            warnings.warn('here')
        return func(this, *args, **kwargs)
    return wrapped

Response: Decorator to warn if self / cls is detached.


Instruction:
Create a Python 3 function for
ensuring that self/cls contains a Storage backend.

Response:
def has_storage(func):
    """ Ensure that self/cls contains a Storage backend. """
    @wraps(func)
    def wrapped(*args, **kwargs):
        me = args[0]
        if not hasattr(me, '_storage') or \
                not me._storage:
            raise exceptions.ImproperConfigurationError(
                'No storage backend attached to schema <{0}>.'
                    .format(me._name.upper())
            )
        return func(*args, **kwargs)
    return wrapped


Instruction:
Given the following Python 3 function, write the documentation
def rm_fwd_refs(obj):
    for stack, key in obj._backrefs_flat:

        # Unpack stack
        backref_key, parent_schema_name, parent_field_name = stack

        # Get parent info
        parent_schema = obj._collections[parent_schema_name]
        parent_key_store = parent_schema._pk_to_storage(key)
        parent_object = parent_schema.load(parent_key_store)
        if parent_object is None:
            continue

        # Remove forward references
        if parent_object._fields[parent_field_name]._list:
            getattr(parent_object, parent_field_name).remove(obj)
        else:
            parent_field_object = parent_object._fields[parent_field_name]
            setattr(parent_object, parent_field_name, parent_field_object._gen_default())

        # Save
        parent_object.save()

Response:
When removing an object other objects with forward references to the current object should remove those references. This function identifies objects
    with forward references to the current object then removes those references.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def rm_back_refs(obj):
    for ref in _collect_refs(obj):
        ref['value']._remove_backref(
            ref['field_instance']._backref_field_name,
            obj,
            ref['field_name'],
            strict=False
        )

Response: When removing an object with foreign fields back - references from other objects to the current object should be deleted.


Instruction:
Write a Python 3 function for
ensuring that all forward references on the provided object have the appropriate backreferences.

Response:
def ensure_backrefs(obj, fields=None):
    """Ensure that all forward references on the provided object have the
    appropriate backreferences.

    :param StoredObject obj: Database record
    :param list fields: Optional list of field names to check

    """
    for ref in _collect_refs(obj, fields):
        updated = ref['value']._update_backref(
            ref['field_instance']._backref_field_name,
            obj,
            ref['field_name'],
        )
        if updated:
            logging.debug('Updated reference {}:{}:{}:{}:{}'.format(
                obj._name, obj._primary_key, ref['field_name'],
                ref['value']._name, ref['value']._primary_key,
            ))


Instruction:
Can you generate the documentation for the following Python 3 function
def _remove_by_pk(self, key, flush=True):
        try:
            del self.store[key]
        except Exception as error:
            pass
        if flush:
            self.flush()

Response: Retrieve value from store.


Instruction:
Write a Python 3 script to
initialize the bot plugins and everything.

Response:
def start(self):
        """Initializes the bot, plugins, and everything."""
        self.bot_start_time = datetime.now()
        self.webserver = Webserver(self.config['webserver']['host'], self.config['webserver']['port'])
        self.plugins.load()
        self.plugins.load_state()
        self._find_event_handlers()
        self.sc = ThreadedSlackClient(self.config['slack_token'])

        self.always_send_dm = ['_unauthorized_']
        if 'always_send_dm' in self.config:
            self.always_send_dm.extend(map(lambda x: '!' + x, self.config['always_send_dm']))

        # Rocket is very noisy at debug
        logging.getLogger('Rocket.Errors.ThreadPool').setLevel(logging.INFO)

        self.is_setup = True
        if self.test_mode:
            self.metrics['startup_time'] = (datetime.now() - self.bot_start_time).total_seconds() * 1000.0


Instruction:
Create a Python 3 function to
run the main loop of the slack RTM API.

Response:
def run(self, start=True):
        """
        Connects to slack and enters the main loop.

        * start - If True, rtm.start API is used. Else rtm.connect API is used

        For more info, refer to
        https://python-slackclient.readthedocs.io/en/latest/real_time_messaging.html#rtm-start-vs-rtm-connect
        """
        # Fail out if setup wasn't run
        if not self.is_setup:
            raise NotSetupError

        # Start the web server
        self.webserver.start()

        first_connect = True

        try:
            while self.runnable:
                if self.reconnect_needed:
                    if not self.sc.rtm_connect(with_team_state=start):
                        return False
                    self.reconnect_needed = False
                    if first_connect:
                        first_connect = False
                        self.plugins.connect()

                # Get all waiting events - this always returns a list
                try:
                    events = self.sc.rtm_read()
                except AttributeError:
                    self.log.exception('Something has failed in the slack rtm library.  This is fatal.')
                    self.runnable = False
                    events = []
                except:
                    self.log.exception('Unhandled exception in rtm_read()')
                    self.reconnect_needed = True
                    events = []
                for e in events:
                    try:
                        self._handle_event(e)
                    except KeyboardInterrupt:
                        # Gracefully shutdown
                        self.runnable = False
                    except:
                        self.log.exception('Unhandled exception in event handler')
                sleep(0.1)
        except KeyboardInterrupt:
            # On ctrl-c, just exit
            pass
        except:
            self.log.exception('Unhandled exception')


Instruction:
Can you tell what is the following Python 3 function doing
def stop(self):
        if self.webserver is not None:
            self.webserver.stop()
        if not self.test_mode:
            self.plugins.save_state()

Response: Does cleanup of bot and plugins.


Instruction:
Create a Python 3 function to
send a message to the specified channel.

Response:
def send_message(self, channel, text, thread=None, reply_broadcast=None):
        """
        Sends a message to the specified channel

        * channel - The channel to send to.  This can be a SlackChannel object, a channel id, or a channel name
        (without the #)
        * text - String to send
        * thread - reply to the thread. See https://api.slack.com/docs/message-threading#threads_party
        * reply_broadcast - Set to true to indicate your reply is germane to all members of a channel
        """
        # This doesn't want the # in the channel name
        if isinstance(channel, SlackRoomIMBase):
            channel = channel.id
        self.log.debug("Trying to send to %s: %s", channel, text)
        self.sc.rtm_send_message(channel, text, thread=thread, reply_broadcast=reply_broadcast)


Instruction:
Implement a Python 3 function for
sending a message to a user as an IM

Response:
def send_im(self, user, text):
        """
        Sends a message to a user as an IM

        * user - The user to send to.  This can be a SlackUser object, a user id, or the username (without the @)
        * text - String to send
        """
        if isinstance(user, SlackUser):
            user = user.id
            channelid = self._find_im_channel(user)
        else:
            channelid = user.id
        self.send_message(channelid, text)


Instruction:
Write a Python 3 script to
check if a token is correct.

Response:
def token_is_correct(self, token):
        """
        Подходит ли токен, для генерации текста.
        Допускаются русские слова, знаки препинания и символы начала и конца.
        """
        if self.is_rus_word(token):
            return True
        elif self.ONLY_MARKS.search(token):
            return True
        elif self.END_TOKENS.search(token):
            return True
        elif token in "$^":
            return True
        return False


Instruction:
Write a Python 3 script to
return a list of optimal variants.

Response:
def get_optimal_variant(self, variants, start_words, **kwargs):
        """
        Возвращает оптимальный вариант, из выборки.
        """

        if not start_words:
            return (choice(variants), {})

        _variants = []
        _weights = []
        for tok in frozenset(variants):
            if not self.token_is_correct(tok):
                continue
            weight = variants.count(tok)
            for word in start_words:
                for token in self.ONLY_WORDS.finditer(word.strip().lower()):
                    if token.group() == tok:
                        weight <<= 1
            _variants.append(tok)
            _weights.append(weight)

        if not _variants:
            return (choice(variants), {})

        return (choices(_variants, weights=_weights, k=1)[0], {})


Instruction:
How would you implement a function in Python 3 that
starts generation of the user s succesfully.

Response:
def start_generation(self, *start_words, **kwargs):
        """
        Генерирует предложение.
        :start_words: Попытаться начать предложение с этих слов.
        """
        out_text = ""
        _need_capialize = True
        for token in self._get_generate_tokens(*start_words, **kwargs):
            if token in "$^":
                _need_capialize = True
                continue
            if self.ONLY_WORDS.search(token):
                out_text += " "
            if _need_capialize:
                _need_capialize = False
                token = token.title()
            out_text += token

        return out_text.strip()


Instruction:
Here you have a function in Python 3, explain what it does
def get_start_array(self, *start_words, **kwargs):
        if not self.start_arrays:
            raise MarkovTextExcept("Не с чего начинать генерацию.")
        if not start_words:
            return choice(self.start_arrays)

        _variants = []
        _weights = []
        for tokens in self.start_arrays:
            weight = 0b1
            for word in start_words:
                word = word.strip().lower()
                for token in self.ONLY_WORDS.finditer(word):
                    if token.group() in tokens:
                        weight <<= 1
            if weight > 0b1:
                _variants.append(tokens)
                _weights.append(weight)

        if not _variants:
            return choice(self.start_arrays)

        return choices(_variants, weights=_weights, k=1)[0]

Response: returns a list of start_words


Instruction:
How would you explain what the following Python 3 function does
def create_base(self):
        self.base_dict = {}
        _start_arrays = []
        for tokens, word in self.chain_generator():
            self.base_dict.setdefault(tokens, []).append(word)
            if tokens[0] == "^":  # Первые ключи, для начала генерации.
                _start_arrays.append(tokens)

        self.start_arrays = tuple(
            frozenset(self.get_corrected_arrays(_start_arrays))
        )

Response:
Метод создаёт базовый словарь, на основе массива токенов.
        Вызывается из метода обновления.


Instruction:
Write a Python 3 function for
setting the vocabulary of the user.

Response:
def set_vocabulary(self, peer_id, from_dialogue=None, update=False):
        """
        Получает вокабулар из функции get_vocabulary и делает его активным.
        """

        self.tokens_array = self.get_vocabulary(
            peer_id,
            from_dialogue,
            update
        )
        self.create_base()


Instruction:
Write a Python 3 function that can
create a dump of the current state of the current object.

Response:
def create_dump(self, name=None):
        """
        Сохраняет текущую базу на жёсткий диск.
        :name: Имя файла, без расширения.
        """
        name = name or "vocabularDump"
        backup_dump_file = os_join(
            self.temp_folder,
            "{0}.backup".format(name)
        )
        dump_file = os_join(
            self.temp_folder,
            "{0}.json".format(name)
        )
        with open(backup_dump_file, "w", encoding="utf-8") as js_file:
            json.dump(self.tokens_array, js_file, ensure_ascii=False)
        copy2(backup_dump_file, dump_file)
        remove(backup_dump_file)


Instruction:
Here you have a function in Python 3, explain what it does
def load_dump(self, name=None):
        name = name or "vocabularDump"
        dump_file = os_join(
            self.temp_folder,
            "{0}.json".format(name)
        )
        if not isfile(dump_file):
            raise MarkovTextExcept("Файл {0!r} не найден.".format(dump_file))
        with open(dump_file, "rb") as js_file:
            self.tokens_array = tuple(json.load(js_file))
        self.create_base()

Response: Load a dump file and create a base object.


Instruction:
Here you have a function in Python 3, explain what it does
def get_vocabulary(self, target, user=None, update=False):
        if not self.vk_object:
            raise MarkovTextExcept("Объект бота не задан.")

        json_name = "{0}{1}_{2}".format(
            target.__class__.__name__,
            target.id,
            user.id
        )
        json_file = os_join(self.temp_folder, "{0}.json".format(json_name))

        if not update:
            result = self.vocabulars.get(json_name, None)
            if result:
                return result
            elif isfile(json_file):
                with open(json_file, "rb") as js_file:
                    result = self.vocabulars[json_name] = tuple(
                        json.load(js_file)
                    )
                return result

        _tokens_array = tuple(self.__parse_from_vk_dialogue(target, user))

        backup_file = "{0}.backup".format(splitext(json_file)[0])
        with open(backup_file, "w", encoding="utf-8") as js_file:
            json.dump(_tokens_array, js_file, ensure_ascii=False)

        copy2(backup_file, json_file)
        remove(backup_file)
        self.vocabulars[json_name] = _tokens_array
        return _tokens_array

Response: Returns a list of the vocabulary of the user.


Instruction:
Write a Python 3 function that can
update the internal list with the given data.

Response:
def update(self, data, fromfile=True):
        """
        Принимает текст, или путь к файлу и обновляет существующую базу.
        """
        func = (self._parse_from_file if fromfile else self._parse_from_text)
        new_data = tuple(func(data))
        if new_data:
            self.tokens_array += new_data
            self.create_base()


Instruction:
Explain what the following Python 3 code does
def _parse_from_text(self, text):
        if not isinstance(text, str):
            raise MarkovTextExcept("Передан не текст.")
        text = text.strip().lower()
        need_start_token = True
        token = "$"  # На случай, если переданная строка пуста.
        for token in self.WORD_OR_MARKS.finditer(text):
            token = token.group()
            if need_start_token:
                need_start_token = False
                yield "^"
            yield token
            if self.END_TOKENS.search(token):
                need_start_token = True
                yield "$"
        if token != "$":
            yield "$"

Response: Parse a text string into a list of strings.


Instruction:
Explain what the following Python 3 code does
def _parse_from_file(self, file_path):
        file_path = abspath(file_path)
        if not isfile(file_path):
            raise MarkovTextExcept("Передан не файл.")
        with open(file_path, "rb") as txt_file:
            for line in txt_file:
                text = line.decode("utf-8", "ignore").strip()
                if not text:
                    continue
                yield from self._parse_from_text(text)

Response: A generator that yields MarkovItem objects from a file.


Instruction:
How would you code a function in Python 3 to
take a SlackEvent parses it for a command and runs it against the registered plugin s command queue and returns the command and the command and the command itself.

Response:
def push(self, message):
        """
        Takes a SlackEvent, parses it for a command, and runs against registered plugin
        """
        if self._ignore_event(message):
            return None, None
        args = self._parse_message(message)
        self.log.debug("Searching for command using chunks: %s", args)
        cmd, msg_args = self._find_longest_prefix_command(args)
        if cmd is not None:
            if message.user is None:
                self.log.debug("Discarded message with no originating user: %s", message)
                return None, None
            sender = message.user.username
            if message.channel is not None:
                sender = "#%s/%s" % (message.channel.name, sender)
            self.log.info("Received from %s: %s, args %s", sender, cmd, msg_args)
            f = self._get_command(cmd, message.user)
            if f:
                if self._is_channel_ignored(f, message.channel):
                    self.log.info("Channel %s is ignored, discarding command %s", message.channel, cmd)
                    return '_ignored_', ""
                return cmd, f.execute(message, msg_args)
            return '_unauthorized_', "Sorry, you are not authorized to run %s" % cmd
        return None, None


Instruction:
Here you have a function in Python 3, explain what it does
def _ignore_event(self, message):
        if hasattr(message, 'subtype') and message.subtype in self.ignored_events:
            return True
        return False

Response: Check if the message is not truly an event and ignore it.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def register_plugin(self, plugin):
        self.log.info("Registering plugin %s", type(plugin).__name__)
        self._register_commands(plugin)
        plugin.on_load()

Response: Registers a plugin and commands with the dispatcher for push


Instruction:
Here you have a function in Python 3, explain what it does
def acl_show(self, msg, args):
        name = args[0] if len(args) > 0 else None
        if name is None:
            return "%s: The following ACLs are defined: %s" % (msg.user, ', '.join(self._acl.keys()))

        if name not in self._acl:
            return "Sorry, couldn't find an acl named '%s'" % name

        return '\n'.join([
            "%s: ACL '%s' is defined as follows:" % (msg.user, name),
            "allow: %s" % ', '.join(self._acl[name]['allow']),
            "deny: %s" % ', '.join(self._acl[name]['deny'])
        ])

Response: Show current allow and deny blocks for the given acl.


Instruction:
Write a Python 3 script for
adding a user to the given acl allow block.

Response:
def add_user_to_allow(self, name, user):
        """Add a user to the given acl allow block."""

        # Clear user from both allow and deny before adding
        if not self.remove_user_from_acl(name, user):
            return False

        if name not in self._acl:
            return False

        self._acl[name]['allow'].append(user)
        return True


Instruction:
How would you explain what the following Python 3 function does
def remove_user_from_acl(self, name, user):
        if name not in self._acl:
            return False
        if user in self._acl[name]['allow']:
            self._acl[name]['allow'].remove(user)
        if user in self._acl[name]['deny']:
            self._acl[name]['deny'].remove(user)
        return True

Response: Remove a user from the given acl.


Instruction:
Implement a function in Python 3 to
create a new acl.

Response:
def create_acl(self, name):
        """Create a new acl."""
        if name in self._acl:
            return False

        self._acl[name] = {
            'allow': [],
            'deny': []
        }
        return True


Instruction:
Can you tell what is the following Python 3 function doing
def mongo(daemon=False, port=20771):
    '''Run the mongod process.
    '''
    cmd = "mongod --port {0}".format(port)
    if daemon:
        cmd += " --fork"
    run(cmd)

Response: Run the mongod process.


Instruction:
Here you have a function in Python 3, explain what it does
def proxy_factory(BaseSchema, label, ProxiedClass, get_key):
    def local():
        key = get_key()
        try:
            return proxies[BaseSchema][label][key]
        except KeyError:
            proxies[BaseSchema][label][key] = ProxiedClass()
            return proxies[BaseSchema][label][key]
    return LocalProxy(local)

Response: Create a proxy to a class instance stored in proxies.


Instruction:
Can you tell what is the following Python 3 function doing
def with_proxies(proxy_map, get_key):
    def wrapper(cls):
        for label, ProxiedClass in six.iteritems(proxy_map):
            proxy = proxy_factory(cls, label, ProxiedClass, get_key)
            setattr(cls, label, proxy)
        return cls
    return wrapper

Response: Class decorator factory that adds proxies to target class.


Instruction:
Create a Python 3 function for
converting a value to a primary key.

Response:
def _to_primary_key(self, value):
        """
        Return primary key; if value is StoredObject, verify
        that it is loaded.

        """
        if value is None:
            return None
        if isinstance(value, self.base_class):
            if not value._is_loaded:
                raise exceptions.DatabaseError('Record must be loaded.')
            return value._primary_key

        return self.base_class._to_primary_key(value)


Instruction:
Write a Python 3 script for
assigning to a nested dictionary.

Response:
def set_nested(data, value, *keys):
    """Assign to a nested dictionary.

    :param dict data: Dictionary to mutate
    :param value: Value to set
    :param list *keys: List of nested keys

    >>> data = {}
    >>> set_nested(data, 'hi', 'k0', 'k1', 'k2')
    >>> data
    {'k0': {'k1': {'k2': 'hi'}}}

    """
    if len(keys) == 1:
        data[keys[0]] = value
    else:
        if keys[0] not in data:
            data[keys[0]] = {}
        set_nested(data[keys[0]], value, *keys[1:])


Instruction:
How would you implement a function in Python 3 that
retrieves user by username

Response:
def get_by_username(self, username):
        """Retrieve user by username"""
        res = filter(lambda x: x.username == username, self.users.values())
        if len(res) > 0:
            return res[0]
        return None


Instruction:
Explain what the following Python 3 code does
def set(self, user):

        self.log.info("Loading user information for %s/%s", user.id, user.username)
        self.load_user_info(user)
        self.log.info("Loading user rights for %s/%s", user.id, user.username)
        self.load_user_rights(user)
        self.log.info("Added user: %s/%s", user.id, user.username)
        self._add_user_to_cache(user)
        return user

Response: Adds a SlackUser object to the user manager


Instruction:
Write a Python 3 function for
setting permissions on user object

Response:
def load_user_rights(self, user):
        """Sets permissions on user object"""
        if user.username in self.admins:
            user.is_admin = True
        elif not hasattr(user, 'is_admin'):
            user.is_admin = False


Instruction:
Make a summary of the following Python 3 code
def send_message(self, channel, text):
        if isinstance(channel, SlackIM) or isinstance(channel, SlackUser):
            self._bot.send_im(channel, text)
        elif isinstance(channel, SlackRoom):
            self._bot.send_message(channel, text)
        elif isinstance(channel, basestring):
            if channel[0] == '@':
                self._bot.send_im(channel[1:], text)
            elif channel[0] == '#':
                self._bot.send_message(channel[1:], text)
            else:
                self._bot.send_message(channel, text)
        else:
            self._bot.send_message(channel, text)

Response: Send a message to the specified channel.


Instruction:
How would you code a function in Python 3 to
schedule a function to be called after some period of time.

Response:
def start_timer(self, duration, func, *args):
        """
        Schedules a function to be called after some period of time.

        * duration - time in seconds to wait before firing
        * func - function to be called
        * args - arguments to pass to the function
        """
        t = threading.Timer(duration, self._timer_callback, (func, args))
        self._timer_callbacks[func] = t
        t.start()
        self.log.info("Scheduled call to %s in %ds", func.__name__, duration)


Instruction:
Can you tell what is the following Python 3 function doing
def stop_timer(self, func):
        if func in self._timer_callbacks:
            t = self._timer_callbacks[func]
            t.cancel()
            del self._timer_callbacks[func]

Response: Stops a timer if it has not fired yet


Instruction:
Create a Python 3 function for
printing translate result in a better format

Response:
def print_res(data):
    """ Print translate result in a better format
    Args:
        data(str): result
    """
    print('===================================')
    main_part = data['data']
    print(main_part['word_name'])
    symbols = main_part['symbols'][0]
    print("美式音标：[" + symbols['ph_am'] + "]")
    print("英式音标：[" + symbols['ph_en'] + "]")
    print('-----------------------------------')
    parts = symbols['parts']
    for part in parts:
        print(part['part'])
        for mean in part['means']:
            print("    ", mean)
    print('===================================')


Instruction:
Can you generate a brief explanation for the following Python 3 code
def _get_underlying_data(self, instance):
        self._touch(instance)
        return self.data.get(instance, None)

Response:
Return data from raw data store rather than overridden
        __get__ methods. Should NOT be overwritten.


Instruction:
How would you implement a function in Python 3 that
casts value to its frozen counterpart.

Response:
def freeze(value):
    """ Cast value to its frozen counterpart. """
    if isinstance(value, list):
        return FrozenList(*value)
    if isinstance(value, dict):
        return FrozenDict(**value)
    return value


Instruction:
Explain what the following Python 3 code does
def help(self, msg, args):
        output = []
        if len(args) == 0:
            commands = sorted(self._bot.dispatcher.commands.items(), key=itemgetter(0))
            commands = filter(lambda x: x[1].is_subcmd is False, commands)
            # Filter commands if auth is enabled, hide_admin_commands is enabled, and user is not admin
            if self._should_filter_help_commands(msg.user):
                commands = filter(lambda x: x[1].admin_only is False, commands)
            for name, cmd in commands:
                output.append(self._get_short_help_for_command(name))
        else:
            name = '!' + args[0]
            output = [self._get_help_for_command(name)]
        return '\n'.join(output)

Response: Displays help for each command


Instruction:
Write a Python 3 script for
saving the current state of the plugin to the backend.

Response:
def save(self, msg, args):
        """Causes the bot to write its current state to backend."""
        self.send_message(msg.channel, "Saving current state...")
        self._bot.plugins.save_state()
        self.send_message(msg.channel, "Done.")


Instruction:
Can you generate a brief explanation for the following Python 3 code
def shutdown(self, msg, args):
        self.log.info("Received shutdown from %s", msg.user.username)
        self._bot.runnable = False
        return "Shutting down..."

Response: Called when a shutdown message is received.


Instruction:
Can you write a function in Python 3 where it
prints information about the user and bot version.

Response:
def whoami(self, msg, args):
        """Prints information about the user and bot version."""
        output = ["Hello %s" % msg.user]
        if hasattr(self._bot.dispatcher, 'auth_manager') and msg.user.is_admin is True:
            output.append("You are a *bot admin*.")
        output.append("Bot version: %s-%s" % (self._bot.version, self._bot.commit))
        return '\n'.join(output)


Instruction:
Create a Python 3 function to
attempt to ignore all messages from the specified channel.

Response:
def sleep(self, channel):
        """Causes the bot to ignore all messages from the channel.

        Usage:
        !sleep [channel name] - ignore the specified channel (or current if none specified)
        """
        self.log.info('Sleeping in %s', channel)
        self._bot.dispatcher.ignore(channel)
        self.send_message(channel, 'Good night')


Instruction:
How would you explain what the following Python 3 function does
def wake(self, channel):
        self.log.info('Waking up in %s', channel)
        self._bot.dispatcher.unignore(channel)
        self.send_message(channel, 'Hello, how may I be of service?')

Response: Wake up the channel.


Instruction:
Make a summary of the following Python 3 code
def _arg_name(self, name, types, prefix="--"):
        if 'type:a10_nullable' in types:
            return self._arg_name(name, types['type:a10_nullable'], prefix)

        if 'type:a10_list' in types:
            return self._arg_name(name, types['type:a10_list'], prefix)

        if 'type:a10_reference' in types:
            if name.endswith('_id'):
                name = name[:-3]

        """--shish-kabob it"""
        return prefix + name.replace('_', '-')

Response: Return the argument name for the user.


Instruction:
Given the following Python 3 function, write the documentation
def _sort_by(key):

    @staticmethod
    def sort_by(p_list, reverse=False):
        return sorted(
            p_list,
            key=lambda p: getattr(p, key),
            reverse=reverse,
        )

    return sort_by

Response: High order function for sort methods.


Instruction:
Write a Python 3 script for
selecting path by criterion.

Response:
def select(self, filters=all_true, recursive=True):
        """Select path by criterion.

        :param filters: a lambda function that take a `pathlib.Path` as input,
          boolean as a output.
        :param recursive: include files in subfolder or not.

        **中文文档**

        根据filters中定义的条件选择路径。
        """
        self.assert_is_dir_and_exists()

        if recursive:
            for p in self.glob("**/*"):
                if filters(p):
                    yield p
        else:
            for p in self.iterdir():
                if filters(p):
                    yield p


Instruction:
How would you implement a function in Python 3 that
selects file path by criterion.

Response:
def select_file(self, filters=all_true, recursive=True):
        """Select file path by criterion.

        **中文文档**

        根据filters中定义的条件选择文件。
        """
        for p in self.select(filters, recursive):
            if p.is_file():
                yield p


Instruction:
Explain what the following Python 3 code does
def select_dir(self, filters=all_true, recursive=True):
        for p in self.select(filters, recursive):
            if p.is_dir():
                yield p

Response: Select all directories in the database.


Instruction:
Can you write a function in Python 3 where it
counts how many files in this directory. Including file in sub folder.

Response:
def n_file(self):
        """
        Count how many files in this directory. Including file in sub folder.
        """
        self.assert_is_dir_and_exists()
        n = 0
        for _ in self.select_file(recursive=True):
            n += 1
        return n


Instruction:
How would you implement a function in Python 3 that
counts how many folders in this directory. Including folder in sub folder.

Response:
def n_dir(self):
        """
        Count how many folders in this directory. Including folder in sub folder.
        """
        self.assert_is_dir_and_exists()
        n = 0
        for _ in self.select_dir(recursive=True):
            n += 1
        return n


Instruction:
Create a Python 3 function for
counting how many subfiles in this directory.

Response:
def n_subfile(self):
        """
        Count how many files in this directory (doesn't include files in
        sub folders).
        """
        self.assert_is_dir_and_exists()
        n = 0
        for _ in self.select_file(recursive=False):
            n += 1
        return n


Instruction:
Here you have a function in Python 3, explain what it does
def n_subdir(self):
        self.assert_is_dir_and_exists()
        n = 0
        for _ in self.select_dir(recursive=False):
            n += 1
        return n

Response: Count how many subfolders in this directory.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def select_by_ext(self, ext, recursive=True):
        ext = [ext.strip().lower() for ext in ensure_list(ext)]

        def filters(p): return p.suffix.lower() in ext

        return self.select_file(filters, recursive)

Response: Select file path by extension.


Instruction:
Make a summary of the following Python 3 code
def select_by_pattern_in_fname(self,
                                   pattern,
                                   recursive=True,
                                   case_sensitive=False):
        """
        Select file path by text pattern in file name.

        **中文文档**

        选择文件名中包含指定子字符串的文件。
        """
        if case_sensitive:
            def filters(p):
                return pattern in p.fname
        else:
            pattern = pattern.lower()

            def filters(p):
                return pattern in p.fname.lower()

        return self.select_file(filters, recursive)

Response: Select file path by text pattern in file name.


Instruction:
Create a Python 3 function for
selecting file path by text pattern in absolute path.

Response:
def select_by_pattern_in_abspath(self,
                                     pattern,
                                     recursive=True,
                                     case_sensitive=False):
        """
        Select file path by text pattern in absolute path.

        **中文文档**

        选择绝对路径中包含指定子字符串的文件。
        """
        if case_sensitive:
            def filters(p):
                return pattern in p.abspath
        else:
            pattern = pattern.lower()

            def filters(p):
                return pattern in p.abspath.lower()

        return self.select_file(filters, recursive)


Instruction:
Can you generate a brief explanation for the following Python 3 code
def select_by_size(self, min_size=0, max_size=1 << 40, recursive=True):

        def filters(p): return min_size <= p.size <= max_size

        return self.select_file(filters, recursive)

Response: Select file path by size.


Instruction:
Implement a Python 3 function for
selecting file path by modify time.

Response:
def select_by_mtime(self, min_time=0, max_time=ts_2100,
                        recursive=True):
        """
        Select file path by modify time.

        :param min_time: lower bound timestamp
        :param max_time: upper bound timestamp

        **中文文档**

        选择所有 :attr:`pathlib_mate.pathlib2.Path.mtime` 在一定范围内的文件。
        """

        def filters(p): return min_time <= p.mtime <= max_time

        return self.select_file(filters, recursive)


Instruction:
Write a Python 3 script for
selecting file path by access time.

Response:
def select_by_atime(self, min_time=0, max_time=ts_2100, recursive=True):
        """
        Select file path by access time.

        :param min_time: lower bound timestamp
        :param max_time: upper bound timestamp

        **中文文档**

        选择所有 :attr:`pathlib_mate.pathlib2.Path.atime` 在一定范围内的文件。
        """

        def filters(p): return min_time <= p.atime <= max_time

        return self.select_file(filters, recursive)


Instruction:
Implement a function in Python 3 to
select file path by create time.

Response:
def select_by_ctime(self, min_time=0, max_time=ts_2100,
                        recursive=True):
        """
        Select file path by create time.

        :param min_time: lower bound timestamp
        :param max_time: upper bound timestamp

        **中文文档**

        选择所有 :attr:`pathlib_mate.pathlib2.Path.ctime` 在一定范围内的文件。
        """

        def filters(p): return min_time <= p.ctime <= max_time

        return self.select_file(filters, recursive)


Instruction:
Given the following Python 3 function, write the documentation
def dirsize(self):
        total = 0
        for p in self.select_file(recursive=True):
            try:
                total += p.size
            except:  # pragma: no cover
                print("Unable to get file size of: %s" % p)
        return total

Response: Return total file size of the file.


Instruction:
Can you tell what is the following Python 3 function doing
def make_zip_archive(self,
                         dst=None,
                         filters=all_true,
                         compress=True,
                         overwrite=False,
                         makedirs=False,
                         verbose=False):  # pragma: no cover
        """
        Make a zip archive.

        :param dst: output file path. if not given, will be automatically assigned.
        :param filters: custom path filter. By default it allows any file.
        :param compress: compress or not.
        :param overwrite: overwrite exists or not.
        :param verbose: display log or not.
        :return:
        """
        self.assert_exists()

        if dst is None:
            dst = self._auto_zip_archive_dst()
        else:
            dst = self.change(new_abspath=dst)

        if not dst.basename.lower().endswith(".zip"):
            raise ValueError("zip archive name has to be endswith '.zip'!")

        if dst.exists():
            if not overwrite:
                raise IOError("'%s' already exists!" % dst)

        if compress:
            compression = ZIP_DEFLATED
        else:
            compression = ZIP_STORED

        if not dst.parent.exists():
            if makedirs:
                os.makedirs(dst.parent.abspath)

        if verbose:
            msg = "Making zip archive for '%s' ..." % self
            print(msg)

        current_dir = os.getcwd()

        if self.is_dir():
            total_size = 0
            selected = list()
            for p in self.glob("**/*"):
                if filters(p):
                    selected.append(p)
                    total_size += p.size

            if verbose:
                msg = "Got {} files, total size is {}, compressing ...".format(
                    len(selected), repr_data_size(total_size),
                )
                print(msg)

            with ZipFile(dst.abspath, "w", compression) as f:
                os.chdir(self.abspath)
                for p in selected:
                    relpath = p.relative_to(self).__str__()
                    f.write(relpath)

        elif self.is_file():
            with ZipFile(dst.abspath, "w", compression) as f:
                os.chdir(self.parent.abspath)
                f.write(self.basename)

        os.chdir(current_dir)

        if verbose:
            msg = "Complete! Archive size is {}.".format(dst.size_in_text)
            print(msg)

Response: Makes a zip archive of the current directory.


Instruction:
Given the following Python 3 function, write the documentation
def backup(self,
               dst=None,
               ignore=None,
               ignore_ext=None,
               ignore_pattern=None,
               ignore_size_smaller_than=None,
               ignore_size_larger_than=None,
               case_sensitive=False):  # pragma: no cover
        """
        Create a compressed zip archive backup for a directory.

        :param dst: the output file path.
        :param ignore: file or directory defined in this list will be ignored.
        :param ignore_ext: file with extensions defined in this list will be ignored.
        :param ignore_pattern: any file or directory that contains this pattern
            will be ignored.
        :param ignore_size_smaller_than: any file size smaller than this
            will be ignored.
        :param ignore_size_larger_than: any file size larger than this
            will be ignored.

        **中文文档**

        为一个目录创建一个备份压缩包。可以通过过滤器选择你要备份的文件。
        """

        def preprocess_arg(arg):  # pragma: no cover
            if arg is None:
                return []

            if isinstance(arg, (tuple, list)):
                return list(arg)
            else:
                return [arg, ]

        self.assert_is_dir_and_exists()

        ignore = preprocess_arg(ignore)
        for i in ignore:
            if i.startswith("/") or i.startswith("\\"):
                raise ValueError

        ignore_ext = preprocess_arg(ignore_ext)
        for ext in ignore_ext:
            if not ext.startswith("."):
                raise ValueError

        ignore_pattern = preprocess_arg(ignore_pattern)

        if case_sensitive:
            pass
        else:
            ignore = [i.lower() for i in ignore]
            ignore_ext = [i.lower() for i in ignore_ext]
            ignore_pattern = [i.lower() for i in ignore_pattern]

        def filters(p):
            relpath = p.relative_to(self).abspath
            if not case_sensitive:
                relpath = relpath.lower()

            # ignore
            for i in ignore:
                if relpath.startswith(i):
                    return False

            # ignore_ext
            if case_sensitive:
                ext = p.ext
            else:
                ext = p.ext.lower()

            if ext in ignore_ext:
                return False

            # ignore_pattern
            for pattern in ignore_pattern:
                if pattern in relpath:
                    return False

            # ignore_size_smaller_than
            if ignore_size_smaller_than:
                if p.size < ignore_size_smaller_than:
                    return False

            # ignore_size_larger_than
            if ignore_size_larger_than:
                if p.size > ignore_size_larger_than:
                    return False

            return True

        self.make_zip_archive(
            dst=dst, filters=filters, compress=True, overwrite=False, verbose=True,
        )

Response: Create a compressed zip archive for a directory.


Instruction:
How would you explain what the following Python 3 function does
def acquire_lock(func):
    @wraps(func)
    def wrapper(self, *args, **kwargs):
        with self.locker as r:
            # get the result
            acquired, code, _  = r
            if acquired:
                try:
                    r = func(self, *args, **kwargs)
                except Exception as err:
                    e = str(err)
                else:
                    e = None
            else:
                warnings.warn("code %s. Unable to aquire the lock when calling '%s'. You may try again!"%(code,func.__name__) )
                e = None
                r = None
        # raise error after exiting with statement and releasing the lock!
        if e is not None:
            traceback.print_stack()
            raise Exception(e)
        return r
    return wrapper

Response: Decorate methods when locking repository is required.


Instruction:
Given the following Python 3 function, write the documentation
def sync_required(func):
    @wraps(func)
    def wrapper(self, *args, **kwargs):
        if not self._keepSynchronized:
            r = func(self, *args, **kwargs)
        else:
            state = self._load_state()
            #print("----------->  ",state, self.state)
            if state is None:
                r = func(self, *args, **kwargs)
            elif state == self.state:
                r = func(self, *args, **kwargs)
            else:
                warnings.warn("Repository at '%s' is out of date. Need to load it again to avoid conflict."%self.path)
                r = None
        return r
    return wrapper

Response: Decorate methods when synchronizing repository is required.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def get_list_representation(self):
        if self.__path is None:
            return []
        repr = [ self.__path+":["+','.join(list(dict.__getitem__(self, 'files')))+']' ]
        # walk directories
        for directory in sorted(list(self.walk_directories_relative_path())):
            directoryRepr = os.path.normpath(directory)
            # get directory info
            dirInfoDict, errorMessage = self.get_directory_info(directory)
            assert dirInfoDict is not None, errorMessage
            directoryRepr += ":["+','.join( list(dict.__getitem__(dirInfoDict, 'files')))+']'
            repr.append(directoryRepr)
        return repr

Response: Gets a list representation of the Repository content in a list of directories ( files ) format.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def walk_files_relative_path(self, relativePath=""):
        def walk_files(directory, relativePath):
            directories = dict.__getitem__(directory, 'directories')
            files       = dict.__getitem__(directory, 'files')
            for f in sorted(files):
                yield os.path.join(relativePath, f)
            for k in sorted(dict.keys(directories)):
                path = os.path.join(relativePath, k)
                dir  = directories.__getitem__(k)
                for e in walk_files(dir, path):
                    yield e
        dir, errorMessage = self.get_directory_info(relativePath)
        assert dir is not None, errorMessage
        return walk_files(dir, relativePath='')

Response: Walk the repository and yield all found files relative path joined with file name.


Instruction:
Here you have a function in Python 3, explain what it does
def walk_files_info(self, relativePath=""):
        def walk_files(directory, relativePath):
            directories = dict.__getitem__(directory, 'directories')
            files       = dict.__getitem__(directory, 'files')
            for fname in sorted(files):
                info = dict.__getitem__(files,fname)
                yield os.path.join(relativePath, fname), info
            for k in sorted(dict.keys(directories)):
                path = os.path.join(relativePath, k)
                dir  = dict.__getitem__(directories, k)
                for e in walk_files(dir, path):
                    yield e
        dir, errorMessage = self.get_directory_info(relativePath)
        assert dir is not None, errorMessage
        return walk_files(dir, relativePath='')

Response:
Walk the repository and yield tuples as the following:\n
        relative path to relativePath joined with file name file info dict.


Instruction:
Can you tell what is the following Python 3 function doing
def walk_directories_relative_path(self, relativePath=""):
        def walk_directories(directory, relativePath):
            directories = dict.__getitem__(directory, 'directories')
            dirNames = dict.keys(directories)
            for d in sorted(dirNames):
                yield os.path.join(relativePath, d)
            for k in sorted(dict.keys(directories)):
                path = os.path.join(relativePath, k)
                dir  = dict.__getitem__(directories, k)
                for e in walk_directories(dir, path):
                    yield e
        dir, errorMessage = self.get_directory_info(relativePath)
        assert dir is not None, errorMessage
        return walk_directories(dir, relativePath='')

Response:
Walks the repository and yield all found directories relative path
COOKIE


Instruction:
Make a summary of the following Python 3 code
def walk_directories_info(self, relativePath=""):
        def walk_directories(directory, relativePath):
            directories = dict.__getitem__(directory, 'directories')
            for fname in sorted(directories):
                info = dict.__getitem__(directories,fname)
                yield os.path.join(relativePath, fname), info
            for k in sorted(dict.keys(directories)):
                path = os.path.join(relativePath, k)
                dir  = dict.__getitem__(directories, k)
                for e in walk_directories(dir, path):
                    yield e
        dir, errorMessage = self.get_directory_info(relativePath)
        assert dir is not None, errorMessage
        return walk_directories(dir, relativePath='')

Response: Walk repository and yield all found directories relative path.


Instruction:
Can you generate the documentation for the following Python 3 function
def walk_directory_directories_relative_path(self, relativePath=""):
        # get directory info dict
        errorMessage = ""
        relativePath = os.path.normpath(relativePath)
        dirInfoDict, errorMessage = self.get_directory_info(relativePath)
        assert dirInfoDict is not None, errorMessage
        for dname in dict.__getitem__(dirInfoDict, "directories"):
            yield os.path.join(relativePath, dname)

Response: Walk a certain directory in repository and yield all found directories relative path.


Instruction:
How would you implement a function in Python 3 that
walks a certain directory and yield tuples as the following:\ n relative path joined with directory name file info dict.

Response:
def walk_directory_directories_info(self, relativePath=""):
        """
        Walk a certain directory in repository and yield tuples as the following:\n
        (relative path joined with directory name, file info dict).

        :parameters:
            #. relativePath (str): The relative path of the directory.
        """
        # get directory info dict
        relativePath = os.path.normpath(relativePath)
        dirInfoDict, errorMessage = self.get_directory_info(relativePath)
        assert dirInfoDict is not None, errorMessage
        for fname in dict.__getitem__(dirInfoDict, "directories"):
            yield os.path.join(relativePath, fname), dict.__getitem__(dirInfoDict, "directories")[fname]


Instruction:
Here you have a function in Python 3, explain what it does
def synchronize(self, verbose=False):
        if self.__path is None:
            return
        # walk directories
        for dirPath in sorted(list(self.walk_directories_relative_path())):
            realPath = os.path.join(self.__path, dirPath)
            # if directory exist
            if os.path.isdir(realPath):
                continue
            if verbose: warnings.warn("%s directory is missing"%realPath)
            # loop to get dirInfoDict
            keys = dirPath.split(os.sep)
            dirInfoDict = self
            for idx in range(len(keys)-1):
                dirs = dict.get(dirInfoDict, 'directories', None)
                if dirs is None: break
                dirInfoDict = dict.get(dirs, keys[idx], None)
                if dirInfoDict is None: break
            # remove dirInfoDict directory if existing
            if dirInfoDict is not None:
                dirs = dict.get(dirInfoDict, 'directories', None)
                if dirs is not None:
                    dict.pop( dirs, keys[-1], None )
        # walk files
        for filePath in sorted(list(self.walk_files_relative_path())):
            realPath = os.path.join(self.__path, filePath)
            # if file exists
            if os.path.isfile( realPath ):
                continue
            if verbose: warnings.warn("%s file is missing"%realPath)
            # loop to get dirInfoDict
            keys = filePath.split(os.sep)
            dirInfoDict = self
            for idx in range(len(keys)-1):
                dirs = dict.get(dirInfoDict, 'directories', None)
                if dirs is None: break
                dirInfoDict = dict.get(dirs, keys[idx], None)
                if dirInfoDict is None: break
            # remove dirInfoDict file if existing
            if dirInfoDict is not None:
                files = dict.get(dirInfoDict, 'files', None)
                if files is not None:
                    dict.pop( files, keys[-1], None )

Response: Synchronizes the Repository information with the directory.


Instruction:
How would you implement a function in Python 3 that
loads the current instance of the current repository from a directory path and updates the current instance with the loaded data.

Response:
def load_repository(self, path):
        """
        Load repository from a directory path and update the current instance.

        :Parameters:
            #. path (string): The path of the directory from where to load the repository.
               If '.' or an empty string is passed, the current working directory will be used.

        :Returns:
             #. repository (pyrep.Repository): returns self repository with loaded data.
        """
        # try to open
        if path.strip() in ('','.'):
            path = os.getcwd()
        repoPath = os.path.realpath( os.path.expanduser(path) )
        if not self.is_repository(repoPath):
            raise Exception("no repository found in '%s'"%str(repoPath))
        # get pyrepinfo path
        repoInfoPath = os.path.join(repoPath, ".pyrepinfo")
        try:
            fd = open(repoInfoPath, 'rb')
        except Exception as e:
            raise Exception("unable to open repository file(%s)"%e)
        # before doing anything try to lock repository
        # can't decorate with @acquire_lock because this will point to old repository
        # path or to current working directory which might not be the path anyways
        L =  Locker(filePath=None, lockPass=str(uuid.uuid1()), lockPath=os.path.join(repoPath, ".pyreplock"))
        acquired, code = L.acquire_lock()
        # check if acquired.
        if not acquired:
            warnings.warn("code %s. Unable to aquire the lock when calling 'load_repository'. You may try again!"%(code,) )
            return
        try:
            # unpickle file
            try:
                repo = pickle.load( fd )
            except Exception as e:
                fd.close()
                raise Exception("unable to pickle load repository (%s)"%e)
            finally:
                fd.close()
            # check if it's a PyrepInfo instance
            if not isinstance(repo, Repository):
                raise Exception(".pyrepinfo in '%s' is not a repository instance."%s)
            else:
                # update info path
                self.__reset_repository()
                self.__update_repository(repo)
                self.__path = repoPath
            # set timestamp
            self.__state = self._get_or_create_state()
        except Exception as e:
            L.release_lock()
            raise Exception(e)
        finally:
            L.release_lock()
        # set loaded repo locker path to L because repository have been moved to another directory
        self.__locker = L
        # return
        return self


Instruction:
Can you implement a function in Python 3 that
creates a repository in a directory. This method insures the creation of the directory in the system if it is missing.\n **N.B. This method erases existing pyrep repository in the path but not the repository files.** :Parameters: #. path (string): The real absolute path where to create the Repository. If '.' or an empty string is passed, the current working directory will be used. #. info (None, object): Any information that can identify the repository. #. verbose (boolean): Whether to be warn and informed about any abnormalities.

Response:
def create_repository(self, path, info=None, verbose=True):
        """
        create a repository in a directory.
        This method insures the creation of the directory in the system if it is missing.\n

        **N.B. This method erases existing pyrep repository in the path but not the repository files.**

        :Parameters:
            #. path (string): The real absolute path where to create the Repository.
               If '.' or an empty string is passed, the current working directory will be used.
            #. info (None, object): Any information that can identify the repository.
            #. verbose (boolean): Whether to be warn and informed about any abnormalities.
        """
        try:
            info = copy.deepcopy( info )
        except:
            raise Exception("Repository info must be a copyable python object.")
        # get real path
        if path.strip() in ('','.'):
            path = os.getcwd()
        realPath = os.path.realpath( os.path.expanduser(path) )
        # create directory if not existing
        if not os.path.isdir(realPath):
            os.makedirs(realPath)
        self.__path = realPath
        self.__info = info
        # reset if replace is set to True
        if self.is_repository(realPath):
            if verbose:
                warnings.warn("A pyrep Repository already exists in the given path '%s' and therefore it has been erased and replaced by a fresh repository."%path)
        # reset repository
        self.__reset_repository()
        # update locker because normally this is done in __update_repository method
        lp = '.pyreplock'
        if self.__path is not None:
            lp = os.path.join(self.__path,lp)
        self.__locker.set_lock_path(lp)
        self.__locker.set_lock_pass(str(uuid.uuid1()))
        # save repository
        self.save()


Instruction:
Write a Python 3 function for
creating a repository at given real path or load any existing one.

Response:
def get_repository(self, path, info=None, verbose=True):
        """
        Create a repository at given real path or load any existing one.
        This method insures the creation of the directory in the system if it is missing.\n
        Unlike create_repository, this method doesn't erase any existing repository
        in the path but loads it instead.

        **N.B. On some systems and some paths, creating a directory may requires root permissions.**

        :Parameters:
            #. path (string): The real absolute path where to create the Repository.
               If '.' or an empty string is passed, the current working directory will be used.
            #. info (None, object): Any information that can identify the repository.
            #. verbose (boolean): Whether to be warn and informed about any abnormalities.
        """
        # get real path
        if path.strip() in ('','.'):
            path = os.getcwd()
        realPath = os.path.realpath( os.path.expanduser(path) )
        # create directory if not existing
        if not os.path.isdir(realPath):
            os.makedirs(realPath)
        # create Repository
        if not self.is_repository(realPath):
            self.create_repository(realPath, info=info, verbose=verbose)
        else:
            self.load_repository(realPath)


Instruction:
Explain what the following Python 3 code does
def remove_repository(self, path=None, relatedFiles=False, relatedFolders=False, verbose=True):
        if path is not None:
            realPath = os.path.realpath( os.path.expanduser(path) )
        else:
            realPath = self.__path
        if realPath is None:
            if verbose: warnings.warn('path is None and current Repository is not initialized!')
            return
        if not self.is_repository(realPath):
            if verbose: warnings.warn("No repository found in '%s'!"%realPath)
            return
        # check for security
        if realPath == os.path.realpath('/..') :
            if verbose: warnings.warn('You are about to wipe out your system !!! action aboarded')
            return
        # get repo
        if path is not None:
            repo = Repository()
            repo.load_repository(realPath)
        else:
            repo = self
        # delete files
        if relatedFiles:
            for relativePath in repo.walk_files_relative_path():
                realPath = os.path.join(repo.path, relativePath)
                if not os.path.isfile(realPath):
                    continue
                if not os.path.exists(realPath):
                    continue
                os.remove( realPath )
        # delete directories
        if relatedFolders:
            for relativePath in reversed(list(repo.walk_directories_relative_path())):
                realPath = os.path.join(repo.path, relativePath)
                # protect from wiping out the system
                if not os.path.isdir(realPath):
                    continue
                if not os.path.exists(realPath):
                    continue
                if not len(os.listdir(realPath)):
                    os.rmdir( realPath )
        # delete repository
        os.remove( os.path.join(repo.path, ".pyrepinfo" ) )
        for fname in (".pyrepstate", ".pyreplock"):
            p = os.path.join(repo.path, fname )
            if os.path.exists( p ):
                os.remove( p )
        # remove main directory if empty
        if os.path.isdir(repo.path):
            if not len(os.listdir(repo.path)):
                os.rmdir( repo.path )
        # reset repository
        repo.__reset_repository()

Response: Removes a repository from the system.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def save(self):
        # open file
        repoInfoPath = os.path.join(self.__path, ".pyrepinfo")
        try:
            fdinfo = open(repoInfoPath, 'wb')
        except Exception as e:
            raise Exception("unable to open repository info for saving (%s)"%e)
        # save repository
        try:
            pickle.dump( self, fdinfo, protocol=2 )
        except Exception as e:
            fdinfo.flush()
            os.fsync(fdinfo.fileno())
            fdinfo.close()
            raise Exception( "Unable to save repository info (%s)"%e )
        finally:
            fdinfo.flush()
            os.fsync(fdinfo.fileno())
            fdinfo.close()
        # save timestamp
        repoTimePath = os.path.join(self.__path, ".pyrepstate")
        try:
            self.__state = ("%.6f"%time.time()).encode()
            with open(repoTimePath, 'wb') as fdtime:
                fdtime.write( self.__state )
                fdtime.flush()
                os.fsync(fdtime.fileno())
        except Exception as e:
            raise Exception("unable to open repository time stamp for saving (%s)"%e)

Response: Save the current state of the object to disk.


Instruction:
How would you implement a function in Python 3 that
creates a tar file package of all the files and directories in the repository.

Response:
def create_package(self, path=None, name=None, mode=None):
        """
        Create a tar file package of all the repository files and directories.
        Only files and directories that are stored in the repository info
        are stored in the package tar file.

        **N.B. On some systems packaging requires root permissions.**

        :Parameters:
            #. path (None, string): The real absolute path where to create the package.
               If None, it will be created in the same directory as the repository
               If '.' or an empty string is passed, the current working directory will be used.
            #. name (None, string): The name to give to the package file
               If None, the package directory name will be used with the appropriate extension added.
            #. mode (None, string): The writing mode of the tarfile.
               If None, automatically the best compression mode will be chose.
               Available modes are ('w', 'w:', 'w:gz', 'w:bz2')
        """
        # check mode
        assert mode in (None, 'w', 'w:', 'w:gz', 'w:bz2'), 'unkown archive mode %s'%str(mode)
        if mode is None:
            mode = 'w:bz2'
            mode = 'w:'
        # get root
        if path is None:
            root = os.path.split(self.__path)[0]
        elif path.strip() in ('','.'):
            root = os.getcwd()
        else:
            root = os.path.realpath( os.path.expanduser(path) )
        assert os.path.isdir(root), 'absolute path %s is not a valid directory'%path
        # get name
        if name is None:
            ext = mode.split(":")
            if len(ext) == 2:
                if len(ext[1]):
                    ext = "."+ext[1]
                else:
                    ext = '.tar'
            else:
                ext = '.tar'
            name = os.path.split(self.__path)[1]+ext
        # save repository
        self.save()
        # create tar file
        tarfilePath = os.path.join(root, name)
        try:
            tarHandler = tarfile.TarFile.open(tarfilePath, mode=mode)
        except Exception as e:
            raise Exception("Unable to create package (%s)"%e)
        # walk directory and create empty directories
        for directory in sorted(list(self.walk_directories_relative_path())):
            t = tarfile.TarInfo( directory )
            t.type = tarfile.DIRTYPE
            tarHandler.addfile(t)
        # walk files and add to tar
        for file in self.walk_files_relative_path():
            tarHandler.add(os.path.join(self.__path,file), arcname=file)
        # save repository .pyrepinfo
        tarHandler.add(os.path.join(self.__path,".pyrepinfo"), arcname=".pyrepinfo")
        # close tar file
        tarHandler.close()


Instruction:
Implement a Python 3 function for
checking if there is a repository in path.

Response:
def is_repository(self, path):
        """
        Check if there is a Repository in path.

        :Parameters:
            #. path (string): The real path of the directory where to check if there is a repository.

        :Returns:
            #. result (boolean): Whether its a repository or not.
        """
        realPath = os.path.realpath( os.path.expanduser(path) )
        if not os.path.isdir(realPath):
            return False
        if ".pyrepinfo" not in os.listdir(realPath):
            return False
        return True


Instruction:
Explain what the following Python 3 code does
def get_directory_info(self, relativePath):
        relativePath = os.path.normpath(relativePath)
        # if root directory
        if relativePath in ('','.'):
            return self, ""
        currentDir  = self.__path
        dirInfoDict = self
        for dir in relativePath.split(os.sep):
            dirInfoDict = dict.__getitem__(dirInfoDict, "directories")
            currentDir = os.path.join(currentDir, dir)
            # check if path exists
            if not os.path.exists(currentDir):
                return None,  "directory '%s' is not found"%currentDir
            val = dirInfoDict.get(dir, None)
            # check if directory is registered in repository
            if val is None:
                return None,  "directory '%s' is not registered in PyrepInfo"%currentDir
            dirInfoDict = val
        return dirInfoDict, ""

Response: Returns the directory information dictionary and the error message if any error has occurred.


Instruction:
How would you explain what the following Python 3 function does
def get_parent_directory_info(self, relativePath):
        relativePath = os.path.normpath(relativePath)
        # if root directory
        if relativePath in ('','.'):
            return self, "relativePath is empty pointing to the repostitory itself."
        # split path
        parentDirPath, _ = os.path.split(relativePath)
        # get parent directory info
        return self.get_directory_info(parentDirPath)

Response: Get the parent directory info of a file or directory from the Repository.


Instruction:
Implement a function in Python 3 to
get file information dict from the repository given its relative path and name.

Response:
def get_file_info(self, relativePath, name=None):
        """
        get file information dict from the repository given its relative path and name.

        :Parameters:
            #. relativePath (string): The relative to the repository path of the directory where the file is.
            #. name (string): The file name.
               If None is given, name will be split from relativePath.

        :Returns:
            #. info (None, dictionary): The file information dictionary.
               If None, it means an error has occurred.
            #. errorMessage (string): The error message if any error occurred.
        """
        # normalize relative path and name
        relativePath = os.path.normpath(relativePath)
        if relativePath == '.':
            relativePath = ''
            assert name != '.pyrepinfo', "'.pyrepinfo' can't be a file name."
        if name is None:
            assert len(relativePath), "name must be given when relative path is given as empty string or as a simple dot '.'"
            relativePath,name = os.path.split(relativePath)
        # initialize message
        errorMessage = ""
        # get directory info
        dirInfoDict, errorMessage = self.get_directory_info(relativePath)
        if dirInfoDict is None:
            return None, errorMessage
        # get file info
        fileInfo = dict.__getitem__(dirInfoDict, "files").get(name, None)
        if fileInfo is None:
            errorMessage = "file %s does not exist in relative path '%s'"%(name, relativePath)
        return fileInfo, errorMessage


Instruction:
Here you have a function in Python 3, explain what it does
def get_file_info_by_id(self, id):
        for path, info in self.walk_files_info():
            if info['id']==id:
                return path, info
        # none was found
        return None, None

Response: Given an id get the corresponding file info dictionary.


Instruction:
How would you explain what the following Python 3 function does
def get_file_relative_path_by_id(self, id):
        for path, info in self.walk_files_info():
            if info['id']==id:
                return path
        # none was found
        return None

Response: Given an id get the corresponding file info relative path joined with file name.


Instruction:
Make a summary of the following Python 3 code
def get_file_relative_path_by_name(self, name, skip=0):
        if skip is None:
            paths = []
        else:
            paths = None
        for path, info in self.walk_files_info():
            _, n = os.path.split(path)
            if n==name:
                if skip is None:
                    paths.append(path)
                elif skip>0:
                    skip -= 1
                else:
                    paths = path
                    break
        return paths

Response: Get file relative path given the file name.


Instruction:
Can you tell what is the following Python 3 function doing
def add_directory(self, relativePath, info=None):
        path = os.path.normpath(relativePath)
        # create directories
        currentDir  = self.path
        currentDict = self
        if path in ("","."):
            return currentDict
        save = False
        for dir in path.split(os.sep):
            dirPath = os.path.join(currentDir, dir)
            # create directory
            if not os.path.exists(dirPath):
                 os.mkdir(dirPath)
            # create dictionary key
            currentDict = dict.__getitem__(currentDict, "directories")
            if currentDict.get(dir, None) is None:
                save = True
                currentDict[dir] = {"directories":{}, "files":{},
                                    "timestamp":datetime.utcnow(),
                                    "id":str(uuid.uuid1()),
                                    "info": info} # INFO MUST BE SET ONLY FOR THE LAST DIRECTORY

            currentDict = currentDict[dir]
            currentDir  = dirPath
        # save repository
        if save:
            self.save()
        # return currentDict
        return currentDict

Response:
Adds a directory in the repository and creates its
        attribute in the Repository with utc timestamp.


Instruction:
Create a Python 3 function for
removing a directory from the repository.

Response:
def remove_directory(self, relativePath, removeFromSystem=False):
        """
        Remove directory from repository.

        :Parameters:
            #. relativePath (string): The relative to the repository path of the directory to remove from the repository.
            #. removeFromSystem (boolean): Whether to also remove directory and all files from the system.\n
               Only files saved in the repository will be removed and empty left directories.
        """
        # get parent directory info
        relativePath = os.path.normpath(relativePath)
        parentDirInfoDict, errorMessage = self.get_parent_directory_info(relativePath)
        assert parentDirInfoDict is not None, errorMessage
        # split path
        path, name = os.path.split(relativePath)
        if dict.__getitem__(parentDirInfoDict, 'directories').get(name, None) is None:
            raise Exception("'%s' is not a registered directory in repository relative path '%s'"%(name, path))
        # remove from system
        if removeFromSystem:
            # remove files
            for rp in self.walk_files_relative_path(relativePath=relativePath):
                ap = os.path.join(self.__path, relativePath, rp)
                if not os.path.isfile(ap):
                    continue
                if not os.path.exists(ap):
                    continue
                if os.path.isfile(ap):
                    os.remove( ap )
            # remove directories
            for rp in self.walk_directories_relative_path(relativePath=relativePath):
                ap = os.path.join(self.__path, relativePath, rp)
                if not os.path.isdir(ap):
                    continue
                if not os.path.exists(ap):
                    continue
                if not len(os.listdir(ap)):
                    os.rmdir(ap)
        # pop directory from repo
        dict.__getitem__(parentDirInfoDict, 'directories').pop(name, None)
        ap = os.path.join(self.__path, relativePath)
        if not os.path.isdir(ap):
            if not len(os.listdir(ap)):
                os.rmdir(ap)
        # save repository
        self.save()


Instruction:
Can you tell what is the following Python 3 function doing
def move_directory(self, relativePath, relativeDestination, replace=False, verbose=True):
        # normalize path
        relativePath    = os.path.normpath(relativePath)
        relativeDestination = os.path.normpath(relativeDestination)
        # get files and directories
        filesInfo = list( self.walk_files_info(relativePath=relativePath) )
        dirsPath  = list( self.walk_directories_relative_path(relativePath=relativePath) )
        dirInfoDict, errorMessage = self.get_directory_info(relativePath)
        assert dirInfoDict is not None, errorMessage
        # remove directory info only
        self.remove_directory(relativePath=relativePath, removeFromSystem=False)
        # create new relative path
        self.add_directory(relativeDestination)
        # move files
        for RP, info in filesInfo:
            source      = os.path.join(self.__path, relativePath, RP)
            destination = os.path.join(self.__path, relativeDestination, RP)
            # add directory
            newDirRP, fileName = os.path.split(os.path.join(relativeDestination, RP))
            dirInfoDict = self.add_directory( newDirRP )
            # move file
            if os.path.isfile(destination):
                if replace:
                    os.remove(destination)
                    if verbose:
                        warnings.warn("file '%s' is copied replacing existing one in destination '%s'."%(fileName, newDirRP))
                else:
                    if verbose:
                        warnings.warn("file '%s' is not copied because the same file exists in destination '%s'."%(fileName,destination))
                    continue
            os.rename(source, destination)
            # set file information
            dict.__getitem__(dirInfoDict, "files")[fileName] = info
        # save repository
        self.save()

Response: Move a directory from one place to another.


Instruction:
Given the following Python 3 function, write the documentation
def rename_file(self, relativePath, name, newName, replace=False, verbose=True):
        # normalize path
        relativePath = os.path.normpath(relativePath)
        if relativePath == '.':
            relativePath = ''
        dirInfoDict, errorMessage = self.get_directory_info(relativePath)
        assert dirInfoDict is not None, errorMessage
        # check directory in repository
        assert name in dict.__getitem__(dirInfoDict, "files"), "file '%s' is not found in repository relative path '%s'"%(name, relativePath)
        # get real path
        realPath = os.path.join(self.__path, relativePath, name)
        assert os.path.isfile(realPath), "file '%s' is not found in system"%realPath
        # assert directory new name doesn't exist in repository
        assert newName not in dict.__getitem__(dirInfoDict, "files"), "file '%s' already exists in repository relative path '%s'"%(newName, relativePath)
        # check new directory in system
        newRealPath = os.path.join(self.__path, relativePath, newName)
        if os.path.isfile( newRealPath ):
            if replace:
                os.remove(newRealPath)
                if verbose:
                    warnings.warn( "file '%s' already exists found in system, it is now replaced by '%s' because 'replace' flag is True."%(newRealPath,realPath) )
            else:
                raise Exception( "file '%s' already exists in system but not registered in repository."%newRealPath )
        # rename file
        os.rename(realPath, newRealPath)
        dict.__setitem__( dict.__getitem__(dirInfoDict, "files"),
                          newName,
                          dict.__getitem__(dirInfoDict, "files").pop(name) )
        # save repository
        self.save()

Response: Rename a file in the repository. It insures renaming the file in the system.