Maintainer: Guido Günther <agx@sigxcpu.org>
Build-Depends:
bash-completion,
+ dh-python,
debhelper (>= 9~),
docbook-utils,
gtk-doc-tools,
openjade,
perl,
- python (>> 2.6.6-3~),
+ python3,
python-epydoc | pydoctor | python-pydoctor,
- python-nose,
- python-pkg-resources,
- python-setuptools,
+ python3-nose,
+ python3-pkg-resources,
+ python3-setuptools,
sgml2x,
librpm-tizen,
# For rpm (epydoc)
- python-rpm
+ python3-rpm
Standards-Version: 3.9.4
Vcs-Git: git://honk.sigxcpu.org/git/git-buildpackage.git
Vcs-Browser: https://honk.sigxcpu.org/gitweb/?p=git-buildpackage.git
Package: git-buildpackage-common
Architecture: all
-Depends: ${python:Depends},
+Depends: ${python3:Depends},
${shlibs:Depends},
${misc:Depends},
git (>= 1:1.7.9.1-1~),
man-db,
- python-pkg-resources,
+ python3-pkg-resources,
#unittest need
zipmerge
Recommends: pristine-tar (>= 0.5)
Package: git-buildpackage
Architecture: all
-Depends: ${python:Depends},
+Depends: ${python3:Depends},
${shlibs:Depends},
${misc:Depends},
devscripts,
Package: git-buildpackage-rpm
Architecture: all
-Depends: ${python:Depends},
+Depends: ${python3:Depends},
${shlibs:Depends},
${misc:Depends},
python-rpm,
Package: git-buildpackage-bb
Architecture: all
-Depends: ${python:Depends},
+Depends: ${python3:Depends},
${misc:Depends},
git-buildpackage-common (= ${binary:Version}),
git-buildpackage-rpm (= ${binary:Version}),
-usr/lib/python2.?/dist-packages/gbp/bb/
-usr/lib/python2.?/dist-packages/gbp/scripts/*bb*.py*
+usr/lib/python*/dist-packages/gbp/bb/
+usr/lib/python*/dist-packages/gbp/scripts/*bb*.py*
README
docs/manual-html/
-build/apidocs/
--- /dev/null
+debian/tmp/usr/lib/python3.*/dist-packages/gbp/deb/__pycache__
+debian/tmp/usr/lib/python3.*/dist-packages/gbp/git/__pycache__
+debian/tmp/usr/lib/python3.*/dist-packages/gbp/pkg/__pycache__
+debian/tmp/usr/lib/python3.*/dist-packages/gbp/__pycache__
+debian/tmp/usr/lib/python3.*/dist-packages/gbp/rpm/__pycache__
+debian/tmp/usr/lib/python3.*/dist-packages/gbp/scripts/common/__pycache__
+debian/tmp/usr/lib/python3.*/dist-packages/gbp/scripts/__pycache__
PYCHECKER_ARGS=-boptparse --no-override --no-shadowbuiltin
%:
- dh $@ --with python2
+ dh $@ --with python3 --buildsystem=pybuild
override_dh_auto_test:
ifeq (,$(filter nocheck,$(DEB_BUILD_OPTIONS)))
export GIT_COMMITTER_NAME=$$GIT_AUTHOR_NAME; \
export GIT_COMMITTER_EMAIL=$$GIT_AUTHOR_EMAIL; \
PYTHONPATH=. \
- python setup.py nosetests
+ python3 setup.py nosetests
else
@echo "Checks disabled via DEB_BUILD_OPTIONS"
dh_auto_build
make -C docs
#generate apidocs
- sh gen_apidocs.sh
+ #sh gen_apidocs.sh
override_dh_auto_install:
dh_auto_install
dh_bash-completion
try:
CLIENT = ZeitgeistClient()
except RuntimeError as e:
- print "Unable to connect to Zeitgeist, won't send events. Reason: '%s'" %e
+ print("Unable to connect to Zeitgeist, won't send events. Reason: '%s'" %e)
def get_repo():
else:
sep = ':'
try:
- repo = unicode(uri.rsplit(sep, 1)[1])
+ repo = str(uri.rsplit(sep, 1)[1])
except IndexError: # no known separator
repo = uri
- repo = repo.rsplit(u'.git', 1)[0]
+ repo = repo.rsplit('.git', 1)[0]
return repo, uri
# * branch
# * log summary (git log -1 --format=%s HEAD)
curdir = os.path.abspath(os.curdir).decode(sys.getfilesystemencoding())
- uri = u"file://%s" % curdir
+ uri = "file://%s" % curdir
repo, origin = get_repo()
if not repo:
- repo = unicode(curdir.rsplit('/', 1)[1])
+ repo = str(curdir.rsplit('/', 1)[1])
origin = uri
subject = Subject.new_for_values(
try:
return __import__('bb')
except ImportError:
- print "ERROR: Unable to find bitbake/lib, try initializing build " \
- "environment with the 'oe-init-build-env' script\n"
+ print("ERROR: Unable to find bitbake/lib, try initializing build " \
+ "environment with the 'oe-init-build-env' script\n")
# Return None instead of raising (ImportError) so that building of
# this package succeeds in Debian. Otherwise dpkg-buildpackage fails
# because of an import error in epydoc.
if match and match.group('name') == var:
if not self.was_set:
self.was_set = True
- print "Setting value %s = %s" % (var, val)
+ print("Setting value %s = %s" % (var, val))
return ['%s = "%s"\n' % (var, val)]
else:
return []
"""handles command line and config file option parsing for the gbp commands"""
from optparse import OptionParser, OptionGroup, Option, OptionValueError
-from ConfigParser import SafeConfigParser, NoSectionError
+from configparser import SafeConfigParser, NoSectionError
from copy import copy
import os.path
import tempfile
if parser.has_section(cmd):
# Don't use items() until we got rid of the compat sections
# since this pulls in the defaults again
- self.config.update(dict(parser._sections[cmd].items()))
+ self.config.update(dict(list(parser._sections[cmd].items())))
for section in self.sections:
if parser.has_section(section):
- self.config.update(dict(parser._sections[section].items()))
+ self.config.update(dict(list(parser._sections[section].items())))
else:
raise NoSectionError("Mandatory section [%s] does not exist."
% section)
@return: C{True} if the version has an epoch, C{False} otherwise
@rtype: C{bool}
"""
- return self._cp.has_key('Epoch')
+ return 'Epoch' in self._cp
@property
def author(self):
new_cl = open("debian/changelog.bak", "w")
for line in old_cl:
if line == " * [[[insert-git-dch-commit-message-here]]]\n":
- print >> new_cl, " * " + msg[0]
+ print(" * " + msg[0], file=new_cl)
for line in msg[1:]:
- print >> new_cl, " " + line
+ print(" " + line, file=new_cl)
else:
- print >> new_cl, line,
+ print(line, end=' ', file=new_cl)
os.rename("debian/changelog.bak", "debian/changelog")
def add_entry(self, msg, author=None, email=None, dch_options=[]):
with open(filename) as f:
control = email.message_from_file(f)
- if not control.items():
+ if not list(control.items()):
raise ParseControlError("Empty or invalid control file or contents")
self._control = control
"""
self._changelog = None
- if isinstance(vfs, basestring):
+ if isinstance(vfs, str):
self._vfs = FileVfs(vfs)
else:
self._vfs = vfs
Add arguments to argument list
"""
for arg in args:
- if isinstance(arg, basestring):
+ if isinstance(arg, str):
self._args.append(arg)
elif isinstance(arg, collections.Iterable):
for i in iter(arg):
self._date = None
tz = GitTz(0)
- if isinstance(date, basestring):
+ if isinstance(date, str):
timestamp, offset = date.split()
offset_h = int(offset[:-2])
offset_m = int(offset[-2:])
def items(self):
items = []
- for key in self.keys():
+ for key in list(self.keys()):
val = self.__getitem__(key)
if val:
items.append((key, val))
def __init__(self, name, fetch_url, push_urls):
self._name = name
self._fetch_url = fetch_url
- if isinstance(push_urls, basestring):
+ if isinstance(push_urls, str):
self._push_urls = [push_urls]
else:
self._push_urls = [url for url in push_urls]
@param verbose: be verbose
@type verbose: C{bool}
"""
- if isinstance(paths, basestring):
+ if isinstance(paths, str):
paths = [ paths ]
args = [] if verbose else ['--quiet']
@type committer: C{dict} with keys 'name' and 'email'
"""
extra_env = {}
- for key, val in author.items():
+ for key, val in list(author.items()):
if val:
extra_env['GIT_AUTHOR_%s' % key.upper()] = val
- for key, val in committer.items():
+ for key, val in list(committer.items()):
if val:
extra_env['GIT_COMMITTER_%s' % key.upper()] = val
args.add(until)
args.add_cond(options, options)
args.add("--")
- if isinstance(paths, basestring):
+ if isinstance(paths, str):
paths = [ paths ]
args.add_cond(paths, paths)
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""Make blobs in a git repository accessible as file like objects"""
-import StringIO
+import io
from gbp.git.repository import GitRepositoryError
class GitVfs(object):
"""
def __init__(self, content):
self._iter = iter
- self._data = StringIO.StringIO(content)
+ self._data = io.StringIO(content)
def readline(self):
return self._data.readline()
# Initialize default logger
LOGGER = logging.getLogger(__name__)
-COLORS = dict([('none', 0)] + zip(['black', 'red', 'green', 'yellow', 'blue',
- 'magenta', 'cyan', 'white'], range(30, 38)))
+COLORS = dict([('none', 0)] + list(zip(['black', 'red', 'green', 'yellow', 'blue',
+ 'magenta', 'cyan', 'white'], list(range(30, 38)))))
DEFAULT_COLOR_SCHEME = {DEBUG: COLORS['green'],
INFO: COLORS['green'],
WARNING: COLORS['red'],
if self.info == None:
self._read_info()
- if self.info.has_key(key):
+ if key in self.info:
return self.info[key]
else:
return get_val() if get_val else None
base_name = ".".join(split[:-1])
(archive_fmt, compression) = (split[-1], None)
else:
- for (c, o) in compressor_opts.iteritems():
+ for (c, o) in compressor_opts.items():
if o[1] == split[-1]:
base_name = ".".join(split[:-1])
compression = c
version_chars = r'[a-zA-Z\d\.\~\-\:\+]'
basename = parse_archive_filename(os.path.basename(filename))[0]
- version_filters = map ( lambda x: x % version_chars,
- ( # Debian upstream tarball: package_'<version>.orig.tar.gz'
+ version_filters = [x % version_chars for x in ( # Debian upstream tarball: package_'<version>.orig.tar.gz'
r'^(?P<package>[a-z\d\.\+\-]+)_(?P<version>%s+)\.orig',
# Debian native: 'package_<version>.tar.gz'
r'^(?P<package>[a-z\d\.\+\-]+)_(?P<version>%s+)',
# Upstream 'package-<version>.tar.gz'
# or directory 'package-<version>':
- r'^(?P<package>[a-zA-Z\d\.\+\-]+)(-)(?P<version>[0-9]%s*)'))
+ r'^(?P<package>[a-zA-Z\d\.\+\-]+)(-)(?P<version>[0-9]%s*)')]
if extra_regex:
version_filters = extra_regex + version_filters
@staticmethod
def known_compressions():
- return [ args[1][-1] for args in compressor_opts.items() ]
+ return [ args[1][-1] for args in list(compressor_opts.items()) ]
def guess_version(self, extra_regex=r''):
return self._pkg_policy.guess_upstream_src_version(self.path,
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""provides some rpm source package related helpers"""
-import commands
+import subprocess
import sys
import os
import re
def sources(self):
"""Get all source tags as a dict"""
sources = {}
- for src in self._sources().values():
+ for src in list(self._sources().values()):
sources[src['num']] = src['linevalue']
return sources
tagvalue = None
# We don't support "multivalue" tags like "Provides:" or "SourceX:"
# Rpm python doesn't support many of these, thus the explicit list
- if type(tagvalue) is int or type(tagvalue) is long:
+ if type(tagvalue) is int or type(tagvalue) is int:
tagvalue = str(tagvalue)
elif type(tagvalue) is list or tagname in self._listtags:
tagvalue = None
indent_re = re.compile(r'^([a-z]+([0-9]+)?\s*:\s*)', flags=re.I)
match = indent_re.match(str(insertafter))
if not match:
- match = indent_re.match(str(insertafter.next))
+ match = indent_re.match(str(insertafter.__next__))
indent = 12 if not match else len(match.group(1))
text = '%-*s%s\n' % (indent, '%s:' % tagname, value)
if key in self._tags:
"which to update" % name)
line = self._special_directives[name][0]['line']
gbp.log.debug("Removing content of %s section" % name)
- while line.next:
- match = self.directive_re.match(str(line.next))
+ while line.__next__:
+ match = self.directive_re.match(str(line.__next__))
if match and match.group('name') in self.section_identifiers:
break
- self._content.delete(line.next)
+ self._content.delete(line.__next__)
else:
gbp.log.debug("Adding %s section to the end of spec file" % name)
line = self._content.append('%%%s\n' % name)
text = ''
if 'changelog' in self._special_directives:
line = self._special_directives['changelog'][0]['line']
- while line.next:
- line = line.next
+ while line.__next__:
+ line = line.__next__
match = self.directive_re.match(str(line))
if match and match.group('name') in self.section_identifiers:
break
macro_prev = None
ignored = self.ignorepatches
# Remove 'Patch:̈́' tags
- for tag in self._patches().values():
+ for tag in list(self._patches().values()):
if not tag['num'] in ignored:
tag_prev = self._delete_tag('patch', tag['num'])
# Remove a preceding comment if it seems to originate from GBP
if not macro['id'] in ignored:
macro_prev = self._delete_special_macro('patch', macro['id'])
# Remove surrounding if-else
- macro_next = macro_prev.next
+ macro_next = macro_prev.__next__
if (str(macro_prev).startswith('%if') and
str(macro_next).startswith('%endif')):
self._content.delete(macro_next)
macro_line = self._content.insert_after(macro_line, comment_text)
macro_line = self._set_special_macro('patch', patchnum, '-p1',
macro_line)
- for cmd, args in cmds.iteritems():
+ for cmd, args in cmds.items():
if cmd in ('if', 'ifarch'):
self._content.insert_before(macro_line, '%%%s %s\n' %
(cmd, args))
"""
orig = None
sources = self.sources()
- for num, filename in sorted(sources.iteritems()):
+ for num, filename in sorted(sources.items()):
src = {'num': num, 'filename': os.path.basename(filename),
'uri': filename}
src['filename_base'], src['archive_fmt'], src['compression'] = \
"""parse srpm by creating a SrcRpmFile object"""
try:
srcrpm = SrcRpmFile(srpmfile)
- except IOError, err:
+ except IOError as err:
raise GbpError("Error reading src.rpm file: %s" % err)
- except librpm.error, err:
+ except librpm.error as err:
raise GbpError("RPM error while reading src.rpm: %s" % err)
return srcrpm
def delete(self):
"""Delete node"""
if self.prev:
- self.prev.next = self.next
- if self.next:
+ self.prev.next = self.__next__
+ if self.__next__:
self.next.prev = self.prev
self._data = None
def __init__(self, obj):
self._next = obj.first
- def next(self):
+ def __next__(self):
ret = self._next
if ret:
- self._next = ret.next
+ self._next = ret.__next__
else:
raise StopIteration
return ret
>>> [str(data) for data in list]
['foo', 'baz', 'bar']
"""
- new = LinkedListNode(data, prev_node=node, next_node=node.next)
- if node.next:
+ new = LinkedListNode(data, prev_node=node, next_node=node.__next__)
+ if node.__next__:
node.next.prev = new
else:
self._last = new
"""
ret = node.prev
if node is self._first:
- ret = self._first = self._first.next
+ ret = self._first = self._first.__next__
if node is self._last:
self._last = self._last.prev
node.delete()
text.extend([" " + line for line in body if line.strip()])
# Add bts tags and ids in the end
- for tag, ids in bts_tags.iteritems():
+ for tag, ids in bts_tags.items():
bts_msg = " (%s: %s)" % (tag, ', '.join(ids))
if len(text[-1]) + len(bts_msg) >= cls.max_entry_line_length:
text.append(" ")
#
"""Build a debian package out of a GIT repository"""
-import ConfigParser
+import configparser
import errno
import os, os.path
import sys
if comp_type != 'auto':
comp_type = compressor_aliases.get(comp_type, comp_type)
- if not compressor_opts.has_key(comp_type):
+ if comp_type not in compressor_opts:
gbp.log.warn("Unknown compression type - guessing.")
comp_type = 'auto'
if not tarball_dir:
tarball_dir = '..'
detected = None
- for comp in compressor_opts.keys():
+ for comp in list(compressor_opts.keys()):
if du.DebianPkgPolicy.has_orig(du.orig_file(cp, comp), tarball_dir):
if detected is not None:
raise GbpError("Multiple orig tarballs found.")
def build_parser(name, prefix=None):
try:
parser = GbpOptionParserDebian(command=os.path.basename(name), prefix=prefix)
- except ConfigParser.ParsingError as err:
+ except configparser.ParsingError as err:
gbp.log.err(err)
return None
#
"""Build an RPM package out of a Git repo with Bitbake meta data"""
-import ConfigParser
+import configparser
import os, os.path
import sys
import shutil
"""Get commit and tree from where to export packaging and patches"""
tree = None
branch = None
- if options.export in wc_names.keys() + [index_name, 'HEAD']:
+ if options.export in list(wc_names.keys()) + [index_name, 'HEAD']:
branch = get_current_branch(repo)
elif options.export in repo.get_local_branches():
branch = options.export
gbp.log.debug("Found matching recipe filename: %s" % name)
return os.path.dirname(name)
else:
- for name, appends in tinfoil.cooker.collection.appendlist.iteritems():
- print name, appends
+ for name, appends in tinfoil.cooker.collection.appendlist.items():
+ print(name, appends)
if name.rsplit('_', 1)[0] == pkg_name:
gbp.log.debug("Found %s from appends" % name)
for append_name in appends:
try:
parser = GbpOptionParserBB(command=os.path.basename(name),
prefix=prefix, git_treeish=git_treeish)
- except ConfigParser.ParsingError, err:
+ except configparser.ParsingError as err:
gbp.log.err(err)
return None
if len(err.__str__()):
gbp.log.err(err)
retval = 2
- except GbpError, err:
+ except GbpError as err:
if len(err.__str__()):
gbp.log.err(err)
retval = 1
#
"""run commands to build an RPM package out of a git repository"""
-import ConfigParser
+import configparser
import errno
import os, os.path
import sys
"""Get commit and tree from where to export packaging and patches"""
tree = None
branch = None
- if options.export in wc_names.keys() + [index_name, 'HEAD']:
+ if options.export in list(wc_names.keys()) + [index_name, 'HEAD']:
branch = get_current_branch(repo)
elif options.export in repo.get_local_branches():
branch = options.export
try:
parser = GbpOptionParserRpm(command=os.path.basename(argv[0]),
prefix=prefix, git_treeish=git_treeish)
- except ConfigParser.ParsingError, err:
+ except configparser.ParsingError as err:
gbp.log.err(err)
return None, None, None
# Create base temporary directory for this run
options.tmp_dir = tempfile.mkdtemp(dir=options.tmp_dir,
prefix='buildpackage-rpm_')
- except GbpError, err:
+ except GbpError as err:
gbp.log.err(err)
return 1
if len(err.__str__()):
gbp.log.err(err)
retval = 2
- except GbpError, err:
+ except GbpError as err:
if len(err.__str__()):
gbp.log.err(err)
retval = 1
#
"""Clone a GIT repository and set it up for gbp"""
-import ConfigParser
+import configparser
import sys
import os, os.path
from gbp.config import (GbpOptionParser, GbpOptionGroup)
try:
parser = GbpOptionParser(command=os.path.basename(name), prefix='',
usage='%prog [options] repository - clone a remote repository')
- except ConfigParser.ParsingError as err:
+ except configparser.ParsingError as err:
gbp.log.err(err)
return None
#
"""Clone a package Git repository from a bitbake-based distro"""
-import ConfigParser
+import configparser
import re
import sys
import os, os.path
parser = GbpOptionParser(command=os.path.basename(name), prefix='',
usage='%prog [options] repository - clone a '
'remote per-package repository')
- except ConfigParser.ParsingError as err:
+ except configparser.ParsingError as err:
gbp.log.err(err)
return None
@param default: The default package name to suggest to the user.
"""
while True:
- sourcepackage = raw_input("What will be the source package name? [%s] " % default)
+ sourcepackage = input("What will be the source package name? [%s] " % default)
if not sourcepackage: # No input, use the default.
sourcepackage = default
# Valid package name, return it.
@param default: The default package version to suggest to the user.
"""
while True:
- version = raw_input("What is the upstream version? [%s] " % default)
+ version = input("What is the upstream version? [%s] " % default)
if not version: # No input, use the default.
version = default
# Valid version, return it.
"""
if exclude_regex:
include_paths = []
- for file_list in file_status.values():
+ for file_list in list(file_status.values()):
for fname in file_list:
if not re.match(exclude_regex, fname):
include_paths.append(fname)
# Git compat: put name in quotes if special characters found
if re.search("[,.@()\[\]\\\:;]", name):
name = '"%s"' % name
- from_header = Header(unicode(name, 'utf-8'), charset, 77, 'from')
- from_header.append(unicode('<%s>' % email))
+ from_header = Header(str(name, 'utf-8'), charset, 77, 'from')
+ from_header.append(str('<%s>' % email))
msg['From'] = from_header
date = commit_info['author'].datetime
datestr = date.strftime('%a, %-d %b %Y %H:%M:%S %z')
- msg['Date'] = Header(unicode(datestr, 'utf-8'), charset, 77, 'date')
- msg['Subject'] = Header(unicode(commit_info['subject'], 'utf-8'),
+ msg['Date'] = Header(str(datestr, 'utf-8'), charset, 77, 'date')
+ msg['Subject'] = Header(str(commit_info['subject'], 'utf-8'),
charset, 77, 'subject')
# Write message body
if commit_info['body']:
#
"""Query and display config file values"""
-import ConfigParser
+import configparser
import sys
import os, os.path
from gbp.config import (GbpOptionParser, GbpOptionGroup)
try:
parser = GbpOptionParser(command=os.path.basename(name), prefix='',
usage='%prog [options] command[.optionname] - display configuration settings')
- except ConfigParser.ParsingError as err:
+ except configparser.ParsingError as err:
gbp.log.err(err)
return None
# Based on the aa-create-git-repo and dom-new-git-repo shell scripts
"""Create a remote GIT repository based on the current one"""
-import ConfigParser
+import configparser
import sys
import os, os.path
-import urlparse
+import urllib.parse
import subprocess
import tty, termios
import re
merge = refs/heads/bar
"""
- print """[remote "%(name)s"]
+ print("""[remote "%(name)s"]
url = %(url)s
- fetch = +refs/heads/*:refs/remotes/%(name)s/*""" % remote
+ fetch = +refs/heads/*:refs/remotes/%(name)s/*""" % remote)
for branch in branches:
- print " push = %s" % branch
+ print(" push = %s" % branch)
for branch in branches:
- print """[branch "%s"]
+ print("""[branch "%s"]
remote = %s
- merge = refs/heads/%s""" % (branch, remote['name'], branch)
+ merge = refs/heads/%s""" % (branch, remote['name'], branch))
def sort_dict(d):
"""Return a sorted list of (key, value) tuples"""
s = []
- for key in sorted(d.iterkeys()):
+ for key in sorted(d.keys()):
s.append((key, d[key]))
return s
...
GbpError: URL contains invalid ~username expansion.
"""
- frags = urlparse.urlparse(remote_url)
+ frags = urllib.parse.urlparse(remote_url)
if frags.scheme in ['ssh', 'git+ssh', '']:
scheme = frags.scheme
else:
usage='%prog [options] - '
'create a remote repository',
sections=sections)
- except ConfigParser.ParsingError as err:
+ except configparser.ParsingError as err:
gbp.log.err(err)
return None
try:
options, args = parse_args(argv)
except Exception as e:
- print >>sys.stderr, "%s" % e
+ print("%s" % e, file=sys.stderr)
return 1
gbp.log.setup(options.color, options.verbose, options.color_scheme)
remote_script = build_remote_script(remote, branches[0])
if options.verbose:
- print remote_script
+ print(remote_script)
cmd = build_cmd(remote)
if options.verbose:
- print cmd
+ print(cmd)
proc = subprocess.Popen(cmd, stdin=subprocess.PIPE)
proc.communicate(remote_script)
#
"""Generate Debian changelog entries from GIT commit messages"""
-import ConfigParser
+import configparser
import os.path
import re
import sys
cw = open(tmpfile, 'w')
cr = open(changelog, 'r')
- print >>cw, ("%(Source)s (%(MangledVersion)s) "
- "%(Distribution)s; urgency=%(urgency)s\n" % cp)
+ print(("%(Source)s (%(MangledVersion)s) "
+ "%(Distribution)s; urgency=%(urgency)s\n" % cp), file=cw)
cr.readline() # skip version and empty line
cr.readline()
line = ''
if snapshot:
- print >>cw, " ** SNAPSHOT build @%s **\n" % snapshot
+ print(" ** SNAPSHOT build @%s **\n" % snapshot, file=cw)
if line:
- print >>cw, line.rstrip()
+ print(line.rstrip(), file=cw)
shutil.copyfileobj(cr, cw)
cw.close()
cr.close()
def get_customizations(customization_file):
if customization_file:
- execfile(customization_file,
+ exec(compile(open(customization_file, "rb").read(), customization_file, 'exec'),
user_customizations,
user_customizations)
try:
parser = GbpOptionParserDebian(command=os.path.basename(name),
usage='%prog [options] paths')
- except ConfigParser.ParsingError as err:
+ except configparser.ParsingError as err:
gbp.log.err(err)
return None
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""Import an RPM package in Bitbake format"""
-import ConfigParser
+import configparser
import sys
import os
import shutil
prefix='',
usage='%prog [options] /path/to/package'
'.src.rpm')
- except ConfigParser.ParsingError, err:
+ except configparser.ParsingError as err:
gbp.log.err(err)
return None
def import_upstream_git(repo, fetch_data, options):
"""Import upstream sources from Git"""
# Fetch from local cached repo
- for branch in fetch_data.branches.values():
+ for branch in list(fetch_data.branches.values()):
repo.fetch(repo=fetch_data.localpath, refspec=branch)
commit = fetch_data.revision
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""Import a Debian source package into a GIT repository"""
-import ConfigParser
+import configparser
import sys
import re
import os
try:
parser = GbpOptionParserDebian(command=os.path.basename(name), prefix='',
usage='%prog [options] /path/to/package.dsc')
- except ConfigParser.ParsingError as err:
+ except configparser.ParsingError as err:
gbp.log.err(err)
return None
os.chdir(dirs['top'])
for d in [ 'tmp', 'download' ]:
- if dirs.has_key(d):
+ if d in dirs:
gbpc.RemoveTree(dirs[d])()
if not ret and not skipped:
gbp.log.debug("Setting GBP_CONF_FILES to '%s'" % gbp_conf_files)
def print_help():
- print """Usage: gbp import-dscs [options] [gbp-import-dsc options] /path/to/dsc1 [/path/to/dsc2] ...
+ print("""Usage: gbp import-dscs [options] [gbp-import-dsc options] /path/to/dsc1 [/path/to/dsc2] ...
gbp import-dscs --debsnap [options] [gbp-import-dsc options] package
Options:
--ignore-repo-config: ignore gbp.conf in git repo
-"""
+""")
def main(argv):
gbp.log.err(err)
ret = 1
finally:
- if dirs.has_key('tmp'):
+ if 'tmp' in dirs:
gbpc.RemoveTree(dirs['tmp'])()
os.chdir(dirs['top'])
#
"""Import a new upstream version into a GIT repository"""
-import ConfigParser
+import configparser
import os
import sys
import gbp.tmpfile as tempfile
try:
parser = GbpOptionParserDebian(command=os.path.basename(name), prefix='',
usage='%prog [options] /path/to/upstream-version.tar.gz | --uscan')
- except ConfigParser.ParsingError as err:
+ except configparser.ParsingError as err:
gbp.log.err(err)
return None
#
"""Import a new upstream version into a git repository"""
-import ConfigParser
+import configparser
import os
import sys
import gbp.tmpfile as tempfile
parser = GbpOptionParserRpm(command=os.path.basename(argv[0]),
prefix='',
usage='%prog [options] /path/to/upstream-version.tar.gz')
- except ConfigParser.ParsingError, err:
+ except configparser.ParsingError as err:
gbp.log.err(err)
return None, None
repo.force_head(current_branch, hard=True)
except (GitRepositoryError, gbpc.CommandExecFailed):
raise GbpError("Import of %s failed" % source.path)
- except GbpError, err:
+ except GbpError as err:
if len(err.__str__()):
gbp.log.err(err)
ret = 1
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""Import an RPM source package into a GIT repository"""
-import ConfigParser
+import configparser
import sys
import re
import os
import time
import shutil
import errno
-import urllib2
+import urllib.request, urllib.error, urllib.parse
import gbp.tmpfile as tempfile
import gbp.command_wrappers as gbpc
"""Download a remote file"""
gbp.log.info("Downloading '%s'..." % url)
try:
- urlobj = urllib2.urlopen(url)
+ urlobj = urllib.request.urlopen(url)
local_fn = os.path.join(target_dir, os.path.basename(url))
with open(local_fn, "wb") as local_file:
local_file.write(urlobj.read())
- except urllib2.HTTPError as err:
+ except urllib.error.HTTPError as err:
raise GbpError("Download failed: %s" % err)
- except urllib2.URLError as err:
+ except urllib.error.URLError as err:
raise GbpError("Download failed: %s" % err.reason)
return local_fn
prefix='',
usage='%prog [options] /path/to/package'
'.src.rpm')
- except ConfigParser.ParsingError, err:
+ except configparser.ParsingError as err:
gbp.log.err(err)
return None, None
# Need to copy files to the packaging directory given by caller
files = [os.path.basename(patch.path) \
for patch in spec.patchseries(unapplied=True, ignored=True)]
- for filename in spec.sources().values():
+ for filename in list(spec.sources().values()):
files.append(os.path.basename(filename))
files.append(os.path.join(spec.specdir, spec.specfile))
# Don't copy orig source archive, though
#
"""Manage Debian patches on a patch queue branch"""
-import ConfigParser
+import configparser
import errno
import os
import shutil
bugs, dummy = extract_bts_cmds(patch.long_desc.split('\n'), options)
if bugs:
msg += '\n'
- for k, v in bugs.items():
+ for k, v in list(bugs.items()):
msg += '\n%s: %s' % (k, ', '.join(v))
else:
msg = "Rediff patches\n\n"
" drop drop (delete) the patch queue associated to the current branch.\n"
" apply apply a patch\n"
" switch switch to patch-queue branch and vice versa")
- except ConfigParser.ParsingError as err:
+ except configparser.ParsingError as err:
gbp.log.err(err)
return None
#
"""manage patches in a patch queue"""
-import ConfigParser
+import configparser
import errno
import os
import shutil
try:
parser = GbpOptionParserBB(command=os.path.basename(name),
prefix='', usage=USAGE_STRING)
- except ConfigParser.ParsingError as err:
+ except configparser.ParsingError as err:
gbp.log.err(err)
return None
except GitRepositoryError as err:
gbp.log.err("Git command failed: %s" % err)
retval = 1
- except GbpError, err:
+ except GbpError as err:
if len(err.__str__()):
gbp.log.err(err)
retval = 1
#
"""manage patches in a patch queue"""
-import ConfigParser
+import configparser
import errno
import os
import shutil
"into one monolithic diff" % (start_sha1, merge_sha1))
patches.append(patch_fn)
start = merge_sha1
- print start
+ print(start)
# Generate patches
for commit in reversed(repo.get_commits(start, end_commit)):
if found:
gbp.log.info("Importing additional file(s) from branch '%s' into '%s'" %
(commitish, repo.get_branch()))
- for fname, content in found.iteritems():
+ for fname, content in found.items():
dirname = os.path.dirname(fname)
if dirname and not os.path.exists(dirname):
os.makedirs(dirname)
with open(fname, 'w') as fobj:
fobj.write(content)
- files = found.keys()
+ files = list(found.keys())
gbp.log.debug('Adding/commiting %s' % files)
repo.add_files(files, force=True)
commit_msg = ("Auto-import file(s) from branch '%s':\n %s\n" %
if patch_ignore:
commit_msg += "\nGbp: Ignore\nGbp-Rpm: Ignore"
repo.commit_files(files, msg=commit_msg)
- return found.keys()
+ return list(found.keys())
def import_spec_patches(repo, options):
"""
try:
parser = GbpOptionParserRpm(command=os.path.basename(argv[0]),
prefix='', usage=USAGE_STRING)
- except ConfigParser.ParsingError as err:
+ except configparser.ParsingError as err:
gbp.log.err('Invalid config file: %s' % err)
return 1
except GitRepositoryError as err:
gbp.log.err("Git command failed: %s" % err)
retval = 1
- except GbpError, err:
+ except GbpError as err:
if len(err.__str__()):
gbp.log.err(err)
retval = 1
#
"""Pull remote changes and fast forward debian, upstream and pristine-tar branch"""
-import ConfigParser
+import configparser
import sys
import os, os.path
from gbp.command_wrappers import (Command, CommandExecFailed)
try:
parser = GbpOptionParser(command=os.path.basename(name), prefix='',
usage='%prog [options] - safely update a repository from remote')
- except ConfigParser.ParsingError as err:
+ except configparser.ParsingError as err:
gbp.log.err(err)
return None
#
"""Generate RPM changelog entries from git commit messages"""
-import ConfigParser
+import configparser
from datetime import datetime
import os.path
import pwd
return
customizations = {}
try:
- execfile(customization_file, customizations, customizations)
+ exec(compile(open(customization_file, "rb").read(), customization_file, 'exec'), customizations, customizations)
except Exception as err:
raise GbpError("Failed to load customization file: %s" % err)
if options.commit:
unstaged = []
status = repo.status()
- for group, files in status.iteritems():
+ for group, files in status.items():
if group != '??' and group[1] != ' ':
unstaged.extend(files)
if unstaged:
revision = options.changelog_revision % rev_str_fields
except KeyError as err:
raise GbpError("Unable to construct revision field: unknown key "
- "%s, only %s are accepted" % (err, rev_str_fields.keys()))
+ "%s, only %s are accepted" % (err, list(rev_str_fields.keys())))
# Add a new changelog section if new release or an empty changelog
if options.release or not changelog.sections:
return options.commit_msg % fields
except KeyError as err:
raise GbpError("Unknown key %s in commit-msg string, "
- "only %s are accepted" % (err, fields.keys()))
+ "only %s are accepted" % (err, list(fields.keys())))
def commit_changelog(repo, changelog, message, author, committer, edit):
"""Commit changelog and create a packaging/release tag"""
try:
parser = GbpOptionParserRpm(command=os.path.basename(argv[0]),
prefix='', usage='%prog [options] paths')
- except ConfigParser.ParsingError as err:
+ except configparser.ParsingError as err:
gbp.log.error('invalid config file: %s' % err)
return None, None
#
"""Create and push submit tag"""
-import ConfigParser
+import configparser
import os
import sys
from datetime import datetime
raise GbpError("Local repo has no remotes configured. Please add one "
"or use --remote to define the remote where to push.")
elif len(remotes) == 1:
- return remotes.keys()[0]
+ return list(remotes.keys())[0]
else:
raise GbpError("Local repo has multiple remotes (%s). Don't know which "
"one to choose. Use --remote to define where to push." %
- ', '.join(remotes.keys()))
+ ', '.join(list(remotes.keys())))
def build_parser(name):
try:
parser = GbpOptionParserBB(command=os.path.basename(name), prefix='',
usage=usage_str)
- except ConfigParser.ParsingError as err:
+ except configparser.ParsingError as err:
gbp.log.err(err)
return None
return cmd.replace('-', '_')
def usage():
- print """
+ print("""
Usage:
gbp <command> [<args>]
import-dscs - import multiple Debian source packages
Use '--list-cmds' to list all available commands.
-"""
+""")
def version(prog):
try:
from gbp.version import gbp_version
except ImportError:
gbp_version = '[Unknown version]'
- print("%s %s" % (os.path.basename(prog), gbp_version))
+ print(("%s %s" % (os.path.basename(prog), gbp_version)))
def import_command(cmd):
path = os.path.dirname(mod.__file__)
maxlen = 0
- print("Available commands in %s\n" % path)
+ print(("Available commands in %s\n" % path))
cmds = sorted(get_available_commands(path))
for cmd in cmds:
if len(cmd[0]) > maxlen:
for cmd in cmds:
mod = import_command(cmd[0])
doc = mod.__doc__
- print(" %s - %s" % (cmd[0].rjust(maxlen), doc))
+ print((" %s - %s" % (cmd[0].rjust(maxlen), doc)))
print('')
try:
module = import_command(cmd)
except ImportError as e:
- print >>sys.stderr, "'%s' is not a valid command." % cmd
+ print("'%s' is not a valid command." % cmd, file=sys.stderr)
usage()
if '--verbose' in args:
- print >>sys.stderr, e
+ print(e, file=sys.stderr)
return 2
return module.main(args)
self._state = self.AUTO
else:
self._state = self.OFF
- elif type(val) in [ type(t) for t in ("", u"") ]:
+ elif type(val) in [ type(t) for t in ("", "") ]:
if val.lower() in [ 'on', 'true' ]:
self._state = self.ON
elif val.lower() in [ 'auto' ]:
else:
return 'off'
- def __nonzero__(self):
+ def __bool__(self):
"""
>>> Tristate('on').__nonzero__()
True
license=('GPLv2')
conflicts=('git-buildpackage')
provides=('git-buildpackage')
-makedepends=('python2-distribute' 'gtk-doc' 'docbook-sgml' 'docbook-utils')
+makedepends=('python3-distribute' 'gtk-doc' 'docbook-sgml' 'docbook-utils')
source=(git-buildpackage_${pkgver}.tar.gz)
sha256sums=(SKIP)
build() {
cd $srcdir/$pkgbase-$pkgver
WITHOUT_NOSETESTS=1 \
- python2 setup.py build
+ python3 setup.py build
# Prepare apidocs
epydoc -n git-buildpackage --no-sourcecode -o docs/apidocs/ \
package_git-buildpackage-common() {
depends=('man-db'
- 'python2'
+ 'python3'
'git')
optdepends=('pristine-tar: regenerate pristine tarballs')
cd $srcdir/$pkgbase-$pkgver
WITHOUT_NOSETESTS=1 \
- python2 setup.py install \
+ python3 setup.py install \
--root="$pkgdir" \
--prefix=/usr \
-O1
provides=("tizen-gbp-rpm=20160302")
cd $srcdir/$pkgbase-$pkgver
WITHOUT_NOSETESTS=1 \
- python2 setup.py install \
+ python3 setup.py install \
--root="$pkgdir" \
--prefix=/usr \
-O1
+%{!?python3_sitelib: %define python3_sitelib %(python3 -c 'import sysconfig; print(sysconfig.get_paths()["purelib"])')}
# Add --without docs rpmbuild option, i.e. docs are enabled by default
%bcond_without docs
%endif
%if 0%{?fedora} || 0%{?centos_ver} || 0%{?tizen_version:1}
-%define python_pkg_name python
+%define python_pkg_name python3
%else
-%define python_pkg_name python-base
+%define python_pkg_name python3
%endif
%if 0%{?tizen_version:1}
-%define rpm_python_pkg_name python-rpm
+%define rpm_python_pkg_name python3-rpm
%else
-%define rpm_python_pkg_name rpm-python
+%define rpm_python_pkg_name rpm-python3
%endif
Requires: %{name}-common = %{version}-%{release}
Requires: %{dpkg_pkg_name}
Requires: %{devscripts_pkg_name}
-BuildRequires: python
-BuildRequires: python-setuptools
+BuildRequires: python3
+BuildRequires: python3-setuptools
%if %{with docs}
BuildRequires: docbook-utils
%endif
%if 0%{?do_unittests}
-BuildRequires: python-coverage
-BuildRequires: python-nose
+BuildRequires: python3-coverage
+BuildRequires: python3-nose
BuildRequires: git-core
BuildRequires: %{man_pkg_name}
BuildRequires: %{dpkg_pkg_name}
%build
-WITHOUT_NOSETESTS=1 %{__python} ./setup.py build
+WITHOUT_NOSETESTS=1 python3 ./setup.py build
%if %{with docs}
# Prepare apidocs
GIT_CEILING_DIRECTORIES=%{_builddir} \
GIT_AUTHOR_EMAIL=rpmbuild@example.com GIT_AUTHOR_NAME=rpmbuild \
GIT_COMMITTER_NAME=$GIT_AUTHOR_NAME GIT_COMMITTER_EMAIL=$GIT_AUTHOR_EMAIL \
- %{__python} setup.py nosetests
+ python3 setup.py nosetests
%endif
%install
rm -rf %{buildroot}
-WITHOUT_NOSETESTS=1 %{__python} ./setup.py install --root=%{buildroot} --prefix=/usr
-rm -rf %{buildroot}%{python_sitelib}/*info
+WITHOUT_NOSETESTS=1 python3 ./setup.py install --root=%{buildroot} --prefix=/usr
+rm -rf %{buildroot}%{python3_sitelib}/*info
%if %{with docs}
# Install man pages
%{_bindir}/git-import-orig
%{_bindir}/git-pbuilder
%{_bindir}/gbp-create-remote-repo
-%{python_sitelib}/gbp/deb
-%{python_sitelib}/gbp/scripts/pq.py*
-%{python_sitelib}/gbp/scripts/buildpackage.py*
-%{python_sitelib}/gbp/scripts/dch.py*
-%{python_sitelib}/gbp/scripts/import_dsc.py*
-%{python_sitelib}/gbp/scripts/import_dscs.py*
-%{python_sitelib}/gbp/scripts/import_orig.py*
-%{python_sitelib}/gbp/scripts/create_remote_repo.py*
+%{python3_sitelib}/gbp/deb
+%{python3_sitelib}/gbp/scripts/pq.py*
+%{python3_sitelib}/gbp/scripts/buildpackage.py*
+%{python3_sitelib}/gbp/scripts/dch.py*
+%{python3_sitelib}/gbp/scripts/import_dsc.py*
+%{python3_sitelib}/gbp/scripts/import_dscs.py*
+%{python3_sitelib}/gbp/scripts/import_orig.py*
+%{python3_sitelib}/gbp/scripts/create_remote_repo.py*
EOF
%if %{with docs}
%{_bindir}/gbp
%{_bindir}/gbp-clone
%{_bindir}/gbp-pull
-%dir %{python_sitelib}/gbp
-%dir %{python_sitelib}/gbp/git
-%dir %{python_sitelib}/gbp/pkg
-%dir %{python_sitelib}/gbp/scripts
-%dir %{python_sitelib}/gbp/scripts/common
-%{python_sitelib}/gbp/*.py*
-%{python_sitelib}/gbp/scripts/__init__.py*
-%{python_sitelib}/gbp/scripts/clone.py*
-%{python_sitelib}/gbp/scripts/config.py*
-%{python_sitelib}/gbp/scripts/pull.py*
-%{python_sitelib}/gbp/scripts/supercommand.py*
-%{python_sitelib}/gbp/scripts/common/*.py*
-%{python_sitelib}/gbp/git/*.py*
-%{python_sitelib}/gbp/pkg/*.py*
+%dir %{python3_sitelib}/gbp
+%dir %{python3_sitelib}/gbp/git
+%dir %{python3_sitelib}/gbp/pkg
+%dir %{python3_sitelib}/gbp/scripts
+%dir %{python3_sitelib}/gbp/scripts/common
+%{python3_sitelib}/gbp/*.py*
+%{python3_sitelib}/gbp/scripts/__init__.py*
+%{python3_sitelib}/gbp/scripts/clone.py*
+%{python3_sitelib}/gbp/scripts/config.py*
+%{python3_sitelib}/gbp/scripts/pull.py*
+%{python3_sitelib}/gbp/scripts/supercommand.py*
+%{python3_sitelib}/gbp/scripts/common/*.py*
+%{python3_sitelib}/gbp/git/*.py*
+%{python3_sitelib}/gbp/pkg/*.py*
%config %{_sysconfdir}/git-buildpackage
%if %{with docs}
%{_mandir}/man1/gbp.1*
%files rpm
%defattr(-,root,root,-)
-%dir %{python_sitelib}/gbp/rpm
+%dir %{python3_sitelib}/gbp/rpm
%{_bindir}/*rpm*
-%{python_sitelib}/gbp/scripts/*rpm*.py*
-%{python_sitelib}/gbp/rpm/*py*
+%{python3_sitelib}/gbp/scripts/*rpm*.py*
+%{python3_sitelib}/gbp/rpm/*py*
%if %{with docs}
%{_mandir}/man1/gbp-buildpackage-rpm.1*
%{_mandir}/man1/gbp-import-orig-rpm.1*
%files bb
%defattr(-,root,root,-)
-%dir %{python_sitelib}/gbp/bb
-%{python_sitelib}/gbp/scripts/*bb*.py*
-%{python_sitelib}/gbp/bb/*py*
+%dir %{python3_sitelib}/gbp/bb
+%{python3_sitelib}/gbp/scripts/*bb*.py*
+%{python3_sitelib}/gbp/bb/*py*
%if %{with docs}
-#!/usr/bin/python
+#!/usr/bin/python3
# vim: set fileencoding=utf-8 :
# Copyright (C) 2006-2011 Guido Günther <agx@sigxcpu.org>
#
try:
popen = subprocess.Popen('dpkg-parsechangelog', stdout=subprocess.PIPE)
out, ret = popen.communicate()
- for line in out.split('\n'):
+ for line in out.decode().split('\n'):
if line.startswith('Version:'):
version = line.split(' ')[1].strip()
break
setup(name = "gbp",
version = fetch_version(),
- author = u'Guido Günther',
+ author = 'Guido Günther',
author_email = 'agx@sigxcpu.org',
url = 'https://honk.sigxcpu.org/piki/projects/git-buildpackage/',
description = 'Suite to help with Debian packages in Git repositories',
context.teardown()
def test_upstream_source_type(self):
- for (comp, archive) in self.archives.iteritems():
+ for (comp, archive) in self.archives.items():
source = gbp.pkg.UpstreamSource(archive[0])
assert source.is_orig() == True
assert source.is_dir() == False
assert type(source.unpacked) == str
def test_upstream_source_unpack(self):
- for (comp, archive) in self.archives.iteritems():
+ for (comp, archive) in self.archives.items():
source = gbp.pkg.UpstreamSource(archive[0])
source.unpack(".")
self._check_files(archive[1], comp)
def test_upstream_source_unpack_no_filter(self):
- for (comp, archive) in self.archives.iteritems():
+ for (comp, archive) in self.archives.items():
source = gbp.pkg.UpstreamSource(archive[0])
source.unpack(".", [])
self._check_files(archive[1], comp)
def test_upstream_source_unpack_filtered(self):
exclude = "README"
- for (comp, archive) in self.archives.iteritems():
+ for (comp, archive) in self.archives.items():
source = gbp.pkg.UpstreamSource(archive[0])
source.unpack(".", [exclude])
archive[1].remove(exclude)
from . import context
-import testutils
+from . import testutils
from gbp.scripts import dch
for i in range(4):
path = os.path.join(self.repo.path, 'testfile%d' % i)
with open(path, 'w') as f:
- print >>f, "testdata %d" % i
+ print("testdata %d" % i, file=f)
paths.append(path)
return paths
from . import context
-import testutils
+from . import testutils
import gbp.log
import gbp.scripts.import_dscs as import_dscs
from . import context
import os
-import testutils
+from . import testutils
from gbp.deb.source import DebianSource, DebianSourceError
from gbp.deb.format import DebianSourceFormat
from gbp.git.vfs import GitVfs
from . import context
-import testutils
+from . import testutils
from gbp.scripts import dch
'pull' ]:
printstub = self.AllValuesPrintStub(cmd)
ret = gbp.scripts.config.print_cmd_all_values(cmd, printstub)
- self.assertTrue('%s.color' % cmd in printstub.result.keys())
+ self.assertTrue('%s.color' % cmd in list(printstub.result.keys()))
self.assertEqual(ret, 0)
def test_invalid_cms(self):
import re
import shutil
import tempfile
-from StringIO import StringIO
+from io import StringIO
from nose import SkipTest
from nose.tools import eq_, ok_ # pylint: disable=E0611
for prj_e in self._doc.getElementsByTagName('project'):
branches = []
for br_e in prj_e.getElementsByTagName('branch'):
- branches.append(dict(br_e.attributes.items()))
+ branches.append(dict(list(br_e.attributes.items())))
yield prj_e.getAttribute('name'), branches
import tempfile
from nose.plugins.skip import SkipTest
from nose.tools import assert_raises, eq_ # pylint: disable=E0611
-from StringIO import StringIO
+from io import StringIO
from gbp.scripts.import_orig_rpm import main as import_orig_rpm
from gbp.git import GitRepository
def _create_dummy_spec(path, **kwargs):
"""Create a dummy spec file"""
with open(path, 'w') as fobj:
- print kwargs
+ print(kwargs)
fobj.write(DUMMY_SPEC % kwargs)
def test_invalid_args(self):
import os
import shutil
-import urllib2
+import urllib.request, urllib.error, urllib.parse
from nose.plugins.skip import SkipTest
from nose.tools import assert_raises, eq_, ok_ # pylint: disable=E0611
from mock import Mock
'master/gbp-test-1.0-1.src.rpm'
# Mock to use local files instead of really downloading
local_fn = os.path.join(DATA_DIR, os.path.basename(srpm))
- urllib2.urlopen = Mock()
- urllib2.urlopen.return_value = open(local_fn, 'r')
+ urllib.request.urlopen = Mock()
+ urllib.request.urlopen.return_value = open(local_fn, 'r')
eq_(mock_import(['--no-pristine-tar', '--download', srpm]), 0)
# Check repository state
"""Test graceful failure when trying download from nonexistent url"""
srpm = 'http://url.does.not.exist.com/foo.src.rpm'
# Do not connect to remote, mock failure
- urllib2.urlopen = Mock()
- urllib2.urlopen.side_effect = urllib2.HTTPError(srpm, 404, "Not found",
+ urllib.request.urlopen = Mock()
+ urllib.request.urlopen.side_effect = urllib.error.HTTPError(srpm, 404, "Not found",
None, None)
eq_(mock_import(['--download', srpm]), 1)
gbp.log.setup(color=False, verbose=True)
-repo_dir, bare_dir, clone_dir, mirror_clone_dir = map(
+repo_dir, bare_dir, clone_dir, mirror_clone_dir = list(map(
lambda x, tmpdir=context.new_tmpdir(__name__): tmpdir.join(x),
- ['repo', 'bare', 'clone', 'mirror_clone'])
+ ['repo', 'bare', 'clone', 'mirror_clone']))
def test_create():
"""
def test_failure(self):
"""Test failure modes"""
- with self.assertRaisesRegexp(GbpError,
+ with self.assertRaisesRegex(GbpError,
"More than one archive specified"):
find_source(False, ['too', 'much'])
- with self.assertRaisesRegexp(GbpError,
+ with self.assertRaisesRegex(GbpError,
"No archive to import specified"):
find_source(False, [])
- with self.assertRaisesRegexp(GbpError,
+ with self.assertRaisesRegex(GbpError,
"you can't pass both --uscan and a filename"):
find_source(True, ['tarball'])
spec = SpecFileTester(spec_filepath)
# Check all the tags
- for name, val in spec.protected('_tags').iteritems():
+ for name, val in spec.protected('_tags').items():
rval = None
if name in ('version', 'release', 'epoch'):
rval = '0'
projects / tools / git-buildpackage.git / commitdiff