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

[Magnus Granberg]

commit:     4931ada1a32903da715ec8809dbc6aa792521739
Author:     Magnus Granberg <zorry <AT> gentoo <DOT> org>
AuthorDate: Sat Jul 30 00:58:44 2011 +0000
Commit:     Magnus Granberg <zorry <AT> gentoo <DOT> org>
CommitDate: Sat Jul 30 00:58:44 2011 +0000
URL:        http://git.overlays.gentoo.org/gitweb/?p=dev/zorry.git;a=commit;h=4931ada1

Move pgsql.py

---
 gobs/pym/arch.py        |    9 +-
 gobs/pym/build_log.py   |    4 +-
 gobs/pym/build_queru.py |    4 +-
 gobs/pym/categories.py  |   11 +-
 gobs/pym/check_setup.py |    4 +-
 gobs/pym/old_cpv.py     |   29 +--
 gobs/pym/package.py     |   74 +++---
 gobs/pym/pgsql.py       |  596 +++++++++++++++++++++++++++++++++++++++++++++++
 setup.py                |    2 +-
 9 files changed, 659 insertions(+), 74 deletions(-)

diff --git a/gobs/pym/arch.py b/gobs/pym/arch.py
index 160de7c..7e11041 100644
--- a/gobs/pym/arch.py
+++ b/gobs/pym/arch.py
@@ -5,10 +5,7 @@ class gobs_arch(object):
 	def __init__(self, CM):
 		#selective import the pgsql/mysql queries
 		if CM.getName() is 'pgsql':
-			from gobs.querys import pgsql
-			self._dbquerys = pgsql
-		#elif CM.getName() == 'mysql':
-		#	import querys.mysql
+			from gobs.pgsql import *
 		self._CM = CM
 		self._conn = CM.getConnection()
 
@@ -18,10 +15,10 @@ class gobs_arch(object):
 	def update_arch_db(self):
 		# FIXME: check for new keyword
 		# Add arch db (keywords)
-		if self._dbquerys.get_arch_db(self._conn) is None:
+		if get_arch_db(self._conn) is None:
 			arch_list =  portage.archlist
 			for arch in arch_list:
 				if arch[0] not in ["~","-"]:
 					arch_list.append("-" + arch)
 					arch_list.append("-*")
-					self._dbquerys.add_new_arch_db(self._conn,arch_list)
\ No newline at end of file
+					add_new_arch_db(self._conn,arch_list)
\ No newline at end of file

diff --git a/gobs/pym/build_log.py b/gobs/pym/build_log.py
index eb5fcea..ccd8225 100644
--- a/gobs/pym/build_log.py
+++ b/gobs/pym/build_log.py
@@ -12,9 +12,7 @@ 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 *
+	from gobs.pgsql import *
 
 class gobs_buildlog(object):
 	

diff --git a/gobs/pym/build_queru.py b/gobs/pym/build_queru.py
index 3d53a05..f97884d 100644
--- a/gobs/pym/build_queru.py
+++ b/gobs/pym/build_queru.py
@@ -7,9 +7,7 @@ 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 *
+	from gobs.pgsql import *
 
 import portage
 import os

diff --git a/gobs/pym/categories.py b/gobs/pym/categories.py
index 636f114..f9f4367 100644
--- a/gobs/pym/categories.py
+++ b/gobs/pym/categories.py
@@ -9,10 +9,7 @@ class gobs_categories(object):
 		self._conn=CM.getConnection()
 		self._mysettings = mysettings
 		if CM.getName() is 'pgsql':
-		  from gobs.querys import pgsql
-		  self.dbquerys = pgsql
-		elif CM.getName() is 'mysql':
-		  import querys.mysql
+		  from gobs.pgsql import *
 	
 	def __del__(self):
 	 self._CM.putConnection(self._conn)
@@ -22,8 +19,8 @@ class gobs_categories(object):
 		categories_dir = self._mysettings['PORTDIR'] + "/" + categories + "/"
 		categories_metadata_xml_checksum_tree = portage.checksum.sha256hash(categories_dir + "metadata.xml")[0]
 		categories_metadata_xml_text_tree = get_file_text(categories_dir + "metadata.xml")
-		categories_metadata_xml_checksum_db = self.dbquerys.get_categories_checksum_db(self._conn, categories)
+		categories_metadata_xml_checksum_db = get_categories_checksum_db(self._conn, categories)
 		if categories_metadata_xml_checksum_db is None:
-			self.dbquerys.add_new_categories_meta_sql(self._conn,categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree)
+			add_new_categories_meta_sql(self._conn,categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree)
 		elif categories_metadata_xml_checksum_db != categories_metadata_xml_checksum_tree:
-			self.dbquerys.update_categories_meta_sql(self._conn,categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree)
+			update_categories_meta_sql(self._conn,categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree)

diff --git a/gobs/pym/check_setup.py b/gobs/pym/check_setup.py
index 47d1a08..b4d08e9 100644
--- a/gobs/pym/check_setup.py
+++ b/gobs/pym/check_setup.py
@@ -11,9 +11,7 @@ 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 *
+	from gobs.pgsql import *
 
 def check_make_conf(conn, gobs_settings_dict):
   # FIXME: mark any config updating true in the db when updating the configs

diff --git a/gobs/pym/old_cpv.py b/gobs/pym/old_cpv.py
index 8a1a9c5..c577033 100644
--- a/gobs/pym/old_cpv.py
+++ b/gobs/pym/old_cpv.py
@@ -6,16 +6,13 @@ class gobs_old_cpv(object):
 		self._mysettings = mysettings
 		self._myportdb = myportdb
 		if CM.getName() is 'pgsql':
-		  from gobs.querys import pgsql
-		  self.dbquerys = pgsql
-		elif CM.getName() is 'mysql':
-		  import querys.mysql
+		  from gobs.pgsql import *
 
 	def mark_old_ebuild_db(self, categories, package, package_id):
 		conn=self._CM.getConnection()
 		ebuild_list_tree = sorted(self._myportdb.cp_list((categories + "/" + package), use_cache=1, mytree=None))
 		# Get ebuild list on categories, package in the db
-		ebuild_list_db = self.dbquerys.cp_list_db(conn,package_id)
+		ebuild_list_db = cp_list_db(conn,package_id)
 		# Check if don't have the ebuild in the tree
 		# Add it to the no active list
 		old_ebuild_list = []
@@ -29,18 +26,18 @@ class gobs_old_cpv(object):
 					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)
+		ebuild_old_list_db = 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])
-			self.dbquerys.del_old_ebuild(conn,ebuild_old_list_db)
+			del_old_ebuild(conn,ebuild_old_list_db)
 		self._CM.putConnection(conn)
 
 	def mark_old_package_db(self, package_id_list_tree):
 		conn=self._CM.getConnection()
 		# Get categories/package list from db
-		package_list_db = self.dbquerys.cp_all_db(conn)
+		package_list_db = cp_all_db(conn)
 		old_package_id_list = []
 		# Check if don't have the categories/package in the tree
 		# Add it to the no active list
@@ -49,37 +46,37 @@ class gobs_old_cpv(object):
 				old_package_id_list.append(package_line)
 		# Set no active on categories/package and ebuilds in the db that no longer in tree
 		if old_package_id_list != []:
-			mark_old_list = self.dbquerys.add_old_package(conn,old_package_id_list)
+			mark_old_list = add_old_package(conn,old_package_id_list)
 			if mark_old_list != []:
 				for x in mark_old_list:
-					element = self.dbquerys.get_cp_from_package_id(conn,x)
+					element = get_cp_from_package_id(conn,x)
 					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)
+			del_package_id_old_list = 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)
+				element = get_cp_from_package_id(conn,i)
 				print("D", element)
-			self.dbquerys.del_old_package(conn,del_package_id_old_list)
+			del_old_package(conn,del_package_id_old_list)
 		self._CM.putConnection(conn)
 		
 	def mark_old_categories_db(self):
 		conn=self._CM.getConnection()
 		# Get categories list from the tree and db
 		categories_list_tree = self._mysettings.categories
-		categories_list_db =self.dbquerys.get_categories_db(conn)
+		categories_list_db =get_categories_db(conn)
 		categories_old_list = []
 		# Check if don't have the categories in the tree
 		# Add it to the no active list
 		for categories_line in categories_list_db:
 			if not categories_line[0] in categories_list_tree:
-				old_c = self.dbquerys.get_old_categories(conn,categories_line[0])
+				old_c = get_old_categories(conn,categories_line[0])
 				if old_c is not None:
 					categories_old_list.append(categories_line)
 		# Delete older  categories in the db
 		if categories_old_list != []:
 			for real_old_categories in categories_old_list:
-				self.dbquerys.del_old_categories(conn,real_old_categoriess)
+				del_old_categories(conn,real_old_categoriess)
 				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 4f0864d..f240e4e 100644
--- a/gobs/pym/package.py
+++ b/gobs/pym/package.py
@@ -5,19 +5,23 @@ from gobs.repoman_gobs import gobs_repoman
 from gobs.manifest import gobs_manifest
 from gobs.text import get_file_text, get_ebuild_text
 from gobs.old_cpv import gobs_old_cpv
+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
+from gobs.ConnectionManager import connectionManager
+CM=connectionManager(gobs_settings_dict)
+#selectively import the pgsql/mysql querys
+if CM.getName()=='pgsql':
+	from gobs.pgsql import *
 
 class gobs_package(object):
 
 	def __init__(self, mysettings, CM, myportdb, gobs_settings_dict):
 		self._mysettings = mysettings
-		self._CM = CM
 		self._gobs_settings_dict = gobs_settings_dict
 		self._myportdb = myportdb
-		if CM.getName() is 'pgsql':
-		  from gobs.querys import pgsql
-		  self._dbquerys = pgsql
-		elif CM.getName() is 'mysql':
-		  from gobs.querys import mysql
 
 	def change_config(self, config_id):
 		# Change config_root  config_id = table configs.id
@@ -26,10 +30,10 @@ class gobs_package(object):
 		return mysettings_setup
 
 	def config_match_ebuild(self, categories, package):
-		conn=self._CM.getConnection()
+		conn=CM.getConnection()
 		config_cpv_listDict ={}
 		# Get a list from table configs/setups with default_config=Fales and active = True
-		config_list_all  = self._dbquerys.get_config_list(conn)
+		config_list_all  = get_config_list(conn)
 		if config_list_all is ():
 			return config_cpv_listDict
 		for i in config_list_all:
@@ -65,7 +69,7 @@ class gobs_package(object):
 			# Clean some cache
 			myportdb_setup.close_caches()
 			portage.portdbapi.portdbapi_instances.remove(myportdb_setup)
-		self._CM.putConnection(conn)
+		CM.putConnection(conn)
 		return config_cpv_listDict
 
 	def get_ebuild_metadata(self, ebuild_line):
@@ -128,7 +132,7 @@ class gobs_package(object):
 		return metadataDict
 
 	def add_new_ebuild_buildquery_db(self, ebuild_id_list, packageDict, config_cpv_listDict):
-		conn=self._CM.getConnection()
+		conn=CM.getConnection()
 		# Get the needed info from packageDict and config_cpv_listDict and put that in buildqueue
 		# Only add it if ebuild_version in packageDict and config_cpv_listDict match
 		if config_cpv_listDict != {}:
@@ -157,10 +161,10 @@ class gobs_package(object):
 						use_enable_list.append(s)
 					# 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)
+						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
 					i = i +1
-		self._CM.putConnection(conn)
+		CM.putConnection(conn)
 
 	def get_package_metadataDict(self, pkgdir, package):
 		# Make package_metadataDict
@@ -178,7 +182,7 @@ class gobs_package(object):
 		return package_metadataDict
 
 	def add_new_package_db(self, categories, package):
-		conn=self._CM.getConnection()
+		conn=CM.getConnection()
 		# add new categories package ebuild to tables package and ebuilds
 		print("N", categories + "/" + package)				# N = New Package
 		pkgdir = self._mysettings['PORTDIR'] + "/" + categories + "/" + package		# Get PORTDIR + cp
@@ -186,19 +190,19 @@ class gobs_package(object):
 		# Get the ebuild list for cp
 		ebuild_list_tree = self._myportdb.cp_list((categories + "/" + package), use_cache=1, mytree=None)
 		config_cpv_listDict = self.config_match_ebuild(categories, package)
-		config_id  = self._dbquerys.get_default_config(conn)
+		config_id  = get_default_config(conn)
 		packageDict ={}
 		for ebuild_line in sorted(ebuild_list_tree):
 			# Make the needed packageDict
 			packageDict[ebuild_line] = self.get_packageDict(pkgdir, ebuild_line, categories, package, config_id)
 			# Add the ebuild to db
-			return_id = self._dbquerys.add_new_package_sql(conn,packageDict)
+			return_id = add_new_package_sql(conn,packageDict)
 			ebuild_id_list = return_id[0]
 			package_id_list = return_id[1]
 			package_id = package_id_list[0]
 			# Add metadataDict to db
 			metadataDict = self.get_metadataDict(packageDict, ebuild_id_list)
-			self._dbquerys.add_new_metadata(conn,metadataDict)
+			add_new_metadata(conn,metadataDict)
 			# Add any qa and repoman erro for the ebuild to buildlog
 			qa_error = []
 			init_manifest =  gobs_manifest(self._mysettings, pkgdir)
@@ -206,37 +210,37 @@ class gobs_package(object):
 			if manifest_error is not None:
 				qa_error.append(manifest_error)
 				print("QA:", categories + "/" + package, qa_error)
-			self._dbquerys.add_qa_repoman(conn,ebuild_id_list, qa_error, packageDict, config_id)
+			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)
 			# Add some checksum on some files
 			package_metadataDict = self.get_package_metadataDict(pkgdir, package)
-			self._dbquerys.add_new_package_metadata(conn,package_id, package_metadataDict)
+			add_new_package_metadata(conn,package_id, package_metadataDict)
 			# Add the manifest file to db
 			manifest_checksum_tree = portage.checksum.sha256hash(pkgdir + "/Manifest")[0]
 			get_manifest_text = get_file_text(pkgdir + "/Manifest")
-			self._dbquerys.add_new_manifest_sql(conn,package_id, get_manifest_text, manifest_checksum_tree)
-		self._CM.putConnection(conn)
+			add_new_manifest_sql(conn,package_id, get_manifest_text, manifest_checksum_tree)
+		CM.putConnection(conn)
 		return package_id
 
 	def update_package_db(self, categories, package, package_id):
-		conn=self._CM.getConnection()
+		conn=CM.getConnection()
 		# Update the categories and package with new info
 		pkgdir = self._mysettings['PORTDIR'] + "/" + categories + "/" + package		# Get PORTDIR with cp
 		# Get the checksum from the file in portage tree
 		manifest_checksum_tree = portage.checksum.sha256hash(pkgdir + "/Manifest")[0]
 		# Get the checksum from the db in package table
-		manifest_checksum_db = self._dbquerys.get_manifest_db(conn,package_id)
+		manifest_checksum_db = get_manifest_db(conn,package_id)
 		# 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
 			# 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)
+			update_new_package_metadata(conn,package_id, package_metadataDict)
 			# Get config_cpv_listDict
 			config_cpv_listDict = self.config_match_ebuild(categories, package)
-			config_id  = self._dbquerys.get_default_config(conn)
+			config_id  = get_default_config(conn)
 			packageDict ={}
 			for ebuild_line in sorted(ebuild_list_tree):
 				old_ebuild_list = []
@@ -244,7 +248,7 @@ class gobs_package(object):
 				ebuild_version_tree = portage.versions.cpv_getversion(ebuild_line)
 				# Get the checksum of the ebuild in tree and db
 				ebuild_version_checksum_tree = portage.checksum.sha256hash(pkgdir + "/" + package + "-" + ebuild_version_tree + ".ebuild")[0]
-				ebuild_version_manifest_checksum_db = self._dbquerys.get_ebuild_checksum(conn,package_id, ebuild_version_tree)
+				ebuild_version_manifest_checksum_db = get_ebuild_checksum(conn,package_id, ebuild_version_tree)
 				# Check if the checksum have change
 				if ebuild_version_manifest_checksum_db is None or ebuild_version_checksum_tree != ebuild_version_manifest_checksum_db:
 					# Get packageDict for ebuild
@@ -255,13 +259,13 @@ class gobs_package(object):
 						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)
-						self._dbquerys.update_active_ebuild(conn,package_id, ebuild_version_tree)
+						add_old_ebuild(conn,package_id, old_ebuild_list)
+						update_active_ebuild(conn,package_id, ebuild_version_tree)
 			# Use packageDictand and metadataDict to update the db
-			return_id = self._dbquerys.add_new_package_sql(conn,packageDict)
+			return_id = add_new_package_sql(conn,packageDict)
 			ebuild_id_list = return_id[0]
 			metadataDict = self.get_metadataDict(packageDict, ebuild_id_list)
-			self._dbquerys.add_new_metadata(conn,metadataDict)
+			add_new_metadata(conn,metadataDict)
 			# Get the text in Manifest and update it
 			get_manifest_text = get_file_text(pkgdir + "/Manifest")
 			self._dbquerys.update_manifest_sql(conn,package_id, get_manifest_text, manifest_checksum_tree)
@@ -272,16 +276,16 @@ class gobs_package(object):
 			if manifest_error is not None:
 				qa_error.append(manifest_error)
 				print("QA:", categories + "/" + package, qa_error)
-			self._dbquerys.add_qa_repoman(conn,ebuild_id_list, qa_error, packageDict, config_id)
+			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)
 			# Mark or remove any old ebuilds
 			init_old_cpv = gobs_old_cpv(self._CM, self._myportdb, self._mysettings)
 			init_old_cpv.mark_old_ebuild_db(categories, package, package_id)
-		self._CM.putConnection(conn)
+		CM.putConnection(conn)
 
 	def update_ebuild_db(self, build_dict):
-		conn=self._CM.getConnection()
+		conn=CM.getConnection()
 		config_id = build_dict['config_profile']
 		categories = build_dict['categories']
 		package = build_dict['package']
@@ -295,7 +299,7 @@ class gobs_package(object):
 		old_ebuild_list = []
 		if ebuild_version_manifest_checksum_db is not None:
 			old_ebuild_list.append(ebuild_version_tree)
-			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)
+			add_old_ebuild(conn,package_id, old_ebuild_list)
+			update_active_ebuild(conn,package_id, ebuild_version_tree)
+		return_id = add_new_package_sql(conn,packageDict)
 		print('return_id', return_id)
\ No newline at end of file

diff --git a/gobs/pym/pgsql.py b/gobs/pym/pgsql.py
new file mode 100644
index 0000000..021c37f
--- /dev/null
+++ b/gobs/pym/pgsql.py
@@ -0,0 +1,596 @@
+#every function takes a connection as a parameter that is provided by the CM
+from __future__ import print_function
+
+def get_default_config(connection):
+	cursor = connection.cursor()
+	sqlQ = 'SELECT id FROM configs WHERE default_config = True'
+	cursor.execute(sqlQ)
+	return cursor.fetchone()
+
+def get_profile_checksum(connection, config_profile):
+    cursor = connection.cursor()
+    sqlQ = "SELECT make_conf_checksum FROM configs WHERE active = 'True' AND id = %s AND updateing = 'False'"
+    cursor.execute(sqlQ, (config_profile,))
+    return cursor.fetchone()
+
+def get_packages_to_build(connection, config_profile):
+  cursor =connection.cursor()
+  # no point in returning dead ebuilds, to just chuck em out later
+  sqlQ1 = '''SELECT post_message, queue_id, ebuild_id FROM buildqueue WHERE config = %s AND extract(epoch from (NOW()) - timestamp) > 7200 ORDER BY queue_id LIMIT 1'''
+
+  sqlQ2 ='''SELECT ebuild_id,category,package_name,ebuild_version,ebuild_checksum FROM ebuilds,buildqueue,packages
+    WHERE buildqueue.ebuild_id=ebuilds.id AND ebuilds.package_id=packages.package_id AND queue_id = %s AND ebuilds.active = TRUE'''
+  
+  # get use flags to use
+  sqlQ3 = "SELECT useflag, enabled FROM ebuildqueuedwithuses WHERE queue_id = %s"
+  cursor.execute(sqlQ1, (config_profile,))
+  build_dict={}
+  entries = cursor.fetchone()
+  if entries is None:
+    return None
+  if entries[2] is None:
+    build_dict['ebuild_id'] = None
+    build_dict['queue_id'] = entries[1]
+    return build_dict
+  msg_list = []
+  if not entries[0] is None:
+    for msg in entries[0].split(" "):
+      msg_list.append(msg)
+  build_dict['post_message'] = msg_list
+  build_dict['queue_id'] = entries[1]
+  build_dict['ebuild_id']=entries[2]
+  cursor.execute(sqlQ2, (build_dict['queue_id'],))
+  #make a list that contains objects that haves ebuild_id and post_message +the lot as attributes
+  entries = cursor.fetchone()
+  if entries is None:
+    build_dict['checksum']= None
+    return build_dict
+  build_dict['ebuild_id']=entries[0]
+  build_dict['category']=entries[1]
+  build_dict['package']=entries[2]
+  build_dict['ebuild_version']=entries[3]
+  build_dict['checksum']=entries[4]
+
+  #add a enabled and disabled list to the objects in the item list
+  cursor.execute(sqlQ3, (build_dict['queue_id'],))
+  uses={}
+  for row in cursor.fetchall():
+    uses[ row[0] ] = row[1]
+  build_dict['build_useflags']=uses
+  return build_dict
+
+def check_revision(connection, build_dict):
+  cursor = connection.cursor()
+  sqlQ1 = 'SELECT queue_id FROM buildqueue WHERE ebuild_id = %s AND config = %s'
+  sqlQ2 = "SELECT useflag FROM ebuildqueuedwithuses WHERE queue_id = %s AND enabled = 'True'"
+  cursor.execute(sqlQ1, (build_dict['ebuild_id'], build_dict['config_profile']))
+  queue_id_list = cursor.fetchall()
+  print('queue_id_list',  queue_id_list)
+  if queue_id_list == []:
+    return None
+  for queue_id in queue_id_list:
+    print('queue_id after list', queue_id[0])
+    cursor.execute(sqlQ2, (queue_id[0],))
+    entries = cursor.fetchall()
+    build_useflags = []
+    if entries == []:
+      build_useflags = None
+    else:
+      for use_line in sorted(entries):
+	      build_useflags.append(use_line[0])
+    print("build_useflags build_dict['build_useflags']", build_useflags, build_dict['build_useflags'])
+    if build_useflags == build_dict['build_useflags']:
+      print('queue_id', queue_id[0])
+      return queue_id[0]
+  return None
+
+def get_config_list(connection):
+  cursor = connection.cursor()
+  sqlQ = 'SELECT id FROM configs WHERE default_config = False AND active = True'
+  cursor.execute(sqlQ)
+  return cursor.fetchall()
+
+def get_config_list_all(connection):
+  cursor = connection.cursor()
+  sqlQ = 'SELECT id FROM configs'
+  cursor.execute(sqlQ)
+  return cursor.fetchall()
+
+def update__make_conf(connection, configsDict):
+  cursor = connection.cursor()
+  sqlQ = 'UPDATE configs SET make_conf_checksum = %s, make_conf_text = %s, active = %s, config_error = %s WHERE id = %s'
+  for k, v in configsDict.iteritems():
+    params = [v['make_conf_checksum_tree'], v['make_conf_text'], v['active'], v['config_error'], k]
+    cursor.execute(sqlQ, params)
+  connection.commit()
+
+def have_package_db(connection, categories, package):
+  cursor = connection.cursor()
+  sqlQ ='SELECT package_id FROM packages WHERE category = %s AND package_name = %s'
+  params = categories, package
+  cursor.execute(sqlQ, params)
+  return cursor.fetchone()
+  
+def have_activ_ebuild_id(connection, ebuild_id):
+	cursor = connection.cursor()
+	sqlQ = 'SELECT ebuild_checksum FROM ebuilds WHERE id = %s AND active = TRUE'
+	cursor.execute(sqlQ, (ebuild_id,))
+	entries = cursor.fetchone()
+	if entries is None:
+		return None
+	# If entries is not None we need [0]
+	return entries[0]
+
+def get_categories_db(connection):
+  cursor = connection.cursor()
+  sqlQ =' SELECT category FROM categories'
+  cursor.execute(sqlQ)
+  return cursor.fetchall()
+
+def get_categories_checksum_db(connection, categories):
+  cursor = connection.cursor()
+  sqlQ =' SELECT metadata_xml_checksum FROM categories_meta WHERE category = %s'
+  cursor.execute(sqlQ, (categories,))
+  return cursor.fetchone()
+
+def add_new_categories_meta_sql(connection, categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree):
+  cursor = connection.cursor()
+  sqlQ = 'INSERT INTO categories_meta (category, metadata_xml_checksum, metadata_xml_text) VALUES  ( %s, %s, %s )'
+  params = categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree
+  cursor.execute(sqlQ, params)
+  connection.commit()
+
+def update_categories_meta_sql(connection, categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree):
+  cursor = connection.cursor()
+  sqlQ ='UPDATE categories_meta SET metadata_xml_checksum = %s, metadata_xml_text = %s WHERE category = %s'
+  params = (categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree, categories)
+  cursor.execute(sqlQ, params)
+  connection.commit()
+
+def add_new_manifest_sql(connection, package_id, get_manifest_text, manifest_checksum_tree):
+  cursor = connection.cursor()
+  sqlQ = 'INSERT INTO manifest (package_id, manifest, checksum) VALUES  ( %s, %s, %s )'
+  params = package_id, get_manifest_text, manifest_checksum_tree
+  cursor.execute(sqlQ, params)
+  connection.commit()
+
+def add_new_package_metadata(connection, package_id, package_metadataDict):
+  cursor = connection.cursor()
+  sqlQ = 'SELECT changelog_checksum FROM packages_meta WHERE package_id = %s'
+  cursor.execute(sqlQ, (package_id,))
+  if cursor.fetchone() is None:
+    sqlQ = 'INSERT INTO packages_meta (package_id, changelog_text, changelog_checksum, metadata_text, metadata_checksum) VALUES  ( %s, %s, %s, %s, %s )'
+    for k, v in package_metadataDict.iteritems():
+      params = package_id, v['changelog_text'], v['changelog_checksum'], v[' metadata_xml_text'], v['metadata_xml_checksum']
+      cursor.execute(sqlQ, params)
+    connection.commit()
+
+def update_new_package_metadata(connection, package_id, package_metadataDict):
+  cursor = connection.cursor()
+  sqlQ = 'SELECT changelog_checksum, metadata_checksum FROM packages_meta WHERE package_id = %s'
+  cursor.execute(sqlQ, package_id)
+  entries = cursor.fetchone()
+  if entries is None:
+    changelog_checksum_db = None
+    metadata_checksum_db = None
+  else:
+    changelog_checksum_db = entries[0]
+    metadata_checksum_db = entries[1]
+  for k, v in package_metadataDict.iteritems():
+    if changelog_checksum_db != v['changelog_checksum']:
+      sqlQ = 'UPDATE packages_meta SET changelog_text = %s, changelog_checksum = %s WHERE package_id = %s'
+      params = v['changelog_text'], v['changelog_checksum'], package_id
+      cursor.execute(sqlQ, params)
+    if metadata_checksum_db != v['metadata_xml_checksum']:
+      sqlQ = 'UPDATE packages_meta SET metadata_text = %s, metadata_checksum = %s WHERE package_id = %s'
+      params = v[' metadata_xml_text'], v['metadata_xml_checksum'], package_id
+      cursor.execute(sqlQ, params)
+  connection.commit()
+
+def get_manifest_db(connection, package_id):
+  cursor = connection.cursor()
+  sqlQ = 'SELECT checksum FROM manifest WHERE package_id = %s'
+  cursor.execute(sqlQ, package_id)
+  entries = cursor.fetchone()
+  if entries is None:
+	  return None
+  # If entries is not None we need [0]
+  return entries[0]
+
+def update_manifest_sql(connection, package_id, get_manifest_text, manifest_checksum_tree):
+  cursor = connection.cursor()
+  sqlQ = 'UPDATE manifest SET checksum = %s, manifest = %s WHERE package_id = %s'
+  params = (manifest_checksum_tree, get_manifest_text, package_id)
+  cursor.execute(sqlQ, params)
+  connection.commit()
+
+def add_new_metadata(connection, metadataDict):
+  cursor = connection.cursor()
+  for k, v in metadataDict.iteritems():
+    #moved the cursor out side of the loop
+    sqlQ = 'SELECT updaterestrictions( %s, %s )'
+    params = k, v['restrictions']
+    cursor.execute(sqlQ, params)
+    sqlQ = 'SELECT updatekeywords( %s, %s )'
+    params = k, v['keyword']
+    cursor.execute(sqlQ, params)
+    sqlQ = 'SELECT updateiuse( %s, %s )'
+    params = k, v['iuse']
+    cursor.execute(sqlQ, params)
+  connection.commit()
+
+def add_new_package_sql(connection, packageDict):
+  #lets have a new cursor for each metod as per best practice
+  cursor = connection.cursor()
+  sqlQ="SELECT insert_ebuild( %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'True')"
+  ebuild_id_list = []
+  package_id_list = []
+  for k, v in packageDict.iteritems():
+    params = [v['categories'], v['package'], v['ebuild_version_tree'], v['ebuild_version_revision'], v['ebuild_version_checksum_tree'],
+    v['ebuild_version_text'], v['ebuild_version_metadata_tree'][0], v['ebuild_version_metadata_tree'][1],
+    v['ebuild_version_metadata_tree'][12], v['ebuild_version_metadata_tree'][2], v['ebuild_version_metadata_tree'][3],
+    v['ebuild_version_metadata_tree'][5],v['ebuild_version_metadata_tree'][6], v['ebuild_version_metadata_tree'][7],
+    v['ebuild_version_metadata_tree'][9], v['ebuild_version_metadata_tree'][11],
+    v['ebuild_version_metadata_tree'][13],v['ebuild_version_metadata_tree'][14], v['ebuild_version_metadata_tree'][15],
+    v['ebuild_version_metadata_tree'][16]]
+    cursor.execute(sqlQ, params)
+    mid = cursor.fetchone()
+    mid=mid[0]
+    ebuild_id_list.append(mid[1])
+    package_id_list.append(mid[0])
+  connection.commit()
+  # add_new_metadata(metadataDict)
+  return ebuild_id_list, package_id_list
+
+def add_new_ebuild_sql(connection, packageDict, new_ebuild_list):
+  #lets have a new cursor for each metod as per best practice
+  cursor = connection.cursor()
+  sqlQ="SELECT insert_ebuild( %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'True')"
+  ebuild_id_list = []
+  package_id_list = []
+  for k, v in packageDict.iteritems():
+    for x in new_ebuild_list:
+      if x == v['ebuild_version_tree']:
+        params = [v['categories'], v['package'], v['ebuild_version_tree'], v['ebuild_version_revision'], v['ebuild_version_checksum_tree'],
+        v['ebuild_version_text'], v['ebuild_version_metadata_tree'][0], v['ebuild_version_metadata_tree'][1],
+        v['ebuild_version_metadata_tree'][12], v['ebuild_version_metadata_tree'][2], v['ebuild_version_metadata_tree'][3],
+        v['ebuild_version_metadata_tree'][5],v['ebuild_version_metadata_tree'][6], v['ebuild_version_metadata_tree'][7],
+        v['ebuild_version_metadata_tree'][9], v['ebuild_version_metadata_tree'][11],
+        v['ebuild_version_metadata_tree'][13],v['ebuild_version_metadata_tree'][14], v['ebuild_version_metadata_tree'][15],
+        v['ebuild_version_metadata_tree'][16]]
+        cursor.execute(sqlQ, params)
+        mid = cursor.fetchone()
+        mid=mid[0]
+        ebuild_id_list.append(mid[1])
+        package_id_list.append(mid[0])
+  connection.commit()
+  # add_new_metadata(metadataDict)
+  return ebuild_id_list, package_id_list
+
+def update_active_ebuild(connection, package_id, ebuild_version_tree):
+  cursor = connection.cursor()
+  sqlQ ="UPDATE ebuilds SET active = 'False', timestamp = now() WHERE package_id = %s AND ebuild_version = %s AND active = 'True'"
+  cursor.execute(sqlQ, (package_id, ebuild_version_tree))
+  connection.commit()
+
+def get_ebuild_id_db(connection, categories, package, ebuild_version_tree):
+	cursor = connection.cursor()
+	sqlQ ='SELECT id FROM packages WHERE category = %s AND ebuild_name = %s AND ebuild_version = %s'
+	cursor.execute(sqlQ, (categories, package, ebuild_version_tree))
+	entries = cursor.fetchone()
+	return entries
+
+def get_ebuild_id_db_checksum(connection, build_dict):
+	cursor = connection.cursor()
+	sqlQ = 'SELECT id FROM ebuilds WHERE ebuild_version = %s AND ebuild_checksum = %s AND package_id = %s'
+	cursor.execute(sqlQ, (build_dict['ebuild_version'], build_dict['checksum'], build_dict['package_id']))
+	ebuild_id = cursor.fetchone()
+	print('ebuild_id', ebuild_id)
+	if ebuild_id is None:
+		return None
+	return ebuild_id[0]
+
+def get_cpv_from_ebuild_id(connection, ebuild_id):
+	cursor = connection.cursor()
+	#wasent used
+	#sqlQ = 'SELECT package_id FROM ebuild WHERE id = %s'
+	sqlQ='SELECT category, ebuild_name, ebuild_version FROM packages WHERE id = %s'
+	cursor.execute(sqlQ, ebuild_id)
+	entries = cursor.fetchone()
+	return entries
+
+def get_cp_from_package_id(connection, package_id):
+  cursor =connection.cursor()
+  sqlQ = "SELECT ARRAY_TO_STRING(ARRAY[category, package_name] , '/') AS cp FROM packages WHERE package_id = %s"
+  cursor.execute(sqlQ, (package_id,))
+  return cursor.fetchone()
+
+def get_keyword_id_db(connection, arch, stable):
+	cursor =connection.cursor()
+	sqlQ ='SELECT id_keyword FROM keywords WHERE ARCH = %s AND stable = %s'
+	cursor.execute(sqlQ, (arch, stable))
+	entries = cursor.fetchone()
+	#why only return 1 entery? if that IS the point use top(1)
+	return entries
+	
+def add_new_keywords(connection, ebuild_id, keyword_id):
+	cursor = connection.cursor()
+	sqlQ ='INSERT INTO keywordsToEbuild (ebuild_id, id_keyword) VALUES  ( %s, %s )'
+	cursor.execute(sqlQ, (ebuild_id, keyword_id))
+	connection.commit()
+		
+def have_package_buildqueue(connection, ebuild_id, config_id):
+	cursor = connection.cursor()
+	sqlQ = 'SELECT useflags FROM buildqueue WHERE  ebuild_id = %s  AND config_id = %s'
+	params = (ebuild_id[0], config_id)
+	cursor.execute(sqlQ, params)
+	entries = cursor.fetchone()
+	return entries
+
+def add_new_package_buildqueue(connection, ebuild_id, config_id, iuse_flags_list, use_enable, message):
+  cursor = connection.cursor()
+  sqlQ="SELECT insert_buildqueue( %s, %s, %s, %s, %s )"
+  if not iuse_flags_list:
+    iuse_flags_list=None
+    use_enable=None
+  params = ebuild_id, config_id, iuse_flags_list, use_enable, message
+  cursor.execute(sqlQ, params)
+  connection.commit()
+  
+def get_ebuild_checksum(connection, package_id, ebuild_version_tree):
+  cursor = connection.cursor()
+  sqlQ = 'SELECT ebuild_checksum FROM ebuilds WHERE package_id = %s AND ebuild_version = %s AND active = TRUE'
+  cursor.execute(sqlQ, (package_id, ebuild_version_tree))
+  entries = cursor.fetchone()
+  if entries is None:
+	  return None
+ # If entries is not None we need [0]
+  return entries[0]
+
+def cp_all_db(connection):
+  cursor = connection.cursor()
+  sqlQ = "SELECT package_id FROM packages"
+  cursor.execute(sqlQ)
+  return cursor.fetchall()
+
+def add_old_package(connection, old_package_list):
+  cursor = connection.cursor()
+  mark_old_list = []
+  sqlQ = "UPDATE ebuilds SET active = 'FALSE', timestamp = NOW() WHERE package_id = %s AND active = 'TRUE' RETURNING package_id"
+  for old_package in old_package_list:
+    cursor.execute(sqlQ, (old_package[0],))
+    entries = cursor.fetchone()
+    if entries is not None:
+      mark_old_list.append(entries[0])
+  connection.commit()
+  return mark_old_list
+  
+def get_old_categories(connection, categories_line):
+  cursor = connection.cursor()
+  sqlQ = "SELECT package_name FROM packages WHERE category = %s"
+  cursor.execute(sqlQ (categories_line))
+  return cursor.fetchone()
+
+def del_old_categories(connection, real_old_categoriess):
+  cursor = connection.cursor()
+  sqlQ1 = 'DELETE FROM categories_meta WHERE category = %s'
+  sqlQ2 = 'DELETE FROM categories categories_meta WHERE category = %s'
+  cursor.execute(sqlQ1 (real_old_categories))
+  cursor.execute(sqlQ2 (real_old_categories))
+  connection.commit()
+
+def add_old_ebuild(connection, package_id, old_ebuild_list):
+  cursor = connection.cursor()
+  sqlQ1 = "UPDATE ebuilds SET active = 'FALSE' WHERE package_id = %s AND ebuild_version = %s"
+  sqlQ2 = "SELECT id FROM ebuilds WHERE package_id = %s AND ebuild_version = %s AND active = 'TRUE'"
+  sqlQ3 = "SELECT queue_id FROM buildqueue WHERE ebuild_id = %s"
+  sqlQ4 = 'DELETE FROM ebuildqueuedwithuses WHERE queue_id = %s'
+  sqlQ5 = 'DELETE FROM buildqueue WHERE queue_id = %s'
+  for old_ebuild in  old_ebuild_list:
+    cursor.execute(sqlQ2, (package_id, old_ebuild[0]))
+    ebuild_id_list = cursor.fetchall()
+    if ebuild_id_list is not None:
+      for ebuild_id in ebuild_id_list:
+        cursor.execute(sqlQ3, (ebuild_id))
+        queue_id_list = cursor.fetchall()
+        if queue_id_list is not None:
+          for queue_id in queue_id_list:
+            cursor.execute(sqlQ4, (queue_id))
+            cursor.execute(sqlQ5, (queue_id))
+        cursor.execute(sqlQ1, (package_id, old_ebuild[0]))
+  connection.commit()
+  
+def cp_all_old_db(connection, old_package_id_list):
+  cursor = connection.cursor()
+  old_package_list = []
+  for old_package in old_package_id_list:
+    sqlQ = "SELECT package_id FROM ebuilds WHERE package_id = %s AND active = 'FALSE' AND date_part('days', NOW() - timestamp) < 60"
+    cursor.execute(sqlQ, old_package)
+    entries = cursor.fetchone()
+    if entries is None:
+      old_package_list.append(old_package)
+  return old_package_list
+
+def del_old_queue(connection, queue_id):
+	cursor = connection.cursor()
+	sqlQ1 = 'DELETE FROM ebuildqueuedwithuses WHERE queue_id = %s'
+	sqlQ2 = 'DELETE FROM temp_errors_queue_qa WHERE queue_id  = %s'
+	sqlQ3 = 'DELETE FROM buildqueue WHERE queue_id  = %s'
+	cursor.execute(sqlQ1, (queue_id,))
+	cursor.execute(sqlQ2, (queue_id,))
+	cursor.execute(sqlQ3, (queue_id,))
+	connection.commit()
+
+def del_old_ebuild(connection, ebuild_old_list_db):
+	cursor = connection.cursor()
+	sqlQ1 = 'SELECT build_id FROM buildlog WHERE ebuild_id = %s'
+	sqlQ2 = 'DELETE FROM qa_problems WHERE build_id = %s'
+	sqlQ3 = 'DELETE FROM repoman_problems WHERE build_id = %s'
+	sqlQ4 = 'DELETE FROM ebuildbuildwithuses WHERE build_id = %s'
+	sqlQ5 = 'DELETE FROM ebuildhaveskeywords WHERE ebuild_id = %s'
+	sqlQ6 = 'DELETE FROM ebuildhavesiuses WHERE ebuild_id = %s'
+	sqlQ7 = 'DELETE FROM ebuildhavesrestrictions WHERE ebuild_id = %s'
+	sqlQ8 = 'DELETE FROM buildlog WHERE ebuild_id = %s'
+	sqlQ9 = 'SELECT queue_id FROM buildqueue WHERE ebuild_id = %s'
+	sqlQ10 = 'DELETE FROM ebuildqueuedwithuses WHERE queue_id = %s'
+	sqlQ11 = 'DELETE FROM buildqueue WHERE ebuild_id  = %s'
+	sqlQ12 = 'DELETE FROM ebuilds WHERE id  = %s'
+	for ebuild_id in ebuild_old_list_db:
+		cursor.execute(sqlQ1, (ebuild_id[0],))
+		build_id_list = cursor.fetchall()
+		if  build_id_list != []:
+			for build_id in build_id_list:
+				cursor.execute(sqlQ2, (build_id[0],))
+				cursor.execute(sqlQ3, (build_id[0],))
+				cursor.execute(sqlQ4, (build_id[0],))
+		cursor.execute(sqlQ9, (ebuild_id[0],))
+		queue_id_list = cursor.fetchall()
+		if queue_id_list != []:
+			for queue_id in queue_id_list:
+				cursor.execute(sqlQ10, (queue_id[0],))
+		cursor.execute(sqlQ5, (ebuild_id[0],))
+		cursor.execute(sqlQ6, (ebuild_id[0],))
+		cursor.execute(sqlQ7, (ebuild_id[0],))
+		cursor.execute(sqlQ8, (ebuild_id[0],))
+		cursor.execute(sqlQ11, (ebuild_id[0],))
+		cursor.execute(sqlQ12, (ebuild_id[0],))
+	connection.commit()
+  
+def del_old_package(connection, package_id_list):
+  cursor = connection.cursor()
+  sqlQ1 = 'SELECT id FROM ebuilds WHERE package_id = %s'
+  sqlQ2 = 'DELETE FROM ebuilds WHERE package_id = %s'
+  sqlQ3 = 'DELETE FROM manifest WHERE package_id = %s'
+  sqlQ4 = 'DELETE FROM packages_meta WHERE package_id = %s'
+  sqlQ5 = 'DELETE FROM packages WHERE package_id = %s'
+  for package_id in package_id_list:
+    cursor.execute(sqlQ1, package_id)
+    ebuild_id_list = cursor.fetchall()
+    del_old_ebuild(connection, ebuild_id_list)
+    cursor.execute(sqlQ2, (package_id,))
+    cursor.execute(sqlQ3, (package_id,))
+    cursor.execute(sqlQ4, (package_id,))
+    cursor.execute(sqlQ5, (package_id,))
+  connection.commit()
+
+def cp_list_db(connection, package_id):
+  cursor = connection.cursor()
+  sqlQ = "SELECT ebuild_version FROM ebuilds WHERE active = 'TRUE' AND package_id = %s"
+  cursor.execute(sqlQ, (package_id))
+  return cursor.fetchall()
+
+def cp_list_old_db(connection, package_id):
+  cursor = connection.cursor()
+  sqlQ ="SELECT id, ebuild_version FROM ebuilds WHERE active = 'FALSE' AND package_id = %s AND date_part('days', NOW() - timestamp) > 60"
+  cursor.execute(sqlQ, package_id)
+  return cursor.fetchall()
+
+def move_queru_buildlog(connection, queue_id, build_error, summary_error, build_log_dict):
+	cursor = connection.cursor()
+	print('queue_id', queue_id)
+	print('build_log_dict', build_log_dict)
+	repoman_error_list = build_log_dict['repoman_error_list']
+	qa_error_list = build_log_dict['qa_error_list']
+	sqlQ = 'SELECT make_buildlog( %s, %s, %s, %s, %s, %s)'
+	cursor.execute(sqlQ, (queue_id, summary_error, build_error, build_log_dict['logfilename'], qa_error_list, repoman_error_list))
+	entries = cursor.fetchone()
+	connection.commit()
+	return entries
+
+def add_new_buildlog(connection, build_dict, use_flags_list, use_enable_list, build_error, summary_error, build_log_dict):
+	cursor = connection.cursor()
+	repoman_error_list = build_log_dict['repoman_error_list']
+	qa_error_list = build_log_dict['qa_error_list']
+	if not use_flags_list:
+    		use_flags_list=None
+    		use_enable=None
+    	print('make_deplog', build_dict['ebuild_id'], build_dict['config_profile'], use_flags_list, use_enable_list, summary_error, build_error, build_log_dict['logfilename'], qa_error_list, repoman_error_list)
+	sqlQ = 'SELECT make_deplog( %s, %s, %s, %s, %s, %s, %s, %s, %s)'
+	params = (build_dict['ebuild_id'], build_dict['config_profile'], use_flags_list, use_enable_list, summary_error, build_error, build_log_dict['logfilename'], qa_error_list, repoman_error_list)
+	cursor.execute(sqlQ, params)
+	entries = cursor.fetchone()
+	connection.commit()
+	return entries
+
+def add_qa_repoman(connection, ebuild_id_list, qa_error, packageDict, config_id):
+  cursor = connection.cursor()
+  ebuild_i = 0
+  for k, v in packageDict.iteritems():
+    ebuild_id = ebuild_id_list[ebuild_i]
+    sqlQ = "INSERT INTO buildlog (ebuild_id, config, error_summary, timestamp, hash ) VALUES  ( %s, %s, %s, now(), '1' ) RETURNING build_id"
+    if v['ebuild_error'] != [] or qa_error != []:
+      if v['ebuild_error'] != [] or qa_error == []:
+        summary = "Repoman"
+      elif v['ebuild_error'] == [] or qa_error != []:
+        summary = "QA"
+      else:
+        summary = "QA:Repoman"
+      params = (ebuild_id, config_id, summary)
+      cursor.execute(sqlQ, params)
+      build_id = cursor.fetchone()
+      if v['ebuild_error'] != []:
+        sqlQ = 'INSERT INTO repoman_problems (problem, build_id ) VALUES ( %s, %s )'
+        for x in v['ebuild_error']:
+          params = (x, build_id)
+          cursor.execute(sqlQ, params)
+      if qa_error != []:
+        sqlQ = 'INSERT INTO qa_problems (problem, build_id ) VALUES ( %s, %s )'
+        for x in qa_error:
+          params = (x, build_id)
+          cursor.execute(sqlQ, params)
+    ebuild_i = ebuild_i +1
+  connection.commit()
+
+def update_qa_repoman(connection, build_id, build_log_dict):
+	cursor = connection.cursor()
+	sqlQ1 = 'INSERT INTO repoman_problems (problem, build_id ) VALUES ( %s, %s )'
+	sqlQ2 = 'INSERT INTO qa_problems (problem, build_id ) VALUES ( %s, %s )'
+	if build_log_dict['repoman_error_list'] != []:
+		for x in build_log_dict['repoman_error_list']:
+			params = (x, build_id)
+			cursor.execute(sqlQ, params)
+	if build_log_dict['qa_error_list'] != []:
+		for x in build_log_dict['qa_error_list']:
+			params = (x, build_id)
+			cursor.execute(sqlQ, params)
+	connection.commit()
+
+def get_arch_db(connection):
+  cursor = connection.cursor()
+  sqlQ = "SELECT keyword FROM keywords WHERE keyword = 'amd64'"
+  cursor.execute(sqlQ)
+  return cursor.fetchone()
+
+def add_new_arch_db(connection, arch_list):
+  cursor = connection.cursor()
+  sqlQ = 'INSERT INTO keywords (keyword) VALUES  ( %s )'
+  for arch in arch_list:
+    cursor.execute(sqlQ, (arch,))
+  connection.commit()
+
+def check_fail_times(connection, logDict):
+	queue_id = logDict['queue_id']
+	qa_error = logDict['qa_error_list'][0]
+	cursor = connection.cursor()
+	sqlQ = 'SELECT errors FROM temp_errors_queue_qa WHERE queue_id = %s AND what_error = %s'
+	cursor.execute(sqlQ, (queue_id, qa_error,))
+	return cursor.fetchone()
+
+def add_fail_times(connection, logDict):
+	queue_id = logDict['queue_id']
+	qa_error = logDict['qa_error_list'][0]
+	cursor = connection.cursor()
+	sqlQ = 'INSERT INTO temp_errors_queue_qa (queue_id, what_error) VALUES ( %s, %s)'
+	cursor.execute(sqlQ, (queue_id, qa_error,))
+	connection.commit()
+
+def update_fail_times(connection, logDict):
+	queue_id = logDict['queue_id']
+	qa_error = logDict['qa_error_list'][0]
+	cursor = connection.cursor()
+	sqlQ1 = 'UPDATE buildqueue SET timestamp = NOW() WHERE queue_id = %s'
+	cursor.execute(sqlQ1, (queue_id,))
+	connection.commit()
+
+def make_conf_error(connection,config_profile):
+  pass

diff --git a/setup.py b/setup.py
index 4ad9586..4042077 100644
--- a/setup.py
+++ b/setup.py
@@ -15,7 +15,7 @@ version = os.path.split(os.path.abspath(__file__))[-2].split('-')[-1]
 
 packages = ['gobs']
 
-package_dir = {'gobs': 'gobs/pym','gobs/pym/querys'}
+package_dir = {'gobs': 'gobs/pym'}
 
 setup(
 	name="gobs",