return result

      with zipfile.ZipFile(zippath, 'r') as archive:

          for entry in archive.infolist():

              result.append({'archive_id': archive_id,

                             'name': filename,

                             'size': entry.file_size,

          return result

      with tarfile.open(tarpath, 'r') as archive:

          for entry in archive:

              result.append({'archive_id': archive_id,

                             'name': filename,

                             'size': entry.size,

      archiveinfo = {'buildroot_id': buildroot_id}

      archiveinfo['build_id'] = buildinfo['id']

      if metadata_only:

          archiveinfo['filename'] = filename

          archiveinfo['size'] = fileinfo['filesize']

          archiveinfo['checksum'] = fileinfo['checksum']

          archiveinfo['checksum_type'] = koji.CHECKSUM_TYPES[fileinfo['checksum_type']]

          archiveinfo['metadata_only'] = True

      else:

          archiveinfo['filename'] = filename

          archiveinfo['size'] = os.path.getsize(filepath)

          # trust values computed on hub (CG_Importer.prep_outputs)

      be created.

      """

      fname = os.path.basename(filepath)

      final_path = "%s/%s" % (destdir, fname)

      if os.path.exists(final_path):

          raise koji.GenericError("Error importing archive file, %s already exists" % final_path)

      if value is None:

          return value

      try:

      except Exception:

          if errstr is None:

              if desc is None:

          for (cltime, clname, cltext) in zip(fields['changelogtime'], fields['changelogname'],

                                              fields['changelogtext']):

              cldate = datetime.datetime.fromtimestamp(cltime).isoformat(' ')

              if author and author != clname:

                  continue

          return '%s (%s)' % (method, arch)

  CONTROL_CHARS = [chr(i) for i in range(32)]

  def removeNonprintable(value):

      # expects raw-encoded string, not unicode

  def _fix_print(value):

      If value is not valid UTF-8 to begin with, assume it is

      encoded in the 'fallback' charset.

      """

      if not value:

          return six.b('')

      Similar behavior to fixEncoding, but recursive

      """

      if isinstance(value, tuple):

          return tuple([fixEncodingRecurse(x, fallback=fallback, remove_nonprintable=remove_nonprintable) for x in value])

      elif isinstance(value, list):

              k = fixEncodingRecurse(k, fallback=fallback, remove_nonprintable=remove_nonprintable)

              ret[k] = v

          return ret

          if remove_nonprintable:

              return removeNonprintable(value.encode('utf8'))

          else:

              return value.encode('utf8')

          # value is a str, but may be encoded in utf8 or some

          # other non-ascii charset.  Try to verify it's utf8, and if not,

          # decode it using the fallback encoding.

              return removeNonprintable(s)

          else:

              return s

      else:

          return value

              if fd:

                  try:

                      if six.PY3:

                      else:

                          os.write(fd, msg)

                      os.close(fd)

          self.assertEqual(recipients, ["user@example.com"])

          fn = os.path.join(os.path.dirname(__file__), 'data/calls', 'build_notif_1', 'message.txt')

          with open(fn, 'rb') as fp:

          self.assertEqual(message, msg_expect)

      simple_values = [

          # [ value, fixed ]

      ]

      def test_fixEncoding(self):

          """Test the fixEncoding function"""

          for a, b in self.simple_values:

              self.assertEqual(koji.fixEncoding(b), b)

          """Test the _fix_print function"""

          for a, b in self.simple_values:

          self.assertEqual(actual, expected)

      complex_values = [

          [None, None],

          [[], []],

          [{u'a': 'a' , 'b' : {'c': u'c\x00'}},

          # iso8859-15 fallback

      ]

      nonprint = [

      ]

      def test_fixEncodingRecurse(self):

          """Test the fixEncodingRecurse function"""

          for a, b in self.simple_values:

              self.assertEqual(koji.fixEncoding(a), b)

          for a, b in self.complex_values:

          return value

      value = koji.fixEncoding(value)

      return value.replace('&', '&').\

             replace('<', '&lt;').\

             replace('>', '>')