[gentoo-commits] dev/zorry:master commit in: gobs/pym/

[Magnus Granberg]

commit:     8554eeee41909a2df43989d6872346b5b64e4570
Author:     Magnus Granberg <zorry <AT> gentoo <DOT> org>
AuthorDate: Fri Jul 29 15:29:35 2011 +0000
Commit:     Magnus Granberg <zorry <AT> gentoo <DOT> org>
CommitDate: Fri Jul 29 15:29:35 2011 +0000
URL:        http://git.overlays.gentoo.org/gitweb/?p=dev/zorry.git;a=commit;h=8554eeee

Updated alot in the pym dir

---
 gobs/pym/ConnectionManager.py |   26 +-
 gobs/pym/build_log.py         |   99 ++++---
 gobs/pym/build_queru.py       |  158 ++++++++++
 gobs/pym/depclean.py          |  632 +++++++++++++++++++++++++++++++++++++++++
 gobs/pym/flags.py             |   27 +-
 gobs/pym/old_cpv.py           |   11 +-
 gobs/pym/package.py           |   44 +---
 gobs/pym/text.py              |   19 +-
 8 files changed, 901 insertions(+), 115 deletions(-)

diff --git a/gobs/pym/ConnectionManager.py b/gobs/pym/ConnectionManager.py
index 7d87702..1bbeb35 100644
--- a/gobs/pym/ConnectionManager.py
+++ b/gobs/pym/ConnectionManager.py
@@ -1,31 +1,31 @@
 #a simple CM build around sie singleton so there can only be 1 CM but you can call the class in different place with out caring about it.
 #when the first object is created of this class, the SQL settings are read from the file and stored in the class for later reuse by the next object and so on.
 #(maybe later add support for connection pools)
+from __future__ import print_function
+
 class connectionManager(object):
     _instance = None   
 
-		      #size of the connection Pool
+    #size of the connection Pool
     def __new__(cls, settings_dict, numberOfconnections=20, *args, **kwargs):
         if not cls._instance:
             cls._instance = super(connectionManager, cls).__new__(cls, *args, **kwargs)
             #read the sql user/host etc and store it in the local object
-            print settings_dict['sql_host']
+            print(settings_dict['sql_host'])
             cls._host=settings_dict['sql_host']
             cls._user=settings_dict['sql_user']
             cls._password=settings_dict['sql_passwd']
             cls._database=settings_dict['sql_db']
             #shouldnt we include port also?
             try:
-	      from psycopg2 import pool
-	      cls._connectionNumber=numberOfconnections
-	      #always create 1 connection
-	      cls._pool=pool.ThreadedConnectionPool(1,cls._connectionNumber,host=cls._host,database=cls._database,user=cls._user,password=cls._password)
-	      cls._name='pgsql'
-	      
-	      
-	    except ImportError:
-	      print "Please install a recent version of dev-python/psycopg for Python"
-	      sys.exit(1)
+              from psycopg2 import pool
+              cls._connectionNumber=numberOfconnections
+              #always create 1 connection
+              cls._pool=pool.ThreadedConnectionPool(1,cls._connectionNumber,host=cls._host,database=cls._database,user=cls._user,password=cls._password)
+              cls._name='pgsql'
+            except ImportError:
+              print("Please install a recent version of dev-python/psycopg for Python")
+              sys.exit(1)
             #setup connection pool
         return cls._instance
     
@@ -38,7 +38,7 @@ class connectionManager(object):
       
     def putConnection(self, connection):
       self._pool.putconn(connection)
-	
+
     def closeAllConnections(self):
       self._pool.closeall()
 

diff --git a/gobs/pym/build_log.py b/gobs/pym/build_log.py
index 4f5a801..eb5fcea 100644
--- a/gobs/pym/build_log.py
+++ b/gobs/pym/build_log.py
@@ -1,8 +1,10 @@
+from __future__ import print_function
 import re
 from gobs.text import get_log_text_list
 from gobs.repoman_gobs import gobs_repoman
 import portage
 from gobs.readconf import get_conf_settings
+from gobs.flags import gobs_use_flags
 reader=get_conf_settings()
 gobs_settings_dict=reader.read_gobs_settings_all()
 # make a CM
@@ -16,35 +18,58 @@ elif CM.getName()=='mysql':
 
 class gobs_buildlog(object):
 	
-	def __init__(self, CM, mysettings, build_dict, config_profile):
+	def __init__(self,  mysettings, build_dict):
 		self._mysettings = mysettings
 		self._myportdb = portage.portdbapi(mysettings=self._mysettings)
 		self._build_dict = build_dict
-		self._config_profile = config_profile
-		self._CM = CM
 		self._logfile_text = get_log_text_list(self._mysettings.get("PORTAGE_LOG_FILE"))
+	
+	def add_new_ebuild_buildlog(self, build_error, summary_error, build_log_dict):
+		conn=CM.getConnection()
+		cpv = self._build_dict['cpv']
+		init_useflags = gobs_use_flags(self._mysettings, self._myportdb, cpv)
+		iuse_flags_list, final_use_list = init_useflags.get_flags_looked()
+		iuse = []
+		use_flags_list = []
+		use_enable_list = []
+		for iuse_line in iuse_flags_list:
+			iuse.append(init_useflags.reduce_flag(iuse_line))
+		iuse_flags_list2 = list(set(iuse))
+		use_enable = final_use_list
+		use_disable = list(set(iuse_flags_list2).difference(set(use_enable)))
+		use_flagsDict = {}
+		for x in use_enable:
+			use_flagsDict[x] = True
+		for x in use_disable:
+			use_flagsDict[x] = False
+		for u, s in  use_flagsDict.iteritems():
+			use_flags_list.append(u)
+			use_enable_list.append(s)
+		build_id = add_new_buildlog(conn, self._build_dict, use_flags_list, use_enable_list, build_error, summary_error, build_log_dict)
+		CM.putConnection(conn)
+		return build_id
 
-	def search_info(self, textline, error_log_list, i):
+	def search_info(self, textline, error_log_list):
 		if re.search(" * Package:", textline):
-			print 'Package'
+			print('Package')
 			error_log_list.append(textline)
 		if re.search(" * Repository:", textline):
-			print 'Repository'
+			print('Repository')
 			error_log_list.append(textline)
 		if re.search(" * Maintainer:", textline):
 			error_log_list.append(textline)
-			print 'Maintainer'
+			print('Maintainer')
 		if re.search(" * USE:", textline):
 			error_log_list.append(textline)
-			print 'USE'
+			print('USE')
 		if re.search(" * FEATURES:", textline):
 			error_log_list.append(textline)
-			print 'FEATURES'
+			print('FEATURES')
 		return error_log_list
 
 	def search_error(self, textline, error_log_list, sum_build_log_list, i):
 		if re.search("Error 1", textline):
-			print 'Error'
+			print('Error')
 			x = i - 20
 			endline = True
 			error_log_list.append(".....\n")
@@ -56,7 +81,7 @@ class gobs_buildlog(object):
 				else:
 					x = x +1
 		if re.search(" * ERROR:", textline):
-			print 'ERROR'
+			print('ERROR')
 			x = i
 			endline= True
 			field = textline.split(" ")
@@ -69,12 +94,25 @@ class gobs_buildlog(object):
 					endline = False
 				else:
 					x = x +1
+		if re.search("configure: error:", textline):
+			print('configure: error:')
+			x = i - 4
+			endline = True
+			error_log_list.append(".....\n")
+			while x != i + 3 and endline:
+				try:
+					error_log_list.append(self._logfile_text[x])
+				except:
+					endline = False
+				else:
+					x = x +1
 		return error_log_list, sum_build_log_list
 
 	def search_qa(self, textline, qa_error_list, error_log_list,i):
-		if re.search(" * QA Notice: Package has poor programming", textline):
-			print 'QA Notice'
+		if re.search(" * QA Notice:", textline):
+			print('QA Notice')
 			x = i
+			qa_error_list.append(self._logfile_text[x])
 			endline= True
 			error_log_list.append(".....\n")
 			while x != i + 3 and endline:
@@ -84,20 +122,6 @@ class gobs_buildlog(object):
 					endline = False
 				else:
 					x = x +1
-			qa_error_list.append('QA Notice: Package has poor programming practices')
-			if re.search(" * QA Notice: The following shared libraries lack NEEDED", textline):
-				print 'QA Notice'
-				x = i
-				endline= True
-				error_log_list.append(".....\n")
-				while x != i + 2 and endline:
-					try:
-						error_log_list.append(self._logfile_text[x])
-					except:
-						endline = False
-					else:
-						x = x +1
-				qa_error_list.append('QA Notice: The following shared libraries lack NEEDED entries')
 		return qa_error_list, error_log_list
 
 	def get_buildlog_info(self):
@@ -110,15 +134,12 @@ class gobs_buildlog(object):
 		repoman_error_list = []
 		sum_build_log_list = []
 		for textline in self._logfile_text:
-			error_log_list = self.search_info(textline, error_log_list, i)
+			error_log_list = self.search_info(textline, error_log_list)
 			error_log_list, sum_build_log_list = self.search_error(textline, error_log_list, sum_build_log_list, i)
 			qa_error_list, error_log_list = self.search_qa(textline, qa_error_list, error_log_list, i)
 			i = i +1
 		# Run repoman check_repoman()
-		categories = self._build_dict['categories']
-		package = self._build_dict['package']
-		ebuild_version = self._build_dict['ebuild_version']
-		repoman_error_list = init_repoman.check_repoman(categories, package, ebuild_version, self._config_profile)
+		repoman_error_list = init_repoman.check_repoman(self._build_dict['categories'], self._build_dict['package'], self._build_dict['ebuild_version'], self._build_dict['config_profile'])
 		if repoman_error_list != []:
 			sum_build_log_list.append("repoman")
 		if qa_error_list != []:
@@ -130,7 +151,7 @@ class gobs_buildlog(object):
 		return build_log_dict
 
 	def add_buildlog_main(self):
-		conn=self._CM.getConnection()
+		conn=CM.getConnection()
 		build_log_dict = {}
 		build_log_dict = self.get_buildlog_info()
 		sum_build_log_list = build_log_dict['summary_error_list']
@@ -143,8 +164,12 @@ class gobs_buildlog(object):
 		if sum_build_log_list != []:
 			for sum_log_line in sum_build_log_list:
 				summary_error = summary_error + " " + sum_log_line
-		print 'summary_error', summary_error
-		logfilename = re.sub("\/var\/log\/portage\/", "",  self._mysettings.get("PORTAGE_LOG_FILE"))
-		build_id = move_queru_buildlog(conn, self._build_dict['queue_id'], build_error, summary_error, logfilename, build_log_dict)
+		print('summary_error', summary_error)
+		build_log_dict['logfilename'] = re.sub("\/var\/log\/portage\/", "",  self._mysettings.get("PORTAGE_LOG_FILE"))
+		print(self._build_dict['queue_id'], build_error, summary_error, build_log_dict['logfilename'], build_log_dict)
+		if self._build_dict['queue_id'] is None:
+			build_id = self.add_new_ebuild_buildlog(build_error, summary_error, build_log_dict)
+		else:
+			build_id = move_queru_buildlog(conn, self._build_dict['queue_id'], build_error, summary_error, build_log_dict)
 		# update_qa_repoman(conn, build_id, build_log_dict)
-		print "build_id", build_id, "logged to db."
+		print("build_id", build_id[0], "logged to db.")

diff --git a/gobs/pym/build_queru.py b/gobs/pym/build_queru.py
new file mode 100644
index 0000000..3d53a05
--- /dev/null
+++ b/gobs/pym/build_queru.py
@@ -0,0 +1,158 @@
+# Get the options from the config file set in gobs.readconf
+from gobs.readconf import get_conf_settings
+reader=get_conf_settings()
+gobs_settings_dict=reader.read_gobs_settings_all()
+# make a CM
+from gobs.ConnectionManager import connectionManager
+CM=connectionManager(gobs_settings_dict)
+#selectively import the pgsql/mysql querys
+if CM.getName()=='pgsql':
+	from gobs.querys.pgsql import *
+elif CM.getName()=='mysql':
+	from gobs.querys.mysql import *
+
+import portage
+import os
+from gobs.manifest import gobs_manifest
+from gobs.depclean import main_depclean
+from gobs.flags import gobs_use_flags
+from _emerge.main import emerge_main
+
+class queruaction(object):
+
+	def __init__(self, config_profile):
+		self._mysettings = portage.settings
+		self._config_profile = config_profile
+		self._myportdb =  portage.portdb
+
+	def log_fail_queru(self, build_dict, fail_querue_dict):
+		fail_times = 0
+		if fail_querue_dict == {}:
+			attDict = {}
+			attDict[build_dict['type_fail']] = 1
+			attDict['build_info'] = build_dict
+			fail_querue_dict[build_dict['querue_id']] = attDict
+			return fail_querue_dict
+		else:
+			# FIXME:If  is 5 remove fail_querue_dict[build_dict['querue_id'] from 
+			# fail_querue_dict and add log to db.
+			if not fail_querue_dict[build_dict['querue_id']] is None:
+				if fail_querue_dict[build_dict['querue_id']][build_dict['type_fail']] is None:
+					fail_querue_dict[build_dict['querue_id']][build_dict['type_fail']] = 1
+					return fail_querue_dict
+				else:
+					fail_times = fail_querue_dict[build_dict['querue_id']][build_dict['type_fail']]
+					fail_times  = fail_times + 1
+					if not fail_times is 5:
+						fail_querue_dict[build_dict['querue_id']][build_dict['type_fail']] = fail_times
+						return fail_querue_dict
+					else:
+						# FIXME:If  is 5 remove fail_querue_dict[build_dict['querue_id']] from
+						# fail_querue_dict and add log to db.
+						return fail_querue_dict
+			else:
+				attDict = {}
+				attDict[build_dict['type_fail']] = 1
+				attDict['build_info'] = build_dict
+				fail_querue_dict[build_dict['querue_id']] = attDict
+			return fail_querue_dict
+
+	def make_build_list(self, build_dict):
+		conn=CM.getConnection()
+		cpv = build_dict['category']+'/'+build_dict['package']+'-'+build_dict['ebuild_version']
+		pkgdir = os.path.join(self._mysettings['PORTDIR'], build_dict['category'] + "/" + build_dict['package'])
+    		init_manifest =  gobs_manifest(self._mysettings, pkgdir)
+    		try:
+			ebuild_version_checksum_tree = portage.checksum.sha256hash(pkgdir+ "/" + build_dict['package'] + "-" + build_dict['ebuild_version'] + ".ebuild")[0]
+		except:
+			ebuild_version_checksum_tree = None
+		if ebuild_version_checksum_tree == build_dict['checksum']:
+			if portage.getmaskingstatus(cpv, settings=self._mysettings, portdb=self._myportdb) == []:
+				init_flags = gobs_use_flags(self._mysettings, self._myportdb, cpv)
+				build_use_flags_list = init_flags.comper_useflags(build_dict)
+				print "build_use_flags_list", build_use_flags_list
+				manifest_error = init_manifest.check_file_in_manifest(self._myportdb, cpv, build_dict, build_use_flags_list)
+				if manifest_error is None:
+					build_dict['check_fail'] = False
+					build_cpv_dict = init_flags.get_needed_dep_useflags(build_use_flags_list)
+					print build_cpv_dict, build_use_flags_list, cpv
+					build_use_flags_dict = {}
+					if build_use_flags_list is None:
+						build_use_flags_dict['None'] = None
+					if build_cpv_dict is None:
+						build_cpv_dict = {}
+						build_cpv_dict[cpv] = build_use_flags_dict
+					else:
+						build_cpv_dict[cpv] = build_use_flags_dict
+					print build_cpv_dict
+					return build_cpv_dict, build_dict
+				else:
+					build_dict['1'] = 1
+			else:
+				build_dict['2'] = 2
+		else:
+			build_dict['3'] = 3
+		build_dict['check_fail'] = True
+		return build_cpv_dict, build_dict
+
+	def build_procces(self, buildqueru_cpv_dict, build_dict):
+		build_cpv_list = []
+		for k, v in buildqueru_cpv_dict.iteritems():
+				build_use_flags_list = []
+				for x, y in v.iteritems():
+					if y is True:
+						build_use_flags_list.append(x)
+					if y is False:
+						build_use_flags_list.append("-" + x)
+				print k, build_use_flags_list
+				if build_use_flags_list == []:
+					build_cpv_list.append("=" + k)
+				else:
+					build_use_flags = ""
+					for flags in build_use_flags_list:
+						build_use_flags = build_use_flags + flags + ","
+					build_cpv_list.append("=" + k + "[" + build_use_flags + "]")
+		print 'build_cpv_list', build_cpv_list
+		argscmd = []
+		if not "nooneshort" in build_dict['post_message']:
+			argscmd.append("--oneshot")
+		argscmd.append("--buildpkg")
+		argscmd.append("--usepkg")
+		for build_cpv in build_cpv_list:
+			argscmd.append(build_cpv)
+		print argscmd
+		# Call main_emerge to build the package in build_cpv_list 
+		try: 
+			build_fail = emerge_main(args=argscmd)
+		except:
+			build_fail = False
+		# Run depclean
+		if not "nodepclean" in build_dict['post_message']:
+			depclean_fail = main_depclean()
+		if build_fail is False or depclean_fail is False:
+			return False
+		return True
+
+	def procces_qureru(self, fail_querue_dict):
+		conn=CM.getConnection()
+		build_dict = {}
+		build_dict = get_packages_to_build(conn, self._config_profile)
+		print "build_dict",  build_dict
+		if build_dict is None and fail_querue_dict == {}:
+			return fail_querue_dict
+		if build_dict is None and fail_querue_dict != {}:
+			return fail_querue_dict
+		if not build_dict['ebuild_id'] is None and build_dict['checksum'] is not None:
+			buildqueru_cpv_dict, build_dict = self.make_build_list(build_dict)
+			print 'buildqueru_cpv_dict', buildqueru_cpv_dict
+			if buildqueru_cpv_dict is None:
+				return fail_querue_dict
+			fail_build_procces = self.build_procces(buildqueru_cpv_dict, build_dict)
+			if build_dict['check_fail'] is True:
+				fail_querue_dict = self.log_fail_queru(build_dict, fail_querue_dict)
+			return fail_querue_dict
+		if not build_dict['post_message'] is [] and build_dict['ebuild_id'] is None:
+			return fail_querue_dict
+		if not build_dict['ebuild_id'] is None and build_dict['checksum'] is None:
+			del_old_queue(conn, build_dict['queue_id'])
+		return fail_querue_dict

diff --git a/gobs/pym/depclean.py b/gobs/pym/depclean.py
new file mode 100644
index 0000000..b6096b6
--- /dev/null
+++ b/gobs/pym/depclean.py
@@ -0,0 +1,632 @@
+from __future__ import print_function
+import errno
+import portage
+from portage._sets.base import InternalPackageSet
+from _emerge.main import parse_opts
+from _emerge.create_depgraph_params import create_depgraph_params
+from _emerge.depgraph import backtrack_depgraph, depgraph, resume_depgraph
+from _emerge.UnmergeDepPriority import UnmergeDepPriority
+from _emerge.SetArg import SetArg
+from _emerge.actions import load_emerge_config
+from _emerge.Package import Package
+from _emerge.unmerge import unmerge
+from portage.util import cmp_sort_key, writemsg, \
+	writemsg_level, writemsg_stdout
+from portage.util.digraph import digraph
+
+def main_depclean():
+	mysettings, mytrees, mtimedb = load_emerge_config()
+	myroot = mysettings["ROOT"]
+	root_config = mytrees[myroot]["root_config"]
+	psets = root_config.setconfig.psets
+	args_set = InternalPackageSet(allow_repo=True)
+	spinner=None
+	scheduler=None
+	tmpcmdline = []
+	tmpcmdline.append("--depclean")
+	tmpcmdline.append("--pretend")
+	print("depclean",tmpcmdline)
+	myaction, myopts, myfiles = parse_opts(tmpcmdline, silent=False)
+	if myfiles:
+		args_set.update(myfiles)
+		matched_packages = False
+		for x in args_set:
+			if vardb.match(x):
+				matched_packages = True
+		if not matched_packages:
+			return 0
+
+	rval, cleanlist, ordered, req_pkg_count, unresolvable = calc_depclean(mysettings, mytrees, mtimedb["ldpath"], myopts, myaction, args_set, spinner)
+	print('rval, cleanlist, ordered, req_pkg_count, unresolvable', rval, cleanlist, ordered, req_pkg_count, unresolvable)
+	if unresolvable != []:
+		return True
+	if cleanlist != []:
+		conflict_package_list = []
+		for depclean_cpv in cleanlist:
+			if portage.versions.cpv_getkey(depclean_cpv) in list(psets["system"]):
+				conflict_package_list.append(depclean_cpv)
+			if portage.versions.cpv_getkey(depclean_cpv) in list(psets['selected']):
+				conflict_package_list.append(depclean_cpv)
+		print('conflict_package_list', conflict_package_list)
+		if conflict_package_list == []:
+			tmpcmdline = []
+			tmpcmdline.append("--depclean")
+			myaction, myopts, myfiles = parse_opts(tmpcmdline, silent=False)
+			unmerge(root_config, myopts, "unmerge", cleanlist, mtimedb["ldpath"], ordered=ordered, scheduler=scheduler)
+			print("Number removed:       "+str(len(cleanlist)))
+			return True
+	return True
+
+def calc_depclean(settings, trees, ldpath_mtimes,
+	myopts, action, args_set, spinner):
+	allow_missing_deps = bool(args_set)
+
+	debug = '--debug' in myopts
+	xterm_titles = "notitles" not in settings.features
+	myroot = settings["ROOT"]
+	root_config = trees[myroot]["root_config"]
+	psets = root_config.setconfig.psets
+	deselect = myopts.get('--deselect') != 'n'
+	required_sets = {}
+	required_sets['world'] = psets['world']
+
+	# When removing packages, a temporary version of the world 'selected'
+	# set may be used which excludes packages that are intended to be
+	# eligible for removal.
+	selected_set = psets['selected']
+	required_sets['selected'] = selected_set
+	protected_set = InternalPackageSet()
+	protected_set_name = '____depclean_protected_set____'
+	required_sets[protected_set_name] = protected_set
+	system_set = psets["system"]
+
+	if not system_set or not selected_set:
+
+		if not system_set:
+			writemsg_level("!!! You have no system list.\n",
+				level=logging.ERROR, noiselevel=-1)
+
+		if not selected_set:
+			writemsg_level("!!! You have no world file.\n",
+					level=logging.WARNING, noiselevel=-1)
+
+		writemsg_level("!!! Proceeding is likely to " + \
+			"break your installation.\n",
+			level=logging.WARNING, noiselevel=-1)
+		if "--pretend" not in myopts:
+			countdown(int(settings["EMERGE_WARNING_DELAY"]), ">>> Depclean")
+
+	if action == "depclean":
+		print(" >>> depclean")
+
+	writemsg_level("\nCalculating dependencies  ")
+	resolver_params = create_depgraph_params(myopts, "remove")
+	resolver = depgraph(settings, trees, myopts, resolver_params, spinner)
+	resolver._load_vdb()
+	vardb = resolver._frozen_config.trees[myroot]["vartree"].dbapi
+	real_vardb = trees[myroot]["vartree"].dbapi
+
+	if action == "depclean":
+
+		if args_set:
+
+			if deselect:
+				# Start with an empty set.
+				selected_set = InternalPackageSet()
+				required_sets['selected'] = selected_set
+				# Pull in any sets nested within the selected set.
+				selected_set.update(psets['selected'].getNonAtoms())
+
+			# Pull in everything that's installed but not matched
+			# by an argument atom since we don't want to clean any
+			# package if something depends on it.
+			for pkg in vardb:
+				if spinner:
+					spinner.update()
+
+				try:
+					if args_set.findAtomForPackage(pkg) is None:
+						protected_set.add("=" + pkg.cpv)
+						continue
+				except portage.exception.InvalidDependString as e:
+					show_invalid_depstring_notice(pkg,
+						pkg.metadata["PROVIDE"], str(e))
+					del e
+					protected_set.add("=" + pkg.cpv)
+					continue
+
+	elif action == "prune":
+
+		if deselect:
+			# Start with an empty set.
+			selected_set = InternalPackageSet()
+			required_sets['selected'] = selected_set
+			# Pull in any sets nested within the selected set.
+			selected_set.update(psets['selected'].getNonAtoms())
+
+		# Pull in everything that's installed since we don't
+		# to prune a package if something depends on it.
+		protected_set.update(vardb.cp_all())
+
+		if not args_set:
+
+			# Try to prune everything that's slotted.
+			for cp in vardb.cp_all():
+				if len(vardb.cp_list(cp)) > 1:
+					args_set.add(cp)
+
+		# Remove atoms from world that match installed packages
+		# that are also matched by argument atoms, but do not remove
+		# them if they match the highest installed version.
+		for pkg in vardb:
+			spinner.update()
+			pkgs_for_cp = vardb.match_pkgs(pkg.cp)
+			if not pkgs_for_cp or pkg not in pkgs_for_cp:
+				raise AssertionError("package expected in matches: " + \
+					"cp = %s, cpv = %s matches = %s" % \
+					(pkg.cp, pkg.cpv, [str(x) for x in pkgs_for_cp]))
+
+			highest_version = pkgs_for_cp[-1]
+			if pkg == highest_version:
+				# pkg is the highest version
+				protected_set.add("=" + pkg.cpv)
+				continue
+
+			if len(pkgs_for_cp) <= 1:
+				raise AssertionError("more packages expected: " + \
+					"cp = %s, cpv = %s matches = %s" % \
+					(pkg.cp, pkg.cpv, [str(x) for x in pkgs_for_cp]))
+
+			try:
+				if args_set.findAtomForPackage(pkg) is None:
+					protected_set.add("=" + pkg.cpv)
+					continue
+			except portage.exception.InvalidDependString as e:
+				show_invalid_depstring_notice(pkg,
+					pkg.metadata["PROVIDE"], str(e))
+				del e
+				protected_set.add("=" + pkg.cpv)
+				continue
+
+	if resolver._frozen_config.excluded_pkgs:
+		excluded_set = resolver._frozen_config.excluded_pkgs
+		required_sets['__excluded__'] = InternalPackageSet()
+
+		for pkg in vardb:
+			if spinner:
+				spinner.update()
+
+			try:
+				if excluded_set.findAtomForPackage(pkg):
+					required_sets['__excluded__'].add("=" + pkg.cpv)
+			except portage.exception.InvalidDependString as e:
+				show_invalid_depstring_notice(pkg,
+					pkg.metadata["PROVIDE"], str(e))
+				del e
+				required_sets['__excluded__'].add("=" + pkg.cpv)
+
+	success = resolver._complete_graph(required_sets={myroot:required_sets})
+	writemsg_level("\b\b... done!\n")
+
+	resolver.display_problems()
+
+	if not success:
+		return True, [], False, 0, []
+
+	def unresolved_deps():
+
+		unresolvable = set()
+		for dep in resolver._dynamic_config._initially_unsatisfied_deps:
+			if isinstance(dep.parent, Package) and \
+				(dep.priority > UnmergeDepPriority.SOFT):
+				unresolvable.add((dep.atom, dep.parent.cpv))
+
+		if not unresolvable:
+			return None
+
+		if unresolvable and not allow_missing_deps:
+
+			prefix = bad(" * ")
+			msg = []
+			msg.append("Dependencies could not be completely resolved due to")
+			msg.append("the following required packages not being installed:")
+			msg.append("")
+			for atom, parent in unresolvable:
+				msg.append("  %s pulled in by:" % (atom,))
+				msg.append("    %s" % (parent,))
+				msg.append("")
+			msg.extend(textwrap.wrap(
+				"Have you forgotten to do a complete update prior " + \
+				"to depclean? The most comprehensive command for this " + \
+				"purpose is as follows:", 65
+			))
+			msg.append("")
+			msg.append("  " + \
+				good("emerge --update --newuse --deep --with-bdeps=y @world"))
+			msg.append("")
+			msg.extend(textwrap.wrap(
+				"Note that the --with-bdeps=y option is not required in " + \
+				"many situations. Refer to the emerge manual page " + \
+				"(run `man emerge`) for more information about " + \
+				"--with-bdeps.", 65
+			))
+			msg.append("")
+			msg.extend(textwrap.wrap(
+				"Also, note that it may be necessary to manually uninstall " + \
+				"packages that no longer exist in the portage tree, since " + \
+				"it may not be possible to satisfy their dependencies.", 65
+			))
+			if action == "prune":
+				msg.append("")
+				msg.append("If you would like to ignore " + \
+					"dependencies then use %s." % good("--nodeps"))
+			writemsg_level("".join("%s%s\n" % (prefix, line) for line in msg),
+				level=logging.ERROR, noiselevel=-1)
+			return unresolvable
+		return None
+
+	unresolvable = unresolved_deps()
+	if not unresolvable is None:
+		return False, [], False, 0, unresolvable
+
+	graph = resolver._dynamic_config.digraph.copy()
+	required_pkgs_total = 0
+	for node in graph:
+		if isinstance(node, Package):
+			required_pkgs_total += 1
+
+	def show_parents(child_node):
+		parent_nodes = graph.parent_nodes(child_node)
+		if not parent_nodes:
+			# With --prune, the highest version can be pulled in without any
+			# real parent since all installed packages are pulled in.  In that
+			# case there's nothing to show here.
+			return
+		parent_strs = []
+		for node in parent_nodes:
+			parent_strs.append(str(getattr(node, "cpv", node)))
+		parent_strs.sort()
+		msg = []
+		msg.append("  %s pulled in by:\n" % (child_node.cpv,))
+		for parent_str in parent_strs:
+			msg.append("    %s\n" % (parent_str,))
+		msg.append("\n")
+		portage.writemsg_stdout("".join(msg), noiselevel=-1)
+
+	def cmp_pkg_cpv(pkg1, pkg2):
+		"""Sort Package instances by cpv."""
+		if pkg1.cpv > pkg2.cpv:
+			return 1
+		elif pkg1.cpv == pkg2.cpv:
+			return 0
+		else:
+			return -1
+
+	def create_cleanlist():
+
+		# Never display the special internal protected_set.
+		for node in graph:
+			if isinstance(node, SetArg) and node.name == protected_set_name:
+				graph.remove(node)
+				break
+
+		pkgs_to_remove = []
+
+		if action == "depclean":
+			if args_set:
+
+				for pkg in sorted(vardb, key=cmp_sort_key(cmp_pkg_cpv)):
+					arg_atom = None
+					try:
+						arg_atom = args_set.findAtomForPackage(pkg)
+					except portage.exception.InvalidDependString:
+						# this error has already been displayed by now
+						continue
+
+					if arg_atom:
+						if pkg not in graph:
+							pkgs_to_remove.append(pkg)
+						elif "--verbose" in myopts:
+							show_parents(pkg)
+
+			else:
+				for pkg in sorted(vardb, key=cmp_sort_key(cmp_pkg_cpv)):
+					if pkg not in graph:
+						pkgs_to_remove.append(pkg)
+					elif "--verbose" in myopts:
+						show_parents(pkg)
+
+		elif action == "prune":
+
+			for atom in args_set:
+				for pkg in vardb.match_pkgs(atom):
+					if pkg not in graph:
+						pkgs_to_remove.append(pkg)
+					elif "--verbose" in myopts:
+						show_parents(pkg)
+
+		return pkgs_to_remove
+
+	cleanlist = create_cleanlist()
+	clean_set = set(cleanlist)
+
+	if cleanlist and \
+		real_vardb._linkmap is not None and \
+		myopts.get("--depclean-lib-check") != "n" and \
+		"preserve-libs" not in settings.features:
+
+		# Check if any of these packages are the sole providers of libraries
+		# with consumers that have not been selected for removal. If so, these
+		# packages and any dependencies need to be added to the graph.
+		linkmap = real_vardb._linkmap
+		consumer_cache = {}
+		provider_cache = {}
+		consumer_map = {}
+
+		writemsg_level(">>> Checking for lib consumers...\n")
+
+		for pkg in cleanlist:
+			pkg_dblink = real_vardb._dblink(pkg.cpv)
+			consumers = {}
+
+			for lib in pkg_dblink.getcontents():
+				lib = lib[len(myroot):]
+				lib_key = linkmap._obj_key(lib)
+				lib_consumers = consumer_cache.get(lib_key)
+				if lib_consumers is None:
+					try:
+						lib_consumers = linkmap.findConsumers(lib_key)
+					except KeyError:
+						continue
+					consumer_cache[lib_key] = lib_consumers
+				if lib_consumers:
+					consumers[lib_key] = lib_consumers
+
+			if not consumers:
+				continue
+
+			for lib, lib_consumers in list(consumers.items()):
+				for consumer_file in list(lib_consumers):
+					if pkg_dblink.isowner(consumer_file):
+						lib_consumers.remove(consumer_file)
+				if not lib_consumers:
+					del consumers[lib]
+
+			if not consumers:
+				continue
+
+			for lib, lib_consumers in consumers.items():
+
+				soname = linkmap.getSoname(lib)
+
+				consumer_providers = []
+				for lib_consumer in lib_consumers:
+					providers = provider_cache.get(lib)
+					if providers is None:
+						providers = linkmap.findProviders(lib_consumer)
+						provider_cache[lib_consumer] = providers
+					if soname not in providers:
+						# Why does this happen?
+						continue
+					consumer_providers.append(
+						(lib_consumer, providers[soname]))
+
+				consumers[lib] = consumer_providers
+
+			consumer_map[pkg] = consumers
+
+		if consumer_map:
+
+			search_files = set()
+			for consumers in consumer_map.values():
+				for lib, consumer_providers in consumers.items():
+					for lib_consumer, providers in consumer_providers:
+						search_files.add(lib_consumer)
+						search_files.update(providers)
+
+			writemsg_level(">>> Assigning files to packages...\n")
+			file_owners = real_vardb._owners.getFileOwnerMap(search_files)
+
+			for pkg, consumers in list(consumer_map.items()):
+				for lib, consumer_providers in list(consumers.items()):
+					lib_consumers = set()
+
+					for lib_consumer, providers in consumer_providers:
+						owner_set = file_owners.get(lib_consumer)
+						provider_dblinks = set()
+						provider_pkgs = set()
+
+						if len(providers) > 1:
+							for provider in providers:
+								provider_set = file_owners.get(provider)
+								if provider_set is not None:
+									provider_dblinks.update(provider_set)
+
+						if len(provider_dblinks) > 1:
+							for provider_dblink in provider_dblinks:
+								provider_pkg = resolver._pkg(
+									provider_dblink.mycpv, "installed",
+									root_config, installed=True)
+								if provider_pkg not in clean_set:
+									provider_pkgs.add(provider_pkg)
+
+						if provider_pkgs:
+							continue
+
+						if owner_set is not None:
+							lib_consumers.update(owner_set)
+
+					for consumer_dblink in list(lib_consumers):
+						if resolver._pkg(consumer_dblink.mycpv, "installed",
+							root_config, installed=True) in clean_set:
+							lib_consumers.remove(consumer_dblink)
+							continue
+
+					if lib_consumers:
+						consumers[lib] = lib_consumers
+					else:
+						del consumers[lib]
+				if not consumers:
+					del consumer_map[pkg]
+
+		if consumer_map:
+			# TODO: Implement a package set for rebuilding consumer packages.
+
+			msg = "In order to avoid breakage of link level " + \
+				"dependencies, one or more packages will not be removed. " + \
+				"This can be solved by rebuilding " + \
+				"the packages that pulled them in."
+
+			prefix = bad(" * ")
+			from textwrap import wrap
+			writemsg_level("".join(prefix + "%s\n" % line for \
+				line in wrap(msg, 70)), level=logging.WARNING, noiselevel=-1)
+
+			msg = []
+			for pkg in sorted(consumer_map, key=cmp_sort_key(cmp_pkg_cpv)):
+				consumers = consumer_map[pkg]
+				consumer_libs = {}
+				for lib, lib_consumers in consumers.items():
+					for consumer in lib_consumers:
+						consumer_libs.setdefault(
+							consumer.mycpv, set()).add(linkmap.getSoname(lib))
+				unique_consumers = set(chain(*consumers.values()))
+				unique_consumers = sorted(consumer.mycpv \
+					for consumer in unique_consumers)
+				msg.append("")
+				msg.append("  %s pulled in by:" % (pkg.cpv,))
+				for consumer in unique_consumers:
+					libs = consumer_libs[consumer]
+					msg.append("    %s needs %s" % \
+						(consumer, ', '.join(sorted(libs))))
+			msg.append("")
+			writemsg_level("".join(prefix + "%s\n" % line for line in msg),
+				level=logging.WARNING, noiselevel=-1)
+
+			# Add lib providers to the graph as children of lib consumers,
+			# and also add any dependencies pulled in by the provider.
+			writemsg_level(">>> Adding lib providers to graph...\n")
+
+			for pkg, consumers in consumer_map.items():
+				for consumer_dblink in set(chain(*consumers.values())):
+					consumer_pkg = resolver._pkg(consumer_dblink.mycpv,
+						"installed", root_config, installed=True)
+					if not resolver._add_pkg(pkg,
+						Dependency(parent=consumer_pkg,
+						priority=UnmergeDepPriority(runtime=True),
+						root=pkg.root)):
+						resolver.display_problems()
+						return True, [], False, 0, []
+
+			writemsg_level("\nCalculating dependencies  ")
+			success = resolver._complete_graph(
+				required_sets={myroot:required_sets})
+			writemsg_level("\b\b... done!\n")
+			resolver.display_problems()
+			if not success:
+				return True, [], False, 0, []
+			unresolvable = unresolved_deps()
+			if not unresolvable is None:
+				return False, [], False, 0, unresolvable
+
+			graph = resolver._dynamic_config.digraph.copy()
+			required_pkgs_total = 0
+			for node in graph:
+				if isinstance(node, Package):
+					required_pkgs_total += 1
+			cleanlist = create_cleanlist()
+			if not cleanlist:
+				return 0, [], False, required_pkgs_total, unresolvable
+			clean_set = set(cleanlist)
+
+	if clean_set:
+		writemsg_level(">>> Calculating removal order...\n")
+		# Use a topological sort to create an unmerge order such that
+		# each package is unmerged before it's dependencies. This is
+		# necessary to avoid breaking things that may need to run
+		# during pkg_prerm or pkg_postrm phases.
+
+		# Create a new graph to account for dependencies between the
+		# packages being unmerged.
+		graph = digraph()
+		del cleanlist[:]
+
+		dep_keys = ["DEPEND", "RDEPEND", "PDEPEND"]
+		runtime = UnmergeDepPriority(runtime=True)
+		runtime_post = UnmergeDepPriority(runtime_post=True)
+		buildtime = UnmergeDepPriority(buildtime=True)
+		priority_map = {
+			"RDEPEND": runtime,
+			"PDEPEND": runtime_post,
+			"DEPEND": buildtime,
+		}
+
+		for node in clean_set:
+			graph.add(node, None)
+			mydeps = []
+			for dep_type in dep_keys:
+				depstr = node.metadata[dep_type]
+				if not depstr:
+					continue
+				priority = priority_map[dep_type]
+
+				try:
+					atoms = resolver._select_atoms(myroot, depstr,
+						myuse=node.use.enabled, parent=node,
+						priority=priority)[node]
+				except portage.exception.InvalidDependString:
+					# Ignore invalid deps of packages that will
+					# be uninstalled anyway.
+					continue
+
+				for atom in atoms:
+					if not isinstance(atom, portage.dep.Atom):
+						# Ignore invalid atoms returned from dep_check().
+						continue
+					if atom.blocker:
+						continue
+					matches = vardb.match_pkgs(atom)
+					if not matches:
+						continue
+					for child_node in matches:
+						if child_node in clean_set:
+							graph.add(child_node, node, priority=priority)
+
+		ordered = True
+		if len(graph.order) == len(graph.root_nodes()):
+			# If there are no dependencies between packages
+			# let unmerge() group them by cat/pn.
+			ordered = False
+			cleanlist = [pkg.cpv for pkg in graph.order]
+		else:
+			# Order nodes from lowest to highest overall reference count for
+			# optimal root node selection (this can help minimize issues
+			# with unaccounted implicit dependencies).
+			node_refcounts = {}
+			for node in graph.order:
+				node_refcounts[node] = len(graph.parent_nodes(node))
+			def cmp_reference_count(node1, node2):
+				return node_refcounts[node1] - node_refcounts[node2]
+			graph.order.sort(key=cmp_sort_key(cmp_reference_count))
+
+			ignore_priority_range = [None]
+			ignore_priority_range.extend(
+				range(UnmergeDepPriority.MIN, UnmergeDepPriority.MAX + 1))
+			while graph:
+				for ignore_priority in ignore_priority_range:
+					nodes = graph.root_nodes(ignore_priority=ignore_priority)
+					if nodes:
+						break
+				if not nodes:
+					raise AssertionError("no root nodes")
+				if ignore_priority is not None:
+					# Some deps have been dropped due to circular dependencies,
+					# so only pop one node in order to minimize the number that
+					# are dropped.
+					del nodes[1:]
+				for node in nodes:
+					graph.remove(node)
+					cleanlist.append(node.cpv)
+
+		return True, cleanlist, ordered, required_pkgs_total, []
+	return True, [], False, required_pkgs_total, []

diff --git a/gobs/pym/flags.py b/gobs/pym/flags.py
index ba9faf6..c2e3bcc 100644
--- a/gobs/pym/flags.py
+++ b/gobs/pym/flags.py
@@ -1,3 +1,4 @@
+from __future__ import print_function
 from _emerge.main import parse_opts
 from _emerge.depgraph import backtrack_depgraph, depgraph, resume_depgraph
 from _emerge.create_depgraph_params import create_depgraph_params
@@ -154,20 +155,21 @@ class gobs_use_flags(object):
 		return iuse_flags, final_flags
 
 	def get_needed_dep_useflags(self, build_use_flags_list):
+		cpv = self._cpv
 		tmpcmdline = []
 		tmpcmdline.append("-p")
 		tmpcmdline.append("--autounmask")
 		tmpcmdline.append("=" + self._cpv)
-		print tmpcmdline
+		print(tmpcmdline)
 		myaction, myopts, myfiles = parse_opts(tmpcmdline, silent=False)
-		print myaction, myopts, myfiles
+		print(myaction, myopts, myfiles)
 		myparams = create_depgraph_params(myopts, myaction)
-		print myparams
+		print(myparams)
 		settings, trees, mtimedb = load_emerge_config()
 		try:
 			success, mydepgraph, favorites = backtrack_depgraph(
 				settings, trees, myopts, myparams, myaction, myfiles, spinner=None)
-			print  success, mydepgraph, favorites
+			print(success, mydepgraph, favorites)
 		except portage.exception.PackageSetNotFound as e:
 			root_config = trees[settings["ROOT"]]["root_config"]
 			display_missing_pkg_set(root_config, e.value)
@@ -179,23 +181,22 @@ class gobs_use_flags(object):
 			use_changes = {}
 			for pkg, needed_use_config_changes in mydepgraph._dynamic_config._needed_use_config_changes.items():
 				new_use, changes = needed_use_config_changes
-				use_changes[pkg.self._cpv] = changes
-		print use_changes
+				use_changes[pkg.cpv] = changes
 		if use_changes is None:
 			return None
 		iteritems_packages = {}
 		for k, v in use_changes.iteritems():
 			k_package = portage.versions.cpv_getkey(k)
 			iteritems_packages[ k_package ] = v
-		print iteritems_packages
+		print('iteritems_packages', iteritems_packages)
 		return iteritems_packages
 							
 	def comper_useflags(self, build_dict):
 		iuse_flags, use_enable = self.get_flags()
 		iuse = []
-		print "use_enable", use_enable
+		print("use_enable", use_enable)
 		build_use_flags_dict = build_dict['build_useflags']
-		print "build_use_flags_dict", build_use_flags_dict
+		print("build_use_flags_dict", build_use_flags_dict)
 		build_use_flags_list = []
 		if use_enable == []:
 			if build_use_flags_dict is None:
@@ -209,10 +210,10 @@ class gobs_use_flags(object):
 			use_flagsDict[x] = True
 		for x in use_disable:
 			use_flagsDict[x] = False
-		print "use_flagsDict", use_flagsDict
+		print("use_flagsDict", use_flagsDict)
 		for k, v in use_flagsDict.iteritems():
-			print "tree use flags", k, v
-			print "db use flags", k, build_use_flags_dict[k]
+			print("tree use flags", k, v)
+			print("db use flags", k, build_use_flags_dict[k])
 		if build_use_flags_dict[k] != v:
 			if build_use_flags_dict[k] is True:
 				build_use_flags_list.append(k)
@@ -220,5 +221,5 @@ class gobs_use_flags(object):
 				build_use_flags_list.append("-" + k)
 		if build_use_flags_list == []:
 			build_use_flags_list = None
-		print build_use_flags_list
+		print(build_use_flags_list)
 		return build_use_flags_list

diff --git a/gobs/pym/old_cpv.py b/gobs/pym/old_cpv.py
index 9dacd82..8a1a9c5 100644
--- a/gobs/pym/old_cpv.py
+++ b/gobs/pym/old_cpv.py
@@ -1,3 +1,4 @@
+from __future__ import print_function
 class gobs_old_cpv(object):
 	
 	def __init__(self, CM, myportdb, mysettings):
@@ -25,14 +26,14 @@ class gobs_old_cpv(object):
 			# Set no active on ebuilds in the db that no longer in tree
 			if  old_ebuild_list != []:
 				for old_ebuild in old_ebuild_list:
-					print "O", categories + "/" + package + "-" + old_ebuild[0]
+					print("O", categories + "/" + package + "-" + old_ebuild[0])
 					self.dbquerys.add_old_ebuild(conn,package_id, old_ebuild_list)
 		# Check if we have older no activ ebuilds then 60 days
 		ebuild_old_list_db = self.dbquerys.cp_list_old_db(conn,package_id)
 		# Delete older ebuilds in the db
 		if ebuild_old_list_db != []:
 			for del_ebuild_old in ebuild_old_list_db:
-				print "D", categories + "/" + package + "-" + del_ebuild_old[1]
+				print("D", categories + "/" + package + "-" + del_ebuild_old[1])
 			self.dbquerys.del_old_ebuild(conn,ebuild_old_list_db)
 		self._CM.putConnection(conn)
 
@@ -52,14 +53,14 @@ class gobs_old_cpv(object):
 			if mark_old_list != []:
 				for x in mark_old_list:
 					element = self.dbquerys.get_cp_from_package_id(conn,x)
-					print "O", element[0]
+					print("O", element[0])
 			# Check if we have older no activ categories/package then 60 days
 			del_package_id_old_list = self.dbquerys.cp_all_old_db(conn,old_package_id_list)
 		# Delete older  categories/package and ebuilds in the db
 		if del_package_id_old_list != []:
 			for i in del_package_id_old_list:
 				element = self.dbquerys.get_cp_from_package_id(conn,i)
-				print "D", element
+				print("D", element)
 			self.dbquerys.del_old_package(conn,del_package_id_old_list)
 		self._CM.putConnection(conn)
 		
@@ -80,5 +81,5 @@ class gobs_old_cpv(object):
 		if categories_old_list != []:
 			for real_old_categories in categories_old_list:
 				self.dbquerys.del_old_categories(conn,real_old_categoriess)
-				print "D", real_old_categories
+				print("D", real_old_categories)
 		self._CM.putConnection(conn)
\ No newline at end of file

diff --git a/gobs/pym/package.py b/gobs/pym/package.py
index 46e13cb..4f0864d 100644
--- a/gobs/pym/package.py
+++ b/gobs/pym/package.py
@@ -1,3 +1,4 @@
+from __future__ import print_function
 import portage
 from gobs.flags import gobs_use_flags
 from gobs.repoman_gobs import gobs_repoman
@@ -157,37 +158,10 @@ class gobs_package(object):
 					# Comper ebuild_version and add the ebuild_version to buildqueue
 					if portage.vercmp(v['ebuild_version_tree'], latest_ebuild_version) == 0:
 						self._dbquerys.add_new_package_buildqueue(conn,ebuild_id, config_id, use_flags_list, use_enable_list, message)
-						print "B",  config_id, v['categories'] + "/" + v['package'] + "-" + latest_ebuild_version, "USE:", use_enable	# B = Build config cpv use-flags
+						print("B",  config_id, v['categories'] + "/" + v['package'] + "-" + latest_ebuild_version, "USE:", use_enable)	# B = Build config cpv use-flags
 					i = i +1
 		self._CM.putConnection(conn)
 
-	def add_new_ebuild_buildquery_db_looked(self, build_dict, config_profile):
-		conn=self._CM.getConnection()
-		myportdb = portage.portdbapi(mysettings=self._mysettings)
-		cpv = build_dict['cpv']
-		message = None
-		init_useflags = gobs_use_flags(self._mysettings, myportdb, cpv)
-		iuse_flags_list, final_use_list = init_useflags.get_flags_looked()
-		iuse = []
-		use_flags_list = []
-		use_enable_list = []
-		for iuse_line in iuse_flags_list:
-			iuse.append(init_useflags.reduce_flag(iuse_line))
-		iuse_flags_list2 = list(set(iuse))
-		use_enable = final_use_list
-		use_disable = list(set(iuse_flags_list2).difference(set(use_enable)))
-		use_flagsDict = {}
-		for x in use_enable:
-			use_flagsDict[x] = True
-		for x in use_disable:
-			use_flagsDict[x] = False
-		for u, s in  use_flagsDict.iteritems():
-			use_flags_list.append(u)
-			use_enable_list.append(s)
-		ebuild_id = self._dbquerys.get_ebuild_id_db_checksum(conn, build_dict)
-		self._dbquerys.add_new_package_buildqueue(conn, ebuild_id, config_profile, use_flags_list, use_enable_list, message)
-		self._CM.putConnection(conn)
-
 	def get_package_metadataDict(self, pkgdir, package):
 		# Make package_metadataDict
 		attDict = {}
@@ -206,7 +180,7 @@ class gobs_package(object):
 	def add_new_package_db(self, categories, package):
 		conn=self._CM.getConnection()
 		# add new categories package ebuild to tables package and ebuilds
-		print "N", categories + "/" + package				# N = New Package
+		print("N", categories + "/" + package)				# N = New Package
 		pkgdir = self._mysettings['PORTDIR'] + "/" + categories + "/" + package		# Get PORTDIR + cp
 		categories_dir = self._mysettings['PORTDIR'] + "/" + categories + "/"
 		# Get the ebuild list for cp
@@ -231,7 +205,7 @@ class gobs_package(object):
 			manifest_error = init_manifest.digestcheck()
 			if manifest_error is not None:
 				qa_error.append(manifest_error)
-				print "QA:", categories + "/" + package, qa_error
+				print("QA:", categories + "/" + package, qa_error)
 			self._dbquerys.add_qa_repoman(conn,ebuild_id_list, qa_error, packageDict, config_id)
 			# Add the ebuild to the buildqueru table if needed
 			self.add_new_ebuild_buildquery_db(ebuild_id_list, packageDict, config_cpv_listDict)
@@ -256,7 +230,7 @@ class gobs_package(object):
 		# if we have the same checksum return else update the package
 		ebuild_list_tree = self._myportdb.cp_list((categories + "/" + package), use_cache=1, mytree=None)
 		if manifest_checksum_tree != manifest_checksum_db:
-			print "U", categories + "/" + package		# U = Update
+			print("U", categories + "/" + package)		# U = Update
 			# Get package_metadataDict and update the db with it
 			package_metadataDict = self.get_package_metadataDict(pkgdir, package)
 			self._dbquerys.update_new_package_metadata(conn,package_id, package_metadataDict)
@@ -276,9 +250,9 @@ class gobs_package(object):
 					# Get packageDict for ebuild
 					packageDict[ebuild_line] = self.get_packageDict(pkgdir, ebuild_line, categories, package, config_id)
 					if ebuild_version_manifest_checksum_db is None:
-						print "N", categories + "/" + package + "-" + ebuild_version_tree	# N = New ebuild
+						print("N", categories + "/" + package + "-" + ebuild_version_tree)	# N = New ebuild
 					else:
-						print "U", categories + "/" + package + "-" + ebuild_version_tree	# U = Updated ebuild
+						print("U", categories + "/" + package + "-" + ebuild_version_tree)	# U = Updated ebuild
 						# Fix so we can use add_new_package_sql(packageDict) to update the ebuilds
 						old_ebuild_list.append(ebuild_version_tree)
 						self._dbquerys.add_old_ebuild(conn,package_id, old_ebuild_list)
@@ -297,7 +271,7 @@ class gobs_package(object):
 			manifest_error = init_manifest.digestcheck()
 			if manifest_error is not None:
 				qa_error.append(manifest_error)
-				print "QA:", categories + "/" + package, qa_error
+				print("QA:", categories + "/" + package, qa_error)
 			self._dbquerys.add_qa_repoman(conn,ebuild_id_list, qa_error, packageDict, config_id)
 			# Add the ebuild to the buildqueru table if needed
 			self.add_new_ebuild_buildquery_db(ebuild_id_list, packageDict, config_cpv_listDict)
@@ -324,4 +298,4 @@ class gobs_package(object):
 			self._dbquerys.add_old_ebuild(conn,package_id, old_ebuild_list)
 			self._dbquerys.update_active_ebuild(conn,package_id, ebuild_version_tree)
 		return_id = self._dbquerys.add_new_package_sql(conn,packageDict)
-		print 'return_id', return_id
\ No newline at end of file
+		print('return_id', return_id)
\ No newline at end of file

diff --git a/gobs/pym/text.py b/gobs/pym/text.py
index 9f5bb4e..2f1f689 100644
--- a/gobs/pym/text.py
+++ b/gobs/pym/text.py
@@ -1,3 +1,4 @@
+from __future__ import print_function
 import sys
 import re
 import os
@@ -7,10 +8,8 @@ def  get_file_text(filename):
 	# Return the filename contents
 	try:
 		textfile = open(filename)
-	except IOError, oe:
-		if oe.errno not in (errno.ENOENT, ):
-			raise
-			return "No file", filename
+	except:
+		return "No file", filename
 	text = ""
 	for line in textfile:
 		text += unicode(line, 'utf-8')
@@ -21,10 +20,8 @@ def  get_ebuild_text(filename):
 	"""Return the ebuild contents"""
 	try:
 		ebuildfile = open(filename)
-	except IOError, oe:
-		if oe.errno not in (errno.ENOENT, ):
-			raise
-			return "No Ebuild file there"
+	except:
+		return "No Ebuild file there"
 	text = ""
 	dataLines = ebuildfile.readlines()
 	for i in dataLines:
@@ -40,12 +37,10 @@ def  get_ebuild_text(filename):
 
 def  get_log_text_list(filename):
 	"""Return the log contents as a list"""
-	print "filename", filename
+	print("filename", filename)
 	try:
 		logfile = open(filename)
-	except IOError, oe:
-		if oe.errno not in (errno.ENOENT, ):
-			raise
+	except:
 		return None
 	text = []
 	dataLines = logfile.readlines()