Instruction:
Can you generate the documentation for the following Python 3 function
def reporter(self):
        # Create the path in which the reports are stored
        make_path(self.reportpath)
        logging.info('Creating {} report'.format(self.analysistype))
        # Initialise the header and data strings
        header = 'Strain,Gene,PercentIdentity,Genus,FoldCoverage\n'
        data = ''
        with open(self.sixteens_report, 'w') as report:
            with open(os.path.join(self.reportpath, self.analysistype + '_sequences.fa'), 'w') as sequences:
                for sample in self.runmetadata.samples:
                    # Initialise
                    sample[self.analysistype].sixteens_match = 'NA'
                    sample[self.analysistype].species = 'NA'
                    try:
                        # Select the best hit of all the full-length 16S genes mapped - for 16S use the hit with the
                        # fewest number of SNPs rather than the highest percent identity
                        sample[self.analysistype].besthit = sorted(sample[self.analysistype].resultssnp.items(),
                                                                   key=operator.itemgetter(1))[0][0]
                        # Parse the baited FASTA file to pull out the the description of the hit
                        for record in SeqIO.parse(sample[self.analysistype].baitfile, 'fasta'):
                            # If the best hit e.g. gi|631251361|ref|NR_112558.1| is present in the current record,
                            # gi|631251361|ref|NR_112558.1| Escherichia coli strain JCM 1649 16S ribosomal RNA ...,
                            # extract the match and the species
                            if sample[self.analysistype].besthit in record.id:
                                # Set the best match and species from the records
                                sample[self.analysistype].sixteens_match = record.description.split(' 16S')[0]
                                sample[self.analysistype].species = \
                                    sample[self.analysistype].sixteens_match.split('|')[-1].split()[1]
                        # Add the sample name to the data string
                        data += sample.name + ','
                        # Find the record that matches the best hit, and extract the necessary values to be place in the
                        # data string
                        for name, identity in sample[self.analysistype].results.items():
                            if name == sample[self.analysistype].besthit:
                                data += '{},{},{},{}\n'.format(name, identity, sample[self.analysistype].genus,
                                                               sample[self.analysistype].avgdepth[name])
                                # Create a FASTA-formatted sequence output of the 16S sequence
                                record = SeqRecord(Seq(sample[self.analysistype].sequences[name],
                                                       IUPAC.unambiguous_dna),
                                                   id='{}_{}'.format(sample.name, '16S'),
                                                   description='')
                                SeqIO.write(record, sequences, 'fasta')
                    except (AttributeError, IndexError):
                        data += '{}\n'.format(sample.name)
            # Write the results to the report
            report.write(header)
            report.write(data)

Response: Creates a report of the results of the current sample


Instruction:
Can you generate the documentation for the following Python 3 function
def add_listener(self, evt_name, fn):
        self._listeners.setdefault(evt_name, [])
        listeners = self.__get_listeners(evt_name)
        listeners.append(fn)

Response: add_listener - 创建 event listener


Instruction:
Can you generate the documentation for the following Python 3 function
def remove_listener(self, evt_name, fn, remove_all=False):
        listeners = self.__get_listeners(evt_name)
        if not self.has_listener(evt_name, fn):
            raise ObservableError(
                "function %r does not exist in the %r event",
                fn, evt_name)
        if remove_all:
            listeners[:] = [i for i in listeners if i != fn]
        else:
            listeners.remove(fn)

Response: remove_listener - remove a listener function from an event.


Instruction:
Can you generate the documentation for the following Python 3 function
def has_listener(self, evt_name, fn):
        listeners = self.__get_listeners(evt_name)
        return fn in listeners

Response: check if a listener exists


Instruction:
How would you code a function in Python 3 to
fire event to all listeners

Response:
def fire_event(self, evt_name, *args, **kwargs):
        """触发事件

        :params evt_name: 事件名称
        :params args: 给事件接受者的参数
        :params kwargs: 给事件接受者的参数
        """
        listeners = self.__get_listeners(evt_name)
        evt = self.generate_event(evt_name)
        for listener in listeners:
            listener(evt, *args, **kwargs)


Instruction:
Make a summary of the following Python 3 code
def create_server_ec2(connection,
                      region,
                      disk_name,
                      disk_size,
                      ami,
                      key_pair,
                      instance_type,
                      tags={},
                      security_groups=None,
                      delete_on_termination=True,
                      log=False,
                      wait_for_ssh_available=True):
    """
    Creates EC2 Instance
    """

    if log:
        log_green("Started...")
        log_yellow("...Creating EC2 instance...")

    ebs_volume = EBSBlockDeviceType()
    ebs_volume.size = disk_size
    bdm = BlockDeviceMapping()
    bdm[disk_name] = ebs_volume

    # get an ec2 ami image object with our choosen ami
    image = connection.get_all_images(ami)[0]
    # start a new instance
    reservation = image.run(1, 1,
                            key_name=key_pair,
                            security_groups=security_groups,
                            block_device_map=bdm,
                            instance_type=instance_type)

    # and get our instance_id
    instance = reservation.instances[0]

    #  and loop and wait until ssh is available
    while instance.state == u'pending':
        if log:
            log_yellow("Instance state: %s" % instance.state)
        sleep(10)
        instance.update()
    if log:
        log_green("Instance state: %s" % instance.state)
    if wait_for_ssh_available:
        wait_for_ssh(instance.public_dns_name)

    # update the EBS volumes to be deleted on instance termination
    if delete_on_termination:
        for dev, bd in instance.block_device_mapping.items():
            instance.modify_attribute('BlockDeviceMapping',
                                      ["%s=%d" % (dev, 1)])

    # add a tag to our instance
    connection.create_tags([instance.id], tags)

    if log:
        log_green("Public dns: %s" % instance.public_dns_name)

    # returns our new instance
    return instance

Response: Create a server EC2 instance.


Instruction:
Can you generate the documentation for the following Python 3 function
def destroy_ebs_volume(connection, region, volume_id, log=False):

    if ebs_volume_exists(connection, region, volume_id):
        if log:
            log_yellow('destroying EBS volume ...')
        try:
            connection.delete_volume(volume_id)
        except:
            # our EBS volume may be gone, but AWS info tables are stale
            # wait a bit and ask again
            sleep(5)
            if not ebs_volume_exists(connection, region, volume_id):
                pass
            else:
                raise("Couldn't delete EBS volume")

Response: destroys an EBS volume


Instruction:
Can you tell what is the following Python 3 function doing
def destroy_ec2(connection, region, instance_id, log=False):

    data = get_ec2_info(connection=connection,
                        instance_id=instance_id,
                        region=region)

    instance = connection.terminate_instances(instance_ids=[data['id']])[0]
    if log:
        log_yellow('destroying instance ...')
    while instance.state != "terminated":
        if log:
            log_yellow("Instance state: %s" % instance.state)
        sleep(10)
        instance.update()
    volume_id = data['volume']
    if volume_id:
        destroy_ebs_volume(connection, region, volume_id)

Response: terminate the EC2 instance


Instruction:
Here you have a function in Python 3, explain what it does
def down_ec2(connection, instance_id, region, log=False):
    # get the instance_id from the state file, and stop the instance
    instance = connection.stop_instances(instance_ids=instance_id)[0]
    while instance.state != "stopped":
        if log:
            log_yellow("Instance state: %s" % instance.state)
        sleep(10)
        instance.update()
    if log:
        log_green('Instance state: %s' % instance.state)

Response: Shutdown an EC2 instance


Instruction:
How would you implement a function in Python 3 that
returns True if a ebs volume exists

Response:
def ebs_volume_exists(connection, region, volume_id):
    """ finds out if a ebs volume exists """
    for vol in connection.get_all_volumes():
        if vol.id == volume_id:
            return True
    return False


Instruction:
Given the following Python 3 function, write the documentation
def get_ec2_info(connection,
                 instance_id,
                 region,
                 username=None):
    """ queries EC2 for details about a particular instance_id
    """
    instance = connection.get_only_instances(
        filters={'instance_id': instance_id}
        )[0]

    data = instance.__dict__
    data['state'] = instance.state
    data['cloud_type'] = 'ec2'

    try:
        volume = connection.get_all_volumes(
            filters={'attachment.instance-id': instance.id}
        )[0].id
        data['volume'] = volume
    except:
        data['volume'] = ''
    return data

Response:
queries EC2 for details about a particular instance_id
WorkItem


Instruction:
Here you have a function in Python 3, explain what it does
def up_ec2(connection,
           region,
           instance_id,
           wait_for_ssh_available=True,
           log=False,
           timeout=600):
    """ boots an existing ec2_instance """

    # boot the ec2 instance
    instance = connection.start_instances(instance_ids=instance_id)[0]
    instance.update()
    while instance.state != "running" and timeout > 1:
        log_yellow("Instance state: %s" % instance.state)
        if log:
            log_yellow("Instance state: %s" % instance.state)
        sleep(10)
        timeout = timeout - 10
        instance.update()

    # and make sure we don't return until the instance is fully up
    if wait_for_ssh_available:
        wait_for_ssh(instance.ip_address)

Response: boot an ec2 instance


Instruction:
Make a summary of the following Python 3 code
def seqs_from_file(filename, exit_on_err=False, return_qual=False):
   # VALIDATE INPUT
   if not isinstance(filename, str):
      msg = 'Filename has to be a string.'
      if exit_on_err:
         sys.stderr.write('Error: %s\n'%msg)
         sys.exit(1)
      else: raise IOError(msg)
   if not os.path.exists(filename):
      msg = 'File "%s" does not exist.'%filename
      if exit_on_err:
         sys.stderr.write('Error: %s\n'%msg)
         sys.exit(1)
      else: raise IOError(msg)

   # EXTRACT DATA
   with open_(filename,"rt") as f:
      query_seq_segments = []
      seq, name, desc, qual = '', '', '', ''
      add_segment = query_seq_segments.append
      for l in f:
         if len(l.strip()) == 0: continue
         #sys.stderr.write("%s\n"%line)
         fields=l.strip().split()
         if l.startswith(">"):
            # FASTA HEADER FOUND
            if query_seq_segments != []:
               # YIELD SEQUENCE AND RESET
               seq = ''.join(query_seq_segments)
               yield (seq, name, desc)
               seq, name, desc = '', '', ''
               del query_seq_segments[:]
            name = fields[0][1:]
            desc = ' '.join(fields[1:])

         elif l.startswith("@"):
            # FASTQ HEADER FOUND
            name = fields[0][1:]
            desc = ' '.join(fields[1:])
            try:
               # EXTRACT FASTQ SEQUENCE
               seq  = next(f).strip().split()[0]
               # SKIP SECOND HEADER LINE AND QUALITY SCORES
               l = next(f)
               qual = next(f).strip() # Qualities
            except:
               break
            else:
               # YIELD SEQUENCE AND RESET
               if return_qual:
                  yield (seq, qual, name, desc)
               else:
                  yield (seq, name, desc)
               seq, name, desc, qual = '', '', '', ''

         elif len(fields[0])>0:
            # EXTRACT FASTA SEQUENCE
            add_segment(fields[0])

      # CHECK FOR LAST FASTA SEQUENCE
      if query_seq_segments != []:
         # YIELD SEQUENCE
         seq = ''.join(query_seq_segments)
         yield (seq, name, desc)

Response: Extract sequences from a file.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def open_(filename, mode=None, compresslevel=9):
   if filename[-3:] == '.gz':
      if mode is None: mode = 'rt'
      return closing(gzip.open(filename, mode, compresslevel))
   else:
      if mode is None: mode = 'r'
      return open(filename, mode)

Response: Open a file and return a file object.


Instruction:
Can you create a Python 3 function that
loads json from file or file name

Response:
def load_json(json_object):
   ''' Load json from file or file name '''
   content = None
   if isinstance(json_object, str) and os.path.exists(json_object):
      with open_(json_object) as f:
         try:
            content = json.load(f)
         except Exception as e:
            debug.log("Warning: Content of '%s' file is not json."%f.name)
   elif hasattr(json_object, 'read'):
      try:
         content = json.load(json_object)
      except Exception as e:
         debug.log("Warning: Content of '%s' file is not json."%json_object.name)
   else:
      debug.log("%s\nWarning: Object type invalid!"%json_object)
   return content


Instruction:
Can you write a function in Python 3 where it
sorts an array of strings to groups by patterns

Response:
def sort2groups(array, gpat=['_R1','_R2']):
   """ Sort an array of strings to groups by patterns """
   groups = [REGroup(gp) for gp in gpat]
   unmatched = []
   for item in array:
      matched = False
      for m in groups:
         if m.match(item):
            matched = True
            break
      if not matched: unmatched.append(item)
   return [sorted(m.list) for m in groups], sorted(unmatched)


Instruction:
Can you generate a brief explanation for the following Python 3 code
def sort_and_distribute(array, splits=2):
   if not isinstance(array, (list,tuple)): raise TypeError("array must be a list")
   if not isinstance(splits, int): raise TypeError("splits must be an integer")
   remaining = sorted(array)
   if sys.version_info < (3, 0):
      myrange = xrange(splits)
   else:
      myrange = range(splits)
   groups = [[] for i in myrange]
   while len(remaining) > 0:
      for i in myrange:
         if len(remaining) > 0: groups[i].append(remaining.pop(0))
   return groups

Response:
Sort an array of strings to groups by alphabetically continuous
       distribution


Instruction:
Explain what the following Python 3 code does
def mkpath(filepath, permissions=0o777):
   # Converting string of octal to integer, if string is given.
   if isinstance(permissions, str):
      permissions = sum([int(x)*8**i for i,x in enumerate(reversed(permissions))])
   # Creating directory
   if not os.path.exists(filepath):
      debug.log("Creating Directory %s (permissions: %s)"%(
         filepath, permissions))
      os.makedirs(filepath, permissions)
   else:
      debug.log("Warning: The directory "+ filepath +" already exists")
   return filepath

Response: This function creates a directory and returns the path.


Instruction:
Can you tell what is the following Python 3 function doing
def create_zip_dir(zipfile_path, *file_list):
   try:
      if isinstance(file_list, (list, tuple)): #unfolding list of list or tuple
         if len(file_list) == 1:
            if isinstance(file_list[0], (list, tuple)): file_list = file_list[0]
      #converting string to iterable list
      if isinstance(file_list, str): file_list = [file_list]
      if file_list:
         with ZipFile(zipfile_path, 'w') as zf:
            for cur_file in file_list:
               if '/' in cur_file:
                  os.chdir('/'.join(cur_file.split('/')[:-1]))
               elif '/' in zipfile_path:
                  os.chdir('/'.join(zipfile_path.split('/')[:-1]))
               zf.write(cur_file.split('/')[-1])
      else:
         debug.log('Error: No Files in list!',zipfile_path+' was not created!')
   except Exception as e:
      debug.log('Error: Could not create zip dir! argtype: '+
                 str(type(file_list)), "FileList: "+ str(file_list),
                 "Errormessage: "+ str(e))

Response: This function creates a zipfile located in zipFilePath with the files in file_list.


Instruction:
Make a summary of the following Python 3 code
def file_zipper(root_dir):
   # FINDING AND ZIPPING UNZIPPED FILES
   for root, dirs, files in os.walk(root_dir, topdown=False):
      if root != "":
         if root[-1] != '/': root += '/'
         for current_file in files:
            filepath = "%s/%s"%(root, current_file)
            try:
               file_size = os.path.getsize(filepath)
            except Exception as e:
               file_size = 0
               debug.log('Error: file_zipper failed to zip following file '+filepath, e)
            # Excluding small files, gzipped files and links
            if (         file_size > 50
                 and     current_file[-3:] != ".gz"
                 and not os.path.islink(filepath)
               ):
               if current_file[-4:] == ".zip":
                  # Unzip file
                  ec = Popen('unzip -qq "%s" -d %s > /dev/null 2>&1'%(filepath, root), shell=True).wait()
                  if ec > 0:
                     debug.log('Error: fileZipper failed to unzip following file %s'%filepath)
                     continue
                  else:
                     ec = Popen('rm -f "%s" > /dev/null 2>&1'%(filepath), shell=True).wait()
                     if ec > 0: debug.log('Error: fileZipper failed to delete the original zip file (%s)'%filepath)
                     filepath = filepath[:-4]
                  # Saving a gzipped version
                  with open_(filepath, 'rb') as f, open_(filepath+".gz", 'wb', 9) as gz:
                     gz.writelines(f)
                  # Deleting old (non-zipped) file
                  try: os.remove(filepath)
                  except OSError as e:
                     debug.log(("WARNING! The file %s could not be "
                                    "removed!\n%s")%(current_file, e))

Response: This function will zip the files created in the runroot directory and all subdirectories of the runroot directory.


Instruction:
Make a summary of the following Python 3 code
def move_file(src, dst):
   # Sanity checkpoint
   src = re.sub('[^\w/\-\.\*]', '', src)
   dst = re.sub('[^\w/\-\.\*]', '', dst)
   if len(re.sub('[\W]', '', src)) < 5 or len(re.sub('[\W]', '', dst)) < 5:
      debug.log("Error: Moving file failed. Provided paths are invalid! src='%s' dst='%s'"%(src, dst))
   else:
      # Check destination
      check = False
      if dst[-1] == '/':
         if os.path.exists(dst):
            check = True # Valid Dir
         else:
            debug.log("Error: Moving file failed. Destination directory does not exist (%s)"%(dst)) #DEBUG
      elif os.path.exists(dst):
         if os.path.isdir(dst):
            check = True # Valid Dir
            dst += '/' # Add missing slash
         else:
            debug.log("Error: Moving file failed. %s exists!"%dst)
      elif os.path.exists(os.path.dirname(dst)):
         check = True # Valid file path
      else:
         debug.log("Error: Moving file failed. %s is an invalid distination!"%dst)
      if check:
         # Check source
         files = glob.glob(src)
         if len(files) != 0:
            debug.log("Moving File(s)...", "Move from %s"%src, "to %s"%dst)
            for file_ in files:
               # Check if file contains invalid symbols:
               invalid_chars = re.findall('[^\w/\-\.\*]', os.path.basename(file_))
               if invalid_chars:
                  debug.graceful_exit(("Error: File %s contains invalid "
                                      "characters %s!"
                                      )%(os.path.basename(file_), invalid_chars))
                  continue
               # Check file exists
               if os.path.isfile(file_):
                  debug.log("Moving file: %s"%file_)
                  shutil.move(file_, dst)
               else:
                  debug.log("Error: Moving file failed. %s is not a regular file!"%file_)
         else: debug.log("Error: Moving file failed. No files were found! (%s)"%src)

Response: This function will move a file from one path to another.


Instruction:
Can you generate the documentation for the following Python 3 function
def copy_file(src, dst, ignore=None):
   # Sanity checkpoint
   src = re.sub('[^\w/\-\.\*]', '', src)
   dst = re.sub('[^\w/\-\.\*]', '', dst)
   if len(re.sub('[\W]', '', src)) < 5 or len(re.sub('[\W]', '', dst)) < 5:
      debug.log("Error: Copying file failed. Provided paths are invalid! src='%s' dst='%s'"%(src, dst))
   else:
      # Check destination
      check = False
      if dst[-1] == '/':
         if os.path.exists(dst):
            check = True # Valid Dir
         else:
            debug.log("Error: Copying file failed. Destination directory does not exist (%s)"%(dst)) #DEBUG
      elif os.path.exists(dst):
         if os.path.isdir(dst):
            check = True # Valid Dir
            dst += '/' # Add missing slash
         else:
            debug.log("Error: Copying file failed. %s exists!"%dst)
      elif os.path.exists(os.path.dirname(dst)):
         check = True # Valid file path
      else:
         debug.log("Error: Copying file failed. %s is an invalid distination!"%dst)
      if check:
         # Check source
         files = glob.glob(src)
         if ignore is not None: files = [fil for fil in files if not ignore in fil]
         if len(files) != 0:
            debug.log("Copying File(s)...", "Copy from %s"%src, "to %s"%dst) #DEBUG
            for file_ in files:
               # Check file exists
               if os.path.isfile(file_):
                  debug.log("Copying file: %s"%file_) #DEBUG
                  shutil.copy(file_, dst)
               else:
                  debug.log("Error: Copying file failed. %s is not a regular file!"%file_) #DEBUG
         else: debug.log("Error: Copying file failed. No files were found! (%s)"%src)

Response: This function will copy a file from one path to another.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def copy_dir(src, dst):
   try:
      debug.log("copy dir from "+ src, "to "+ dst)
      shutil.copytree(src, dst)
   except Exception as e:
      debug.log("Error: happened while copying!\n%s\n"%e)

Response: this function will simply copy the file from the source path to the destination path given as input


Instruction:
Can you tell what is the following Python 3 function doing
def print_out(self, *lst):
      self.print2file(self.stdout, True, True, *lst)

Response: Print list of strings to the predefined stdout.


Instruction:
Write a Python 3 function that can
print list of strings to the predefined stderr.

Response:
def print_err(self, *lst):
      """ Print list of strings to the predefined stdout. """
      self.print2file(self.stderr, False, True, *lst)


Instruction:
Here you have a function in Python 3, explain what it does
def print2file(self, logfile, print2screen, addLineFeed, *lst):
      if addLineFeed:
         linefeed = '\n'
      else: linefeed = ''
      if print2screen: print(linefeed.join(str(string) for string in lst))
      try: file_instance = isinstance(logfile, file)
      except NameError as e:
         from io import IOBase
         try: file_instance = isinstance(logfile, IOBase)
         except: raise e
      if file_instance:
         logfile.write(linefeed.join(str(string) for string in lst) + linefeed)
      elif isinstance(logfile, str) and os.path.exists(logfile):
         with open_(logfile, 'a') as f:
            f.write(linefeed.join(str(string) for string in lst) + linefeed)
      elif not print2screen: # Print to screen if there is no outputfile
         print(linefeed.join(str(string) for string in lst))

Response: This function prints to the screen and logs to a file.


Instruction:
Can you generate the documentation for the following Python 3 function
def log(self, *lst):
      self.print2file(self.logfile, self.debug, True, *lst)
      if 'Error' in '\n'.join([str(x) for x in lst]):
         self.caught_error = '\n'.join([str(x) for x in lst])

Response: Print list of strings to the predefined logfile if debug is set.


Instruction:
Write a Python 3 script for
printing a message to the predefined log file without a newline.

Response:
def log_no_newline(self, msg):
      """ print the message to the predefined log file without newline """
      self.print2file(self.logfile, False, False, msg)


Instruction:
Can you generate the documentation for the following Python 3 function
def get_tree(self, list_of_keys):
      cur_obj = self
      for key in list_of_keys:
         cur_obj = cur_obj.get(key)
         if not cur_obj: break
      return cur_obj

Response: This function will extract the value from a nested dictionary and return it.


Instruction:
Implement a function in Python 3 to
return inverse mapping of dictionary with sorted values.

Response:
def invert(self):
      ''' Return inverse mapping of dictionary with sorted values.
      USAGE
         >>> # Switch the keys and values
         >>> adv_dict({
         ...     'A': [1, 2, 3],
         ...     'B': [4, 2],
         ...     'C': [1, 4],
         ... }).invert()
         {1: ['A', 'C'], 2: ['A', 'B'], 3: ['A'], 4: ['B', 'C']}
      '''
      inv_map = {}
      for k, v in self.items():
         if sys.version_info < (3, 0):
            acceptable_v_instance = isinstance(v, (str, int, float, long))
         else:
            acceptable_v_instance = isinstance(v, (str, int, float))
         if acceptable_v_instance: v = [v]
         elif not isinstance(v, list):
            raise Exception('Error: Non supported value format! Values may only'
                            ' be numerical, strings, or lists of numbers and '
                            'strings.')
         for val in v:
            inv_map[val] = inv_map.get(val, [])
            inv_map[val].append(k)
            inv_map[val].sort()
      return inv_map


Instruction:
Write a Python 3 function for
replacing the string with the given string.

Response:
def sub(self, replace, string, count=0):
      """ returns new string where the matching cases (limited by the count) in
      the string is replaced. """
      return self.re.sub(replace, string, count)


Instruction:
Can you write a function in Python 3 where it
matches the given string to the stored regular expression and stores all groups in mathches. Returns True on success.

Response:
def match(self, s):
      """ Matches the string to the stored regular expression, and stores all
      groups in mathches. Returns False on negative match. """
      self.matches = self.re.search(s)
      return self.matches


Instruction:
Can you create a Python 3 function that
returns True if the pattern matches the input string returns False otherwise

Response:
def match(self, s):
      """ Matching the pattern to the input string, returns True/False and
          saves the matched string in the internal list
      """
      if self.re.match(s):
         self.list.append(s)
         return True
      else: return False


Instruction:
Implement a Python 3 function for
creating the MASH report

Response:
def reporter(self):
        """
        Create the MASH report
        """
        logging.info('Creating {} report'.format(self.analysistype))
        make_path(self.reportpath)
        header = 'Strain,ReferenceGenus,ReferenceFile,ReferenceGenomeMashDistance,Pvalue,NumMatchingHashes\n'
        data = ''
        for sample in self.metadata:
            try:
                data += '{},{},{},{},{},{}\n'.format(sample.name,
                                                     sample[self.analysistype].closestrefseqgenus,
                                                     sample[self.analysistype].closestrefseq,
                                                     sample[self.analysistype].mashdistance,
                                                     sample[self.analysistype].pvalue,
                                                     sample[self.analysistype].nummatches)
            except AttributeError:
                data += '{}\n'.format(sample.name)
        # Create the report file
        reportfile = os.path.join(self.reportpath, 'mash.csv')
        with open(reportfile, 'w') as report:
            report.write(header)
            report.write(data)


Instruction:
Make a summary of the following Python 3 code
def get_function(pkgpath):
    # Extract the module and function name from pkgpath
    elems = pkgpath.split('.')
    if len(elems) <= 1:
        raise PyMacaronCoreException("Path %s is too short. Should be at least module.func." % elems)
    func_name = elems[-1]
    func_module = '.'.join(elems[0:-1])

    # Load the function's module and get the function
    try:
        m = import_module(func_module)
        f = getattr(m, func_name)
        return f
    except Exception as e:
        t = traceback.format_exc()
        raise PyMacaronCoreException("Failed to import %s: %s\nTrace:\n%s" % (pkgpath, str(e), t))

Response:
Take a full path to a python method or class for example
    mypkg. subpkg. method and return the method or class


Instruction:
Explain what the following Python 3 code does
def runner(self):
        printtime('Starting {} analysis pipeline'.format(self.analysistype), self.starttime)
        # Create the objects to be used in the analyses
        objects = Objectprep(self)
        objects.objectprep()
        self.runmetadata = objects.samples
        # Run the analyses
        sippr = Sippr(self, self.cutoff)
        sippr.clear()
        # Print the metadata
        printer = MetadataPrinter(self)
        printer.printmetadata()

Response: Run the necessary methods in the correct order.


Instruction:
Create a Python 3 function for
syllabifying the given word whether simplex or complex.

Response:
def syllabify(word):
    '''Syllabify the given word, whether simplex or complex.'''
    word = split(word)  # detect any non-delimited compounds
    compound = True if re.search(r'-| |\.', word) else False
    syllabify = _syllabify_compound if compound else _syllabify
    syll, rules = syllabify(word)

    yield syll, rules

    n = 3

    if 'T4' in rules:
        yield syllabify(word, T4=False)
        n -= 1

    if 'e' in rules:
        yield syllabify(word, T1E=False)
        n -= 1

    if 'e' in rules and 'T4' in rules:
        yield syllabify(word, T4=False, T1E=False)
        n -= 1

    # yield empty syllabifications and rules
    for n in range(7):
        yield '', ''


Instruction:
How would you explain what the following Python 3 function does
def edges(self):
        edge_str = ctypes.create_string_buffer(MAX_CHARS)

        cgaddag.gdg_edges(self.gdg, self.node, edge_str)

        return [char for char in edge_str.value.decode("ascii")]

Response: Return the edge characters of this node.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def letter_set(self):
        end_str = ctypes.create_string_buffer(MAX_CHARS)

        cgaddag.gdg_letter_set(self.gdg, self.node, end_str)

        return [char for char in end_str.value.decode("ascii")]

Response: Return the letter set of this node.


Instruction:
Create a Python 3 function to
return True if this char is part of this node s letter set False otherwise.

Response:
def is_end(self, char):
        """
        Return `True` if this `char` is part of this node's letter set,
        `False` otherwise.
        """
        char = char.lower()

        return bool(cgaddag.gdg_is_end(self.gdg, self.node, char.encode("ascii")))


Instruction:
Make a summary of the following Python 3 code
def follow(self, chars):
        chars = chars.lower()

        node = self.node
        for char in chars:
            node = cgaddag.gdg_follow_edge(self.gdg, node, char.encode("ascii"))
            if not node:
                raise KeyError(char)

        return Node(self.gdg, node)

Response: Traverse the GADDAG to the node at the end of the given characters.


Instruction:
Create a Python 3 function to
split a docker link string into a list of 3 items.

Response:
def _split_docker_link(alias_name):
    """
    Splits a docker link string into a list of 3 items (protocol, host, port).
    - Assumes IPv4 Docker links

    ex: _split_docker_link('DB') -> ['tcp', '172.17.0.82', '8080']
    """
    sanitized_name = alias_name.strip().upper()
    split_list = re.split(r':|//', core.str('{0}_PORT'.format(sanitized_name)))
    # filter out empty '' vals from the list with filter and
    # cast to list (required for python3)
    return list(filter(None, split_list))


Instruction:
Write a Python 3 function for
getting the raw docker link value.

Response:
def read(alias_name, allow_none=False):
    """Get the raw docker link value.

    Get the raw environment variable for the docker link

    Args:
        alias_name: The environment variable name
        default: The default value if the link isn't available
        allow_none: If the return value can be `None` (i.e. optional)
    """
    warnings.warn('Will be removed in v1.0', DeprecationWarning, stacklevel=2)
    return core.read('{0}_PORT'.format(alias_name), default=None, allow_none=allow_none)


Instruction:
Here you have a function in Python 3, explain what it does
def isset(alias_name):
    warnings.warn('Will be removed in v1.0', DeprecationWarning, stacklevel=2)
    raw_value = read(alias_name, allow_none=True)
    if raw_value:
        if re.compile(r'.+://.+:\d+').match(raw_value):
            return True
        else:
            warnings.warn('"{0}_PORT={1}" does not look like a docker link.'.format(alias_name, raw_value), stacklevel=2)
            return False

    return False

Response: Return a boolean if the docker link is set or not.


Instruction:
Write a Python 3 script for
getting the protocol from the docker link alias or return the default value.

Response:
def protocol(alias_name, default=None, allow_none=False):
    """Get the protocol from the docker link alias or return the default.

    Args:
        alias_name: The docker link alias
        default: The default value if the link isn't available
        allow_none: If the return value can be `None` (i.e. optional)

    Examples:
        Assuming a Docker link was created with ``docker --link postgres:db``
        and the resulting environment variable is ``DB_PORT=tcp://172.17.0.82:5432``.

        >>> envitro.docker.protocol('DB')
        tcp
    """
    warnings.warn('Will be removed in v1.0', DeprecationWarning, stacklevel=2)
    try:
        return _split_docker_link(alias_name)[0]
    except KeyError as err:
        if default or allow_none:
            return default
        else:
            raise err


Instruction:
Can you implement a function in Python 3 that
gets the port from the docker link alias or return the default value.

Response:
def port(alias_name, default=None, allow_none=False):
    """Get the port from the docker link alias or return the default.

    Args:
        alias_name: The docker link alias
        default: The default value if the link isn't available
        allow_none: If the return value can be `None` (i.e. optional)

    Examples:
        Assuming a Docker link was created with ``docker --link postgres:db``
        and the resulting environment variable is ``DB_PORT=tcp://172.17.0.82:5432``.

        >>> envitro.docker.port('DB')
        5432
    """
    warnings.warn('Will be removed in v1.0', DeprecationWarning, stacklevel=2)
    try:
        return int(_split_docker_link(alias_name)[2])
    except KeyError as err:
        if default or allow_none:
            return default
        else:
            raise err


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

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


Instruction:
Here you have a function in Python 3, explain what it does
def attributer(self):
        from Bio import SeqIO
        import operator
        for sample in self.runmetadata.samples:
            # Load the records from the target file into a dictionary
            record_dict = SeqIO.to_dict(SeqIO.parse(sample[self.analysistype].baitfile, "fasta"))
            sample[self.analysistype].classification = set()
            sample[self.analysistype].genera = dict()
            # Add all the genera with hits into the set of genera
            for result in sample[self.analysistype].results:
                genus, species = record_dict[result].description.split('|')[-1].split()[:2]
                sample[self.analysistype].classification.add(genus)
                sample[self.analysistype].genera[result] = genus
            # Convert the set to a list for easier JSON serialisation
            sample[self.analysistype].classification = list(sample[self.analysistype].classification)
            # If there is a mixed sample, then further analyses will be complicated
            if len(sample[self.analysistype].classification) > 1:
                # print('multiple: ', sample.name, sample[self.analysistype].classification)
                sample.general.closestrefseqgenus = sample[self.analysistype].classification
                # sample.general.bestassemblyfile = 'NA'
                sample[self.analysistype].multiple = True
            else:
                sample[self.analysistype].multiple = False

                try:
                    # Recreate the results dictionary with the percent identity as a float rather than a string
                    sample[self.analysistype].intresults = \
                        {key: float(value) for key, value in sample[self.analysistype].results.items()}
                    # Set the best hit to be the top entry from the sorted results
                    sample[self.analysistype].besthit = sorted(sample[self.analysistype].intresults.items(),
                                                               key=operator.itemgetter(1), reverse=True)[0]
                    sample.general.closestrefseqgenus = sample[self.analysistype].classification[0]
                except IndexError:
                    sample.general.bestassemblyfile = 'NA'

Response: Parses the 16S target files to link accession numbers stored in the. fai and the. metadata files to the genera stored in the. genera file.


Instruction:
Can you implement a function in Python 3 that
spawns a REST API.

Response:
def spawn_server_api(api_name, app, api_spec, error_callback, decorator):
    """Take a a Flask app and a swagger file in YAML format describing a REST
    API, and populate the app with routes handling all the paths and methods
    declared in the swagger file.

    Also handle marshaling and unmarshaling between json and object instances
    representing the definitions from the swagger file.
    """

    def mycallback(endpoint):
        handler_func = get_function(endpoint.handler_server)

        # Generate api endpoint around that handler
        handler_wrapper = _generate_handler_wrapper(api_name, api_spec, endpoint, handler_func, error_callback, decorator)

        # Bind handler to the API path
        log.info("Binding %s %s ==> %s" % (endpoint.method, endpoint.path, endpoint.handler_server))
        endpoint_name = '_'.join([endpoint.method, endpoint.path]).replace('/', '_')
        app.add_url_rule(endpoint.path, endpoint_name, handler_wrapper, methods=[endpoint.method])

    api_spec.call_on_each_endpoint(mycallback)

    # Add custom error handlers to the app
    add_error_handlers(app)


Instruction:
Write a Python 3 script to
take a bravado - core model representing an error and return a Flask Response containing the given error code and error instance as body

Response:
def _responsify(api_spec, error, status):
    """Take a bravado-core model representing an error, and return a Flask Response
    with the given error code and error instance as body"""
    result_json = api_spec.model_to_json(error)
    r = jsonify(result_json)
    r.status_code = status
    return r


Instruction:
How would you code a function in Python 3 to
generate a handler function for the given url method + path and operation

Response:
def _generate_handler_wrapper(api_name, api_spec, endpoint, handler_func, error_callback, global_decorator):
    """Generate a handler method for the given url method+path and operation"""

    # Decorate the handler function, if Swagger spec tells us to
    if endpoint.decorate_server:
        endpoint_decorator = get_function(endpoint.decorate_server)
        handler_func = endpoint_decorator(handler_func)

    @wraps(handler_func)
    def handler_wrapper(**path_params):
        log.info(" ")
        log.info(" ")
        log.info("=> INCOMING REQUEST %s %s -> %s" %
                 (endpoint.method, endpoint.path, handler_func.__name__))
        log.info(" ")
        log.info(" ")

        # Get caller's pym-call-id or generate one
        call_id = request.headers.get('PymCallID', None)
        if not call_id:
            call_id = str(uuid.uuid4())
        stack.top.call_id = call_id

        # Append current server to call path, or start one
        call_path = request.headers.get('PymCallPath', None)
        if call_path:
            call_path = "%s.%s" % (call_path, api_name)
        else:
            call_path = api_name
        stack.top.call_path = call_path

        if endpoint.param_in_body or endpoint.param_in_query:
            # Turn the flask request into something bravado-core can process...
            try:
                req = FlaskRequestProxy(request, endpoint.param_in_body)
            except BadRequest:
                ee = error_callback(ValidationError("Cannot parse json data: have you set 'Content-Type' to 'application/json'?"))
                return _responsify(api_spec, ee, 400)

            try:
                # Note: unmarshall validates parameters but does not fail
                # if extra unknown parameters are submitted
                parameters = unmarshal_request(req, endpoint.operation)
                # Example of parameters: {'body': RegisterCredentials()}
            except jsonschema.exceptions.ValidationError as e:
                ee = error_callback(ValidationError(str(e)))
                return _responsify(api_spec, ee, 400)

        # Call the endpoint, with proper parameters depending on whether
        # parameters are in body, query or url
        args = []
        kwargs = {}

        if endpoint.param_in_path:
            kwargs = path_params

        if endpoint.param_in_body:
            # Remove the parameters already defined in path_params
            for k in list(path_params.keys()):
                del parameters[k]
            lst = list(parameters.values())
            assert len(lst) == 1
            args.append(lst[0])

        if endpoint.param_in_query:
            kwargs.update(parameters)

        result = handler_func(*args, **kwargs)

        if not result:
            e = error_callback(PyMacaronCoreException("Have nothing to send in response"))
            return _responsify(api_spec, e, 500)

        # Did we get the expected response?
        if endpoint.produces_html:
            if type(result) is not tuple:
                e = error_callback(PyMacaronCoreException("Method %s should return %s but returned %s" %
                                                          (endpoint.handler_server, endpoint.produces, type(result))))
                return _responsify(api_spec, e, 500)

            # Return an html page
            return result

        elif endpoint.produces_json:
            if not hasattr(result, '__module__') or not hasattr(result, '__class__'):
                e = error_callback(PyMacaronCoreException("Method %s did not return a class instance but a %s" %
                                                          (endpoint.handler_server, type(result))))
                return _responsify(api_spec, e, 500)

            # If it's already a flask Response, just pass it through.
            # Errors in particular may be either passed back as flask Responses, or
            # raised as exceptions to be caught and formatted by the error_callback
            result_type = result.__module__ + "." + result.__class__.__name__
            if result_type == 'flask.wrappers.Response':
                return result

            # We may have got a pymacaron Error instance, in which case
            # it has a http_reply() method...
            if hasattr(result, 'http_reply'):
                # Let's transform this Error into a flask Response
                log.info("Looks like a pymacaron error instance - calling .http_reply()")
                return result.http_reply()

            # Otherwise, assume no error occured and make a flask Response out of
            # the result.

            # TODO: check that result is an instance of a model expected as response from this endpoint
            result_json = api_spec.model_to_json(result)

            # Send a Flask Response with code 200 and result_json
            r = jsonify(result_json)
            r.status_code = 200
            return r

    handler_wrapper = cross_origin(headers=['Content-Type', 'Authorization'])(handler_wrapper)

    # And encapsulate all in a global decorator, if given one
    if global_decorator:
        handler_wrapper = global_decorator(handler_wrapper)

    return handler_wrapper


Instruction:
How would you implement a function in Python 3 that
returns the ANSI escape sequence to set character formatting.

Response:
def format_escape( foreground=None, background=None, bold=False, faint=False,
    italic=False, underline=False, blink=False, inverted=False ):
    """Returns the ANSI escape sequence to set character formatting.

    foreground
        Foreground colour to use. Accepted types: None, int (xterm
        palette ID), tuple (RGB, RGBA), Colour

    background
        Background colour to use. Accepted types: None, int (xterm
        palette ID), tuple (RGB, RGBA), Colour

    bold
        Enable bold text (default: False)

    faint
        Enable faint text (default: False)

    italic
        Enable italic text (default: False)

    underline
        Enable underlined text (default: False)

    blink
        Enable blinky text (default: False)

    inverted
        Enable inverted text (default: False)
    """
    fg_format = None
    if isinstance( foreground, int ):
        fg_format = ANSI_FORMAT_FOREGROUND_XTERM_CMD.format( foreground )
    else:
        fg_rgba = colour.normalise_rgba( foreground )
        if fg_rgba[3] != 0:
            fg_format = ANSI_FORMAT_FOREGROUND_CMD.format( *fg_rgba[:3] )

    bg_format = None
    if isinstance( background, int ):
        bg_format = ANSI_FORMAT_BACKGROUND_XTERM_CMD.format( background )
    else:
        bg_rgba = colour.normalise_rgba( background )
        if bg_rgba[3] != 0:
            bg_format = ANSI_FORMAT_BACKGROUND_CMD.format( *bg_rgba[:3] )

    colour_format = []
    if fg_format is not None:
        colour_format.append( fg_format )
    if bg_format is not None:
        colour_format.append( bg_format )
    if bold:
        colour_format.append( ANSI_FORMAT_BOLD_CMD )
    if faint:
        colour_format.append( ANSI_FORMAT_FAINT_CMD )
    if italic:
        colour_format.append( ANSI_FORMAT_ITALIC_CMD )
    if underline:
        colour_format.append( ANSI_FORMAT_UNDERLINE_CMD )
    if blink:
        colour_format.append( ANSI_FORMAT_BLINK_CMD )
    if inverted:
        colour_format.append( ANSI_FORMAT_INVERTED_CMD )

    colour_format = ANSI_FORMAT_BASE.format( ';'.join( colour_format ) )
    return colour_format


Instruction:
Can you tell what is the following Python 3 function doing
def format_string( string, foreground=None, background=None, reset=True, bold=False,
    faint=False, italic=False, underline=False, blink=False, inverted=False ):
    """Returns a Unicode string formatted with an ANSI escape sequence.

    string
        String to format

    foreground
        Foreground colour to use. Accepted types: None, int (xterm
        palette ID), tuple (RGB, RGBA), Colour

    background
        Background colour to use. Accepted types: None, int (xterm
        palette ID), tuple (RGB, RGBA), Colour

    reset
        Reset the formatting at the end (default: True)

    bold
        Enable bold text (default: False)

    faint
        Enable faint text (default: False)

    italic
        Enable italic text (default: False)

    underline
        Enable underlined text (default: False)

    blink
        Enable blinky text (default: False)

    inverted
        Enable inverted text (default: False)
    """
    colour_format = format_escape( foreground, background, bold, faint,
                                        italic, underline, blink, inverted )
    reset_format = '' if not reset else ANSI_FORMAT_RESET

    return '{}{}{}'.format( colour_format, string, reset_format )

Response: Returns a Unicode string formatted with an ANSI escape sequence.


Instruction:
Create a Python 3 function for
returning the ANSI escape sequence to render two vertically - stacked pixels as a single monospace character.

Response:
def format_pixels( top, bottom, reset=True, repeat=1 ):
    """Return the ANSI escape sequence to render two vertically-stacked pixels as a
    single monospace character.

    top
        Top colour to use. Accepted types: None, int (xterm
        palette ID), tuple (RGB, RGBA), Colour

    bottom
        Bottom colour to use. Accepted types: None, int (xterm
        palette ID), tuple (RGB, RGBA), Colour

    reset
        Reset the formatting at the end (default: True)

    repeat
        Number of horizontal pixels to render (default: 1)
    """
    top_src = None
    if isinstance( top, int ):
        top_src = top
    else:
        top_rgba = colour.normalise_rgba( top )
        if top_rgba[3] != 0:
            top_src = top_rgba

    bottom_src = None
    if isinstance( bottom, int ):
        bottom_src = bottom
    else:
        bottom_rgba = colour.normalise_rgba( bottom )
        if bottom_rgba[3] != 0:
            bottom_src = bottom_rgba

    # short circuit for empty pixel
    if (top_src is None) and (bottom_src is None):
        return ' '*repeat

    string = '▀'*repeat;
    colour_format = []

    if top_src == bottom_src:
        string = '█'*repeat
    elif (top_src is None) and (bottom_src is not None):
        string = '▄'*repeat

    if (top_src is None) and (bottom_src is not None):
        if isinstance( bottom_src, int ):
            colour_format.append( ANSI_FORMAT_FOREGROUND_XTERM_CMD.format( bottom_src ) )
        else:
            colour_format.append( ANSI_FORMAT_FOREGROUND_CMD.format( *bottom_src[:3] ) )
    else:
        if isinstance( top_src, int ):
            colour_format.append( ANSI_FORMAT_FOREGROUND_XTERM_CMD.format( top_src ) )
        else:
            colour_format.append( ANSI_FORMAT_FOREGROUND_CMD.format( *top_src[:3] ) )

    if top_src is not None and bottom_src is not None and top_src != bottom_src:
        if isinstance( top_src, int ):
            colour_format.append( ANSI_FORMAT_BACKGROUND_XTERM_CMD.format( bottom_src ) )
        else:
            colour_format.append( ANSI_FORMAT_BACKGROUND_CMD.format( *bottom_src[:3] ) )

    colour_format = ANSI_FORMAT_BASE.format( ';'.join( colour_format ) )
    reset_format = '' if not reset else ANSI_FORMAT_RESET

    return '{}{}{}'.format( colour_format, string, reset_format )


Instruction:
Can you generate the documentation for the following Python 3 function
def format_image_iter( data_fetch, x_start=0, y_start=0, width=32, height=32, frame=0, columns=1, downsample=1 ):
    frames = []
    try:
        frame_iter = iter( frame )
        frames = [f for f in frame_iter]
    except TypeError:
        frames = [frame]

    rows = math.ceil( len( frames )/columns )
    for r in range( rows ):
        for y in range( 0, height, 2*downsample ):
            result = []
            for c in range( min( (len( frames )-r*columns), columns ) ):
                row = []
                for x in range( 0, width, downsample ):
                    fr = frames[r*columns + c]
                    c1 = data_fetch( x_start+x, y_start+y, fr )
                    c2 = data_fetch( x_start+x, y_start+y+downsample, fr )
                    row.append( (c1, c2) )
                prev_pixel = None
                pointer = 0
                while pointer < len( row ):
                    start = pointer
                    pixel = row[pointer]
                    while pointer < len( row ) and (row[pointer] == pixel):
                        pointer += 1
                    result.append( format_pixels( pixel[0], pixel[1], repeat=pointer-start ) )
            yield ''.join( result )
    return

Response: Return ANSI escape sequence to render a bitmap image.


Instruction:
Write a Python 3 script for
writing a Python object into a byte array using the field definition.

Response:
def update_buffer_with_value( self, value, buffer, parent=None ):
        """Write a Python object into a byte array, using the field definition.

        value
            Input Python object to process.

        buffer
            Output byte array to encode value into.

        parent
            Parent block object where this Field is defined. Used for e.g.
            evaluating Refs.
        """
        assert common.is_bytes( buffer )
        self.validate( value, parent )
        return


Instruction:
Given the following Python 3 function, write the documentation
def get_end_offset( self, value, parent=None, index=None ):
        return self.get_start_offset( value, parent, index ) + self.get_size( value, parent, index )

Response: Returns the end offset of the field s data. Used for chainloading.


Instruction:
Can you tell what is the following Python 3 function doing
def nonalpha_split(string):
    '''Split 'string' along any punctuation or whitespace.'''
    return re.findall(r'[%s]+|[^%s]+' % (A, A), string, flags=FLAGS)

Response: Split string along any punctuation or whitespace.


Instruction:
Make a summary of the following Python 3 code
def syllable_split(string):
    '''Split 'string' into (stressed) syllables and punctuation/whitespace.'''
    p = r'\'[%s]+|`[%s]+|[%s]+|[^%s\'`\.]+|[^\.]{1}' % (A, A, A, A)
    return re.findall(p, string, flags=FLAGS)

Response: Split string into ( stressed ) syllables and punctuation and whitespace.


Instruction:
Make a summary of the following Python 3 code
def extract_words(string):
    '''Extract all alphabetic syllabified forms from 'string'.'''
    return re.findall(r'[%s]+[%s\.]*[%s]+' % (A, A, A), string, flags=FLAGS)

Response: Extract all alphabetic syllabified forms from string.


Instruction:
Write a Python 3 function for
returning a thread that emits state_changed between each sub - request.

Response:
def thread_with_callback(on_error, on_done, requete_with_callback):
    """
    Return a thread emiting `state_changed` between each sub-requests.

    :param on_error: callback str -> None
    :param on_done: callback object -> None
    :param requete_with_callback: Job to execute. monitor_callable -> None
    :return: Non started thread
    """

    class C(THREAD):

        error = SIGNAL(str)
        done = SIGNAL(object)
        state_changed = SIGNAL(int, int)

        def __del__(self):
            self.wait()

        def run(self):
            try:
                r = requete_with_callback(self.state_changed.emit)
            except (ConnexionError, StructureError) as e:
                self.error.emit(str(e))
            else:
                self.done.emit(r)

    th = C()
    th.error.connect(on_error)
    th.done.connect(on_done)
    return th


Instruction:
Write a Python 3 function that can
use to crypt and decrypt data before saving locally.

Response:
def protege_data(datas_str, sens):
    """
    Used to crypt/decrypt data before saving locally.
    Override if securit is needed.
    bytes -> str when decrypting
    str -> bytes when crypting

    :param datas_str: When crypting, str. when decrypting bytes
    :param sens: True to crypt, False to decrypt
    """
    return bytes(datas_str, encoding="utf8") if sens else str(datas_str, encoding="utf8")


Instruction:
Given the following Python 3 function, write the documentation
def build_parser(parser: argparse.ArgumentParser) -> None:
    parser.add_argument(
        '--delimiter',
        help='a delimiter for the samples (teeth) in the key',
        default=' ',
    )
    parser.add_argument(
        '--encoding',
        help='the encoding of the population file',
        default='utf-8',
    )
    parser.add_argument(
        '--nsamples', '-n',
        help='the number of random samples to take',
        type=int,
        default=6,
        dest='nteeth',
    )
    parser.add_argument(
        '--population', '-p',
        help='{0}, or a path to a file of line-delimited items'.format(
            ', '.join(POPULATIONS.keys()),
        ),
        default='/usr/share/dict/words',
    )
    parser.add_argument(
        '--stats',
        help='show statistics for the key',
        default=False,
        action='store_true',
    )
    parser.add_argument(
        '--version',
        action='version',
        version='%(prog)s {0}'.format(__version__),
    )

Response: Build a parser for CLI arguments and options.


Instruction:
Write a Python 3 function for
creating a parser for CLI arguments and options.

Response:
def default_parser() -> argparse.ArgumentParser:
    """Create a parser for CLI arguments and options."""
    parser = argparse.ArgumentParser(
        prog=CONSOLE_SCRIPT,
        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
    )
    build_parser(parser)
    return parser


Instruction:
Can you tell what is the following Python 3 function doing
def key(
        seq: Sequence,
        tooth: Callable[[Sequence], str] = (
            lambda seq: str(random.SystemRandom().choice(seq)).strip()
        ),
        nteeth: int = 6,
        delimiter: str = ' ',
) -> str:
    """Concatenate strings generated by the tooth function."""
    return delimiter.join(tooth(seq) for _ in range(nteeth))

Response: Return a random string from the sequence seq.


Instruction:
Can you write a function in Python 3 where it
adds a firewall rule to the firewalld service

Response:
def add_firewalld_service(service, permanent=True):
    """ adds a firewall rule """
    yum_install(packages=['firewalld'])

    with settings(hide('warnings', 'running', 'stdout', 'stderr'),
                  warn_only=True, capture=True):
        p = ''
        if permanent:
            p = '--permanent'
        sudo('firewall-cmd --add-service %s %s' % (service, p))
        sudo('systemctl reload firewalld')


Instruction:
Can you tell what is the following Python 3 function doing
def add_firewalld_port(port, permanent=True):

    yum_install(packages=['firewalld'])

    log_green('adding a new fw rule: %s' % port)
    with settings(hide('warnings', 'running', 'stdout', 'stderr'),
                  warn_only=True, capture=True):
        p = ''
        if permanent:
            p = '--permanent'
        sudo('firewall-cmd --add-port %s %s' % (port, p))
        sudo('systemctl restart firewalld')

Response: Adds a firewall rule to the firewalld system


Instruction:
Write a Python 3 script to
add a new repository file for apt

Response:
def apt_add_repository_from_apt_string(apt_string, apt_file):
    """ adds a new repository file for apt """

    apt_file_path = '/etc/apt/sources.list.d/%s' % apt_file

    if not file_contains(apt_file_path, apt_string.lower(), use_sudo=True):
        file_append(apt_file_path, apt_string.lower(), use_sudo=True)

        with hide('running', 'stdout'):
            sudo("DEBIAN_FRONTEND=noninteractive apt-get update")


Instruction:
Write a Python 3 script to
return the current cpu archictecture

Response:
def arch():
    """ returns the current cpu archictecture """
    with settings(hide('warnings', 'running', 'stdout', 'stderr'),
                  warn_only=True, capture=True):
        result = sudo('rpm -E %dist').strip()
    return result


Instruction:
How would you code a function in Python 3 to
disable rDNS lookups on the given binary node.

Response:
def disable_openssh_rdns(distribution):
    """
    Set 'UseDNS no' in openssh config to disable rDNS lookups

    On each request for a new channel openssh defaults to an
    rDNS lookup on the client IP. This can be slow, if it fails
    for instance, adding 10s of overhead to every request
    for a new channel (not connection). This can add a lot of
    time to a process that opens lots of channels (e.g. running
    several commands via fabric.)

    This function will disable rDNS lookups in the openssh
    config and reload ssh to adjust the running instance.

    :param bytes distribution: the name of the distribution
        running on the node.
    """
    log_green('Disabling openssh reverse dns lookups')
    openssh_config_file = '/etc/ssh/sshd_config'
    dns_config = 'UseDNS no'
    if not file_contains(openssh_config_file, dns_config, use_sudo=True):
        file_append(openssh_config_file, dns_config, use_sudo=True)
        service_name = 'sshd'
        if 'ubuntu' in distribution:
            service_name = 'ssh'
        sudo('service {} reload'.format(service_name))


Instruction:
How would you implement a function in Python 3 that
connects to AWS EC2

Response:
def connect_to_ec2(region, access_key_id, secret_access_key):
    """ returns a connection object to AWS EC2  """
    conn = boto.ec2.connect_to_region(region,
                                      aws_access_key_id=access_key_id,
                                      aws_secret_access_key=secret_access_key)
    return conn


Instruction:
Create a Python 3 function for
returning a connection object to Rackspace

Response:
def connect_to_rackspace(region,
                         access_key_id,
                         secret_access_key):
    """ returns a connection object to Rackspace  """
    pyrax.set_setting('identity_type', 'rackspace')
    pyrax.set_default_region(region)
    pyrax.set_credentials(access_key_id, secret_access_key)
    nova = pyrax.connect_to_cloudservers(region=region)
    return nova


Instruction:
Can you tell what is the following Python 3 function doing
def create_gce_image(zone,
                     project,
                     instance_name,
                     name,
                     description):
    """
    Shuts down the instance and creates and image from the disk.

    Assumes that the disk name is the same as the instance_name (this is the
    default behavior for boot disks on GCE).
    """

    disk_name = instance_name
    try:
        down_gce(instance_name=instance_name, project=project, zone=zone)
    except HttpError as e:
        if e.resp.status == 404:
            log_yellow("the instance {} is already down".format(instance_name))
        else:
            raise e

    body = {
        "rawDisk": {},
        "name": name,
        "sourceDisk": "projects/{}/zones/{}/disks/{}".format(
            project, zone, disk_name
        ),
        "description": description
    }
    compute = _get_gce_compute()
    gce_wait_until_done(
        compute.images().insert(project=project, body=body).execute()
    )
    return name

Response: Creates a GCE image from the disk.


Instruction:
How would you explain what the following Python 3 function does
def create_image(cloud, **kwargs):
    if cloud == 'ec2':
        return create_ami(**kwargs)

    if cloud == 'rackspace':
        return create_rackspace_image(**kwargs)

    if cloud == 'gce':
        return create_gce_image(**kwargs)

Response: proxy call for ec2 rackspace create ami backend functions


Instruction:
Given the following Python 3 function, write the documentation
def create_server(cloud, **kwargs):
    if cloud == 'ec2':
        _create_server_ec2(**kwargs)
    elif cloud == 'rackspace':
        _create_server_rackspace(**kwargs)
    elif cloud == 'gce':
        _create_server_gce(**kwargs)
    else:
        raise ValueError("Unknown cloud type: {}".format(cloud))

Response: Create a new instance of the server.


Instruction:
Can you generate the documentation for the following Python 3 function
def gce_wait_until_done(operation):
    operation_name = operation['name']
    if 'zone' in operation:
        zone_url_parts = operation['zone'].split('/')
        project = zone_url_parts[-3]
        zone = zone_url_parts[-1]

        def get_zone_operation():
            return _get_gce_compute().zoneOperations().get(
                project=project,
                zone=zone,
                operation=operation_name
            )
        update = get_zone_operation
    else:
        project = operation['selfLink'].split('/')[-4]

        def get_global_operation():
            return _get_gce_compute().globalOperations().get(
                project=project,
                operation=operation_name
            )
        update = get_global_operation
    done = False
    latest_operation = None
    start = time()
    timeout = 5*60  # seconds
    while not done:
        latest_operation = update().execute()
        log_yellow("waiting for operation")
        if (latest_operation['status'] == 'DONE' or
                time() - start > timeout):
            done = True
        else:
            sleep(10)
            print "waiting for operation"
    return latest_operation

Response: This function will wait until the operation completes.


Instruction:
How would you explain what the following Python 3 function does
def startup_gce_instance(instance_name, project, zone, username, machine_type,
                         image, public_key, disk_name=None):
    """
    For now, jclouds is broken for GCE and we will have static slaves
    in Jenkins.  Use this to boot them.
    """
    log_green("Started...")
    log_yellow("...Creating GCE Jenkins Slave Instance...")
    instance_config = get_gce_instance_config(
        instance_name, project, zone, machine_type, image,
        username, public_key, disk_name
    )
    operation = _get_gce_compute().instances().insert(
        project=project,
        zone=zone,
        body=instance_config
    ).execute()
    result = gce_wait_until_done(operation)
    if not result:
        raise RuntimeError("Creation of VM timed out or returned no result")
    log_green("Instance has booted")

Response: Create a new GCE Slave Instance.


Instruction:
Can you create a Python 3 function that
creates a new EC2 server and return a new EC2 instance

Response:
def _create_server_ec2(region,
                       access_key_id,
                       secret_access_key,
                       disk_name,
                       disk_size,
                       ami,
                       key_pair,
                       instance_type,
                       username,
                       tags={},
                       security_groups=None):
    """
    Creates EC2 Instance and saves it state in a local json file
    """
    conn = connect_to_ec2(region, access_key_id, secret_access_key)

    log_green("Started...")
    log_yellow("...Creating EC2 instance...")

    # we need a larger boot device to store our cached images
    ebs_volume = EBSBlockDeviceType()
    ebs_volume.size = disk_size
    bdm = BlockDeviceMapping()
    bdm[disk_name] = ebs_volume

    # get an ec2 ami image object with our choosen ami
    image = conn.get_all_images(ami)[0]
    # start a new instance
    reservation = image.run(1, 1,
                            key_name=key_pair,
                            security_groups=security_groups,
                            block_device_map=bdm,
                            instance_type=instance_type)

    # and get our instance_id
    instance = reservation.instances[0]

    #  and loop and wait until ssh is available
    while instance.state == u'pending':
        log_yellow("Instance state: %s" % instance.state)
        sleep(10)
        instance.update()
    log_green("Instance state: %s" % instance.state)
    wait_for_ssh(instance.public_dns_name)

    # update the EBS volumes to be deleted on instance termination
    for dev, bd in instance.block_device_mapping.items():
        instance.modify_attribute('BlockDeviceMapping',
                                  ["%s=%d" % (dev, 1)])

    # add a tag to our instance
    conn.create_tags([instance.id], tags)

    log_green("Public dns: %s" % instance.public_dns_name)
    # finally save the details or our new instance into the local state file
    save_ec2_state_locally(instance_id=instance.id,
                           region=region,
                           username=username,
                           access_key_id=access_key_id,
                           secret_access_key=secret_access_key)


Instruction:
Write a Python 3 script to
create a new server in Rackspace and save it locally.

Response:
def _create_server_rackspace(region,
                             access_key_id,
                             secret_access_key,
                             disk_name,
                             disk_size,
                             ami,
                             key_pair,
                             instance_type,
                             username,
                             instance_name,
                             tags={},
                             security_groups=None):
    """
    Creates Rackspace Instance and saves it state in a local json file
    """
    nova = connect_to_rackspace(region, access_key_id, secret_access_key)
    log_yellow("Creating Rackspace instance...")

    flavor = nova.flavors.find(name=instance_type)
    image = nova.images.find(name=ami)

    server = nova.servers.create(name=instance_name,
                                 flavor=flavor.id,
                                 image=image.id,
                                 region=region,
                                 availability_zone=region,
                                 key_name=key_pair)

    while server.status == 'BUILD':
        log_yellow("Waiting for build to finish...")
        sleep(5)
        server = nova.servers.get(server.id)

    # check for errors
    if server.status != 'ACTIVE':
        log_red("Error creating rackspace instance")
        exit(1)

    # the server was assigned IPv4 and IPv6 addresses, locate the IPv4 address
    ip_address = server.accessIPv4

    if ip_address is None:
        log_red('No IP address assigned')
        exit(1)

    wait_for_ssh(ip_address)
    log_green('New server with IP address {0}.'.format(ip_address))
    # finally save the details or our new instance into the local state file
    save_rackspace_state_locally(instance_id=server.id,
                                 region=region,
                                 username=username,
                                 access_key_id=access_key_id,
                                 secret_access_key=secret_access_key)


Instruction:
Make a summary of the following Python 3 code
def destroy_ebs_volume(region, volume_id, access_key_id, secret_access_key):
    conn = connect_to_ec2(region, access_key_id, secret_access_key)

    if ebs_volume_exists(region, volume_id, access_key_id, secret_access_key):
        log_yellow('destroying EBS volume ...')
        conn.delete_volume(volume_id)

Response: destroys an EBS volume


Instruction:
Can you write a function in Python 3 where it
deletes the rackspace instance.

Response:
def destroy_rackspace(region, instance_id, access_key_id, secret_access_key):
    """ terminates the instance """
    nova = connect_to_rackspace(region,
                                access_key_id,
                                secret_access_key)

    server = nova.servers.get(instance_id)
    log_yellow('deleting rackspace instance ...')
    server.delete()

    # wait for server to be deleted
    try:
        while True:
            server = nova.servers.get(server.id)
            log_yellow('waiting for deletion ...')
            sleep(5)
    except:
        pass
    log_green('The server has been deleted')
    os.unlink('data.json')


Instruction:
Given the following Python 3 function, write the documentation
def ebs_volume_exists(region, volume_id, access_key_id, secret_access_key):
    conn = connect_to_ec2(region, access_key_id, secret_access_key)
    for vol in conn.get_all_volumes():
        if vol.id == volume_id:
            return True

Response: Checks if an ebs volume exists


Instruction:
Can you generate the documentation for the following Python 3 function
def enable_marathon_basic_authentication(principal, password):
    upstart_file = '/etc/init/marathon.conf'
    with hide('running', 'stdout'):
        sudo('echo -n "{}" > /etc/marathon-mesos.credentials'.format(password))
    boot_args = ' '.join(['exec',
                          '/usr/bin/marathon',
                          '--http_credentials',
                          '"{}:{}"'.format(principal, password),
                          '--mesos_authentication_principal',
                          principal,
                          '--mesos_authentication_secret_file',
                          '/etc/marathon-mesos.credentials'])

    # check if the init conf file contains the exact user and password
    if not file_contains(upstart_file, boot_args, use_sudo=True):
        sed(upstart_file, 'exec /usr/bin/marathon.*', boot_args, use_sudo=True)
        file_attribs(upstart_file, mode=700, sudo=True)
        restart_service('marathon')

Response: configure marathon to start with basic authentication


Instruction:
Explain what the following Python 3 code does
def enable_mesos_basic_authentication(principal, password):
    restart = False
    secrets_file = '/etc/mesos/secrets'
    secrets_entry = '%s %s' % (principal, password)
    if not file_contains(filename=secrets_file,
                         text=secrets_entry, use_sudo=True):
        file_append(filename=secrets_file, text=secrets_entry, use_sudo=True)
        file_attribs(secrets_file, mode=700, sudo=True)
        restart = True

    # set new startup parameters for mesos-master
    with quiet():
        if secrets_file not in sudo('cat /etc/mesos-master/credentials'):
            sudo('echo %s > /etc/mesos-master/credentials' % secrets_file)
            restart = True

        if not exists('/etc/mesos-master/\?authenticate', use_sudo=True):
            sudo('touch /etc/mesos-master/\?authenticate')
            file_attribs('/etc/mesos-master/\?authenticate',
                         mode=700,
                         sudo=True)
            restart = True

    if restart:
        restart_service('mesos-master')

Response: enables and adds a new authorized principal


Instruction:
Can you generate a brief explanation for the following Python 3 code
def file_attribs(location, mode=None, owner=None, group=None, sudo=False):
    return dir_attribs(location, mode, owner, group, False, sudo)

Response: Updates the mode owner group for the remote file at the given location.


Instruction:
Can you generate the documentation for the following Python 3 function
def get_ec2_info(instance_id,
                 region,
                 access_key_id,
                 secret_access_key,
                 username):
    """ queries EC2 for details about a particular instance_id
    """
    conn = connect_to_ec2(region, access_key_id, secret_access_key)
    instance = conn.get_only_instances(
        filters={'instance_id': instance_id}
        )[0]

    data = {}
    data['public_dns_name'] = instance.public_dns_name
    data['id'] = instance.id
    data['instance_type'] = instance.instance_type
    data['ip_address'] = instance.ip_address
    data['architecture'] = instance.architecture
    data['state'] = instance.state
    data['region'] = region
    data['cloud_type'] = 'ec2'
    data['username'] = username

    # find out the distribution running on the instance
    if username is not None:
        wait_for_ssh(data['ip_address'])
        with settings(host_string=username + '@' + data['ip_address']):
            data['distribution'] = linux_distribution(username,
                                                      data['ip_address'])
            data['os_release'] = os_release(username,
                                            data['ip_address'])

    try:
        volume = conn.get_all_volumes(
            filters={'attachment.instance-id': instance.id})[0].id
        data['volume'] = volume
    except:
        data['volume'] = ''
    return data

Response: queries EC2 for details about a particular instance_id


Instruction:
Create a Python 3 function for
returning an ipaddress for a rackspace instance

Response:
def get_ip_address_from_rackspace_server(server_id):
    """
    returns an ipaddress for a rackspace instance
    """
    nova = connect_to_rackspace()
    server = nova.servers.get(server_id)
    # the server was assigned IPv4 and IPv6 addresses, locate the IPv4 address
    ip_address = None
    for network in server.networks['public']:
        if re.match('\d+\.\d+\.\d+\.\d+', network):
            ip_address = network
            break

    # find out if we have an ip address
    if ip_address is None:
        log_red('No IP address assigned')
        return False
    else:
        return ip_address


Instruction:
Can you write a function in Python 3 where it
queries Rackspace for details about a particular server id and region

Response:
def get_rackspace_info(server_id,
                       region,
                       access_key_id,
                       secret_access_key,
                       username):
    """ queries Rackspace for details about a particular server id
    """
    nova = connect_to_rackspace(region, access_key_id, secret_access_key)
    server = nova.servers.get(server_id)

    data = {}
    data['id'] = server.id
    # this needs to be tackled
    data['ip_address'] = server.accessIPv4
    data['state'] = server.status
    data['region'] = region
    data['cloud_type'] = 'rackspace'
    data['username'] = username

    # find out the distribution running on the instance
    if username is not None:
        wait_for_ssh(data['ip_address'])
        with settings(host_string=username + '@' + data['ip_address']):
            data['distribution'] = linux_distribution(username,
                                                      data['ip_address'])
            data['os_release'] = os_release(username,
                                            data['ip_address'])

    data['volume'] = ''
    return data


Instruction:
Can you write a function in Python 3 where it
installs mesos on a single node

Response:
def install_mesos_single_box_mode(distribution):
    """ install mesos (all of it) on a single node"""

    if 'ubuntu' in distribution:
        log_green('adding mesosphere apt-key')
        apt_add_key(keyid='E56151BF')

        os = lsb_release()
        apt_string = 'deb http://repos.mesosphere.io/%s %s main' % (
            os['DISTRIB_ID'], os['DISTRIB_CODENAME'])

        log_green('adding mesosphere apt repository')
        apt_add_repository_from_apt_string(apt_string, 'mesosphere.list')

        log_green('installing ubuntu development tools')
        install_ubuntu_development_tools()

        install_oracle_java(distribution, '8')

        log_green('installing mesos and marathon')
        apt_install(packages=['mesos', 'marathon'])

        if not file_contains('/etc/default/mesos-master',
                             'MESOS_QUORUM=1', use_sudo=True):
            file_append('/etc/default/mesos-master',
                        'MESOS_QUORUM=1', use_sudo=True)

            log_green('restarting services...')
            for svc in ['zookeeper', 'mesos-master', 'mesos-slave', 'marathon']:
                restart_service(svc)

        if not file_contains('/etc/mesos-slave/work_dir',
                             '/data/mesos', use_sudo=True):
            file_append('/etc/mesos-slave/work_dir',
                        '/data/mesos', use_sudo=True)

            log_green('restarting services...')
            for svc in ['mesos-slave']:
                restart_service(svc)

        log_green('enabling nginx autoindex on /...')

        with quiet():
            cmd = 'cat /etc/nginx/sites-available/default'
            contents = sudo(cmd).replace('\n', ' ').replace('\r', '')

        if not bool(re.search('.*#*location \/ {.*autoindex on;.*', contents)):
            insert_line_in_file_after_regex(
                path='/etc/nginx/sites-available/default',
                line='                autoindex on;',
                after_regex='^[^#]*location \/ {',
                use_sudo=True)
            log_green('restarting nginx')
            restart_service('nginx')


Instruction:
Can you tell what is the following Python 3 function doing
def insert_line_in_file_after_regex(path, line, after_regex, use_sudo=False):

    tmpfile = str(uuid.uuid4())
    get_file(path, tmpfile, use_sudo=use_sudo)
    with open(tmpfile) as f:
        original = f.read()

    if line not in original:
        outfile = str(uuid.uuid4())
        with open(outfile, 'w') as output:
            for l in original.split('\n'):
                output.write(l + '\n')
                if re.match(after_regex, l) is not None:
                    output.write(line + '\n')

        upload_file(local_path=outfile,
                    remote_path=path,
                    use_sudo=use_sudo)
        os.unlink(outfile)
    os.unlink(tmpfile)

Response: inserts a line in the middle of a file


Instruction:
Given the following Python 3 function, write the documentation
def install_python_module(name):

    with settings(hide('warnings', 'running', 'stdout', 'stderr'),
                  warn_only=False, capture=True):
        run('pip --quiet install %s' % name)

Response: installs a python module


Instruction:
How would you explain what the following Python 3 function does
def install_python_module_locally(name):
    with settings(hide('warnings', 'running', 'stdout', 'stderr'),
                  warn_only=False, capture=True):
        local('pip --quiet install %s' % name)

Response: installs a python module locally


Instruction:
Can you generate a brief explanation for the following Python 3 code
def install_system_gem(gem):
    with settings(hide('warnings', 'running', 'stdout', 'stderr'),
                  warn_only=False, capture=True):
        sudo("gem install %s --no-rdoc --no-ri" % gem)

Response: install a particular gem


Instruction:
Can you tell what is the following Python 3 function doing
def is_vagrant_plugin_installed(plugin, use_sudo=False):

    cmd = 'vagrant plugin list'

    if use_sudo:
        results = sudo(cmd)
    else:
        results = run(cmd)

    installed_plugins = []
    for line in results:
        plugin = re.search('^(\S.*) \((.*)\)$', line)
        installed_plugins.append({'name': plugin.group(0),
                                  'version': plugin.group(1)})
        return installed_plugins

Response: checks if vagrant plugin is installed


Instruction:
Given the following Python 3 function, write the documentation
def is_deb_package_installed(pkg):

    with settings(hide('warnings', 'running', 'stdout', 'stderr'),
                  warn_only=True, capture=True):

        result = sudo('dpkg-query -l "%s" | grep -q ^.i' % pkg)
        return not bool(result.return_code)

Response: checks if a particular deb package is installed


Instruction:
Can you generate the documentation for the following Python 3 function
def is_ssh_available(host, port=22):
    s = socket.socket()
    try:
        s.connect((host, port))
        return True
    except:
        return False

Response: checks if ssh port is open


Instruction:
Write a Python 3 script to
return the os - release for a user

Response:
def os_release(username, ip_address):
    """ returns /etc/os-release in a dictionary """
    with settings(hide('warnings', 'running', 'stdout', 'stderr'),
                  warn_only=True, capture=True):

        _os_release = {}
        with settings(host_string=username + '@' + ip_address):
            data = run('cat /etc/os-release')
        for line in data.split('\n'):
            if not line:
                continue
            parts = line.split('=')
            if len(parts) == 2:
                _os_release[parts[0]] = parts[1].strip('\n\r"')

        return _os_release


Instruction:
Explain what the following Python 3 code does
def load_state_from_disk():
    if is_there_state():
        with open('data.json', 'r') as f:
            data = json.load(f)
        return data
    else:
        return False

Response: loads the state from a local data. json file


Instruction:
Make a summary of the following Python 3 code
def print_ec2_info(region,
                   instance_id,
                   access_key_id,
                   secret_access_key,
                   username):
    """ outputs information about our EC2 instance """
    data = get_ec2_info(instance_id=instance_id,
                        region=region,
                        access_key_id=access_key_id,
                        secret_access_key=secret_access_key,
                        username=username)

    log_green("region: %s" % data['region'])
    log_green("Instance_type: %s" % data['instance_type'])
    log_green("Instance state: %s" % data['state'])
    log_green("Public dns: %s" % data['public_dns_name'])
    log_green("Ip address: %s" % data['ip_address'])
    log_green("volume: %s" % data['volume'])
    log_green("user: %s" % data['username'])
    log_green("ssh -i %s %s@%s" % (env.key_filename,
                                   username,
                                   data['ip_address']))

Response: Prints info about our EC2 instance


Instruction:
Can you tell what is the following Python 3 function doing
def print_gce_info(zone, project, instance_name, data):
    try:
        instance_info = _get_gce_compute().instances().get(
            project=project,
            zone=zone,
            instance=instance_name
        ).execute()
        log_yellow(pformat(instance_info))
        log_green("Instance state: %s" % instance_info['status'])
        log_green("Ip address: %s" % data['ip_address'])
    except HttpError as e:
        if e.resp.status != 404:
            raise e
        log_yellow("Instance state: DOWN")
    log_green("project: %s" % project)
    log_green("zone: %s" % zone)
    log_green("disk_name: %s" % instance_name)
    log_green("user: %s" % data['username'])
    log_green("ssh -i %s %s@%s" % (env.key_filename,
                                   data['username'],
                                   data['ip_address']))

Response: Prints out information about our Rackspace instance


Instruction:
How would you code a function in Python 3 to
print out information about our Rackspace instance

Response:
def print_rackspace_info(region,
                         instance_id,
                         access_key_id,
                         secret_access_key,
                         username):
    """ outputs information about our Rackspace instance """
    data = get_rackspace_info(server_id=instance_id,
                              region=region,
                              access_key_id=access_key_id,
                              secret_access_key=secret_access_key,
                              username=username)

    log_green("region: %s" % data['region'])
    log_green("Instance state: %s" % data['state'])
    log_green("Ip address: %s" % data['ip_address'])
    log_green("volume: %s" % data['volume'])
    log_green("user: %s" % data['username'])
    log_green("ssh -i %s %s@%s" % (env.key_filename,
                                   username,
                                   data['ip_address']))


Instruction:
Can you tell what is the following Python 3 function doing
def rsync():
    log_green('syncing code to remote box...')
    data = load_state_from_disk()
    if 'SOURCE_PATH' in os.environ:
        with lcd(os.environ['SOURCE_PATH']):
            local("rsync  -a "
                  "--info=progress2 "
                  "--exclude .git "
                  "--exclude .tox "
                  "--exclude .vagrant "
                  "--exclude venv "
                  ". "
                  "-e 'ssh -C -i " + env.ec2_key_filename + "' "
                  "%s@%s:" % (env.user, data['ip_address']))
    else:
        print('please export SOURCE_PATH before running rsync')
        exit(1)

Response: syncs the source code to the remote box


Instruction:
Explain what the following Python 3 code does
def save_ec2_state_locally(instance_id,
                           region,
                           username,
                           access_key_id,
                           secret_access_key):
    """ queries EC2 for details about a particular instance_id and
        stores those details locally
    """
    # retrieve the IP information from the instance
    data = get_ec2_info(instance_id,
                        region,
                        access_key_id,
                        secret_access_key,
                        username)
    return _save_state_locally(data)

Response: Save the state of the EC2 instance in the local machine.


Instruction:
Write a Python 3 script for
opening a ssh shell to the host

Response:
def ssh_session(key_filename,
                username,
                ip_address,
                *cli):
    """ opens a ssh shell to the host """
    local('ssh -t -i %s %s@%s %s' % (key_filename,
                                     username,
                                     ip_address,
                                     "".join(chain.from_iterable(cli))))


Instruction:
Implement a Python 3 function for
booting an ec2 instance and update the ec2 state file

Response:
def up_ec2(region,
           access_key_id,
           secret_access_key,
           instance_id,
           username):
    """ boots an existing ec2_instance """

    conn = connect_to_ec2(region, access_key_id, secret_access_key)
    # boot the ec2 instance
    instance = conn.start_instances(instance_ids=instance_id)[0]
    while instance.state != "running":
        log_yellow("Instance state: %s" % instance.state)
        sleep(10)
        instance.update()
    # the ip_address has changed so we need to get the latest data from ec2
    data = get_ec2_info(instance_id=instance_id,
                        region=region,
                        access_key_id=access_key_id,
                        secret_access_key=secret_access_key,
                        username=username)
    # and make sure we don't return until the instance is fully up
    wait_for_ssh(data['ip_address'])
    # lets update our local state file with the new ip_address
    save_ec2_state_locally(instance_id=instance_id,
                           region=region,
                           username=username,
                           access_key_id=access_key_id,
                           secret_access_key=secret_access_key)

    env.hosts = data['ip_address']

    print_ec2_info(region,
                   instance_id,
                   access_key_id,
                   secret_access_key,
                   username)


Instruction:
Can you write a function in Python 3 where it
waits until the ssh port is available

Response:
def wait_for_ssh(host, port=22, timeout=600):
    """ probes the ssh port and waits until it is available """
    log_yellow('waiting for ssh...')
    for iteration in xrange(1, timeout): #noqa
        sleep(1)
        if is_ssh_available(host, port):
            return True
        else:
            log_yellow('waiting for ssh...')


Instruction:
Given the following Python 3 function, write the documentation
def _get_visuals(user):
    pixmap = SuperUserAvatar() if user["status"] == "admin" else UserAvatar()
    label = user["label"]
    return pixmap, QLabel(label)

Response: Returns a tuple of QPixmap et QLabel


Instruction:
Explain what the following Python 3 code does
def saveDirectory(alias):
	if not settings.platformCompatible():
		return False
	dataFile = open(settings.getDataFile(), "wb")
	currentDirectory = os.path.abspath(".")
	directory = {alias : currentDirectory}
	pickle.dump(directory, dataFile)
	speech.success(alias + " will now link to " + currentDirectory + ".")
	speech.success("Tip: use 'hallie go to " + alias + "' to change to this directory.")

Response: save a directory to a certain alias


Instruction:
Can you implement a function in Python 3 that
goes to a saved directory

Response:
def goToDirectory(alias):
	"""go to a saved directory"""
	if not settings.platformCompatible():
		return False
	data = pickle.load(open(settings.getDataFile(), "rb"))
	try:
		data[alias]
	except KeyError:
		speech.fail("Sorry, it doesn't look like you have saved " + alias + " yet.")
		speech.fail("Go to the directory you'd like to save and type 'hallie save as " + alias + "\'")
		return
	try:
		(output, error) = subprocess.Popen(["osascript", "-e", CHANGE_DIR % (data[alias])], stdout=subprocess.PIPE).communicate()
	except:
		speech.fail("Something seems to have gone wrong. Please report this error to michaelmelchione@gmail.com.")
		return
	speech.success("Successfully navigating to " + data[alias])


Instruction:
How would you explain what the following Python 3 function does
def list(self, filters=None):
        # Add in the page and page_size parameters to the filter, such
        # that our request gets *all* objects in the list. However,
        # don't do this if the user has explicitly included these
        # parameters in the filter.
        if not filters:
            filters = {}

        if "page" not in filters:
            filters["page"] = 1

        if "page_size" not in filters:
            # The below "magic number" is 2^63 - 1, which is the largest
            # number you can hold in a 64 bit integer. The main point
            # here is that we want to get everything in one page (unless
            # otherwise specified, of course).
            filters["page_size"] = 9223372036854775807

        # Form the request URL - first add in the query filters
        query_filter_sub_url = ""

        for idx, filter_param in enumerate(filters):
            # Prepend '?' or '&'
            if idx == 0:
                query_filter_sub_url += "?"
            else:
                query_filter_sub_url += "&"

            # Add in the query filter
            query_filter_sub_url += "{param}={val}".format(
                param=filter_param, val=filters[filter_param]
            )

        # Stitch together all sub-urls
        request_url = (
            self._client.base_api_url + self.list_url + query_filter_sub_url
        )

        # Make the request
        response = self._client.session.get(request_url)

        # Validate that the request was successful
        self.validate_request_success(
            response_text=response.text,
            request_url=request_url,
            status_code=response.status_code,
            expected_status_code=HTTP_200_OK,
        )

        # Return a list of model instances
        return self.response_data_to_model_instances_list(response.json())

Response: This method returns a list of all the container task type related objects in the API.


Instruction:
Make a summary of the following Python 3 code
def get(self, id):
        # Get the object
        request_url = self._client.base_api_url + self.detail_url.format(id=id)

        response = self._client.session.get(request_url)

        # Validate that the request was successful
        self.validate_request_success(
            response_text=response.text,
            request_url=request_url,
            status_code=response.status_code,
            expected_status_code=HTTP_200_OK,
        )

        # Return a model instance
        return self.response_data_to_model_instance(response.json())

Response: Get the object with a given id.


Instruction:
How would you code a function in Python 3 to
validate that a request was successful.

Response:
def validate_request_success(
        response_text, request_url, status_code, expected_status_code
    ):
        """Validates that a request was successful.

        Args:
            response_text (str): The response body of the request.
            request_url (str): The URL the request was made at.
            status_code (int): The status code of the response.
            expected_status_code (int): The expected status code of the
                response.

        Raises:
            :class:`saltant.exceptions.BadHttpRequestError`: The HTTP
                request failed.
        """
        try:
            assert status_code == expected_status_code
        except AssertionError:
            msg = (
                "Request to {url} failed with status {status_code}:\n"
                "The reponse from the request was as follows:\n\n"
                "{content}"
            ).format(
                url=request_url, status_code=status_code, content=response_text
            )
            raise BadHttpRequestError(msg)