modulitiz-micro 2.60.0__py312-none-any.whl

modulitiz_micro/ModuloSeriale.py

@@ -0,0 +1,70 @@
+import serial
+
+from modulitiz_nano.ModuloStringhe import ModuloStringhe
+from modulitiz_nano.sistema.ModuloSystem import ModuloSystem
+
+
+class ModuloSeriale(object):
+	"""
+	Utility di gestione dela connessione seriale RS232
+	"""
+	
+	COM_PORTS=[]
+	
+	def __init__(self):
+		self.connessione=None
+	
+	@classmethod
+	def populate(cls):
+		"""
+		Popola le variabili di classe.
+		"""
+		if ModuloSystem.isWindows():
+			COM_PORTS=cls.__generaElencoPorte("COM",1)
+		else:
+			COM_PORTS=cls.__generaElencoPorte("/dev/tty",0)
+			COM_PORTS.extend(cls.__generaElencoPorte("/dev/ttyS",0))
+			COM_PORTS.extend(cls.__generaElencoPorte("/dev/ttyUSB",0))
+		cls.COM_PORTS=COM_PORTS
+	
+	def apriPrimaPortaDisponibile(self):
+		"""
+		Prova ad aprire la prima porta disponibile che trova.
+		"""
+		for port in self.COM_PORTS:
+			try:
+				connessioneSeriale=serial.Serial(port=port, baudrate=9600, rtscts=True, dsrdtr=True, exclusive=True)
+				connessioneSeriale.dtr=True
+				connessioneSeriale.dtr=False
+				self.connessione=connessioneSeriale
+				return
+			except OSError:
+				pass
+	
+	def isOpen(self)->bool:
+		"""
+		Controlla se la connessione alla porta è aperta.
+		"""
+		return self.connessione is not None and self.connessione.isOpen()
+	
+	def read(self, port: str,baudrate: int,exitCallback):
+		"""
+		Reads serial strings and prints it to standard output.
+		"""
+		self.connessione=serial.Serial(port,baudrate,timeout=1)
+		while not exitCallback():
+			print(self.connessione.readline().decode(ModuloStringhe.CODIFICA_UTF8,"replace"),end="")
+		self.close()
+	
+	def close(self):
+		"""
+		Chiude la connessione alla porta.
+		"""
+		if not self.isOpen():
+			return
+		self.connessione.close()
+		self.connessione=None
+
+	@staticmethod
+	def __generaElencoPorte(prefisso:str,inizio:int)->list:
+		return [prefisso+str(i) for i in range(inizio,16)]

modulitiz_micro/SunUtil.py

@@ -0,0 +1,21 @@
+from datetime import datetime
+
+from suntime import Sun
+
+from modulitiz_nano.ModuloDate import ModuloDate
+
+
+class SunUtil(object):
+	@staticmethod
+	def getLocalSunrise(lat: float,long: float,dateTime: datetime|None = None) -> datetime:
+		if dateTime is None:
+			dateTime=ModuloDate.now()
+		sun=Sun(lat,long)
+		return sun.get_sunrise_time(dateTime,ModuloDate.getTimezoneLocal(dateTime))
+	
+	@staticmethod
+	def getLocalSunset(lat: float,long: float,dateTime: datetime|None = None) -> datetime:
+		if dateTime is None:
+			dateTime=ModuloDate.now()
+		sun=Sun(lat,long)
+		return sun.get_sunset_time(dateTime,ModuloDate.getTimezoneLocal(dateTime))

modulitiz_micro/database/AbstractDatabaseService.py

@@ -0,0 +1,13 @@
+import threading
+from abc import ABC
+
+from modulitiz_nano.files.ModuloLogging import ModuloLogging
+
+
+class AbstractDatabaseService(ABC):
+	
+	def __init__(self,logger:ModuloLogging):
+		self._logger=logger
+		self.lock=threading.Lock()
+		
+		self.database=None

modulitiz_micro/database/AbstractSql.py

@@ -0,0 +1,69 @@
+import threading
+from abc import ABC
+
+from modulitiz_nano.ModuloStringhe import ModuloStringhe
+
+
+class AbstractSql(ABC):
+	def __init__(self):
+		self.connDb=None
+		self.lock=threading.Lock()
+	
+	def commit(self):
+		"""
+		Use to make modifications permanents.
+		"""
+		with self.lock:
+			self.commitNoLock()
+	
+	def commitNoLock(self):
+		"""
+		Use only if lock is made externally.
+		"""
+		self.connDb.commit()
+	
+	def rollback(self):
+		"""
+		Undo last uncommitted operations.
+		"""
+		with self.lock:
+			self.connDb.rollback()
+	
+	def initCursor(self):
+		"""
+		Creates cursor objects, it's needed to read/write database.
+		"""
+		with self.lock:
+			cursoreDb=self.connDb.cursor()
+		return cursoreDb
+	
+	def fetchOne(self,cursoreDb):
+		"""
+		Retrieve first row of query
+		"""
+		with cursoreDb:
+			with self.lock:
+				result=cursoreDb.fetchone()
+		if not result:
+			return None
+		return result[0]
+	
+	def count(self,cursoreDb)->int:
+		with cursoreDb:
+			with self.lock:
+				result=cursoreDb.fetchone()
+		if not result:
+			return 0
+		return result[0]
+	
+	def close(self):
+		with self.lock:
+			if self.connDb is not None:
+				self.connDb.close()
+				self.connDb=None
+	
+	@staticmethod
+	def ifEmptyThenNull(testo:str|None)->str|None:
+		if ModuloStringhe.isEmpty(testo) or testo=="NULL":
+			return None
+		return testo

modulitiz_micro/database/ModuloSqlOracle.py

@@ -0,0 +1,19 @@
+import oracledb
+
+from modulitiz_micro.database.ModuloSqlServer import ModuloSqlServer
+
+
+class ModuloSqlOracle(ModuloSqlServer):
+	DEFAULT_PORT=1521
+	
+	def __init__(self,port:int|None,*args,**kwargs):
+		super().__init__(*args,**kwargs)
+		if port is None:
+			port=self.DEFAULT_PORT
+		self.port=port
+	
+	def connessione(self):
+		dsn="{}/{}@{}:{}/xe".format(self.username,self.password,self.host,self.port)
+		self.connDb=oracledb.connect(dsn)
+		self.connDb=dsn
+	

modulitiz_micro/database/ModuloSqlServer.py

@@ -0,0 +1,43 @@
+import pypyodbc
+
+from modulitiz_micro.database.AbstractSql import AbstractSql
+
+
+class ModuloSqlServer(AbstractSql):
+	ERROR_CODE__UNIQUE_INDEX=23000
+	
+	def __init__(self,host:str,nome_db:str,username:str,password:str):
+		super().__init__()
+		self.host=host
+		self.nome_db=nome_db
+		self.username=username
+		self.password=password
+		
+	def connessione(self):
+		connDb=pypyodbc.connect("Driver={SQL Server};Server="+self.host+";Database="+self.nome_db+";uid="+self.username+";pwd="+self.password+";")
+		self.connDb=connDb
+	
+	def select(self,sql:str,params:list):
+		with self.initCursor() as cursoreDb:
+			cursoreDb.execute(sql,params)
+			results=list(cursoreDb)
+		return results
+	
+	def select_count(self,cursoreDb,sql:str,params:list)->int:
+		with cursoreDb:
+			cursoreDb.execute(sql,params)
+			output=self.count(cursoreDb)
+		return output
+	
+	def modifica(self,cursoreDb,sql:str,params:list,ignore_unique_index:bool):
+		"""
+		Use it for data modifications like: insert, update, delete
+		"""
+		try:
+			cursoreDb.execute(sql,params)
+		except pypyodbc.IntegrityError as ie:
+			if ignore_unique_index:
+				error_code=int(ie.value[0])
+				if error_code!=self.ERROR_CODE__UNIQUE_INDEX:
+					raise ie
+	

modulitiz_micro/database/exceptions/ExceptionDbNoData.py

@@ -0,0 +1,7 @@
+from modulitiz_nano.exceptions.ExceptionNoData import ExceptionNoData
+
+
+class ExceptionDbNoData(ExceptionNoData):
+	
+	def __init__(self,*args):
+		super().__init__(*args)

modulitiz_micro/database/mysql/AbstractBasicMysql.py

@@ -0,0 +1,114 @@
+from abc import abstractmethod
+
+from modulitiz_nano.ModuloStringhe import ModuloStringhe
+from modulitiz_micro.database.mysql.ModuloMysql import ModuloMysql
+
+
+class AbstractBasicMysql(ModuloMysql):
+	
+	def __init__(self,*args,**kwargs):
+		super().__init__(*args,**kwargs)
+	
+	def initDdlBasicTables(self):
+		if not self.isDbNew:
+			return
+		sqlStr=ModuloStringhe.normalizzaEol(self.schemaBasicTables())
+		for results in self.executeScript(sqlStr):
+			yield results
+		sqlInsertBasicTables=self.insertBasicTables()
+		if not ModuloStringhe.isEmpty(sqlInsertBasicTables):
+			sqlInsertBasicTables=ModuloStringhe.normalizzaEol(sqlInsertBasicTables)
+			for results in self.executeScript(sqlInsertBasicTables):
+				yield results
+		self.commit()
+	
+	def schemaBasicTables(self):
+		return """
+
+CREATE TABLE tb_params(
+	id						INT UNSIGNED AUTO_INCREMENT PRIMARY KEY NOT NULL,
+	type1					CHAR(30) NOT NULL,
+	key1					CHAR(30) NOT NULL,
+	desc1					CHAR(100) NOT NULL,
+	enabled					BOOLEAN NOT NULL,
+	lang_code				CHAR(2) NULL,
+	data_insert				DATETIME NOT NULL
+)"""+self.TABLE_OPTIONS+""";
+CREATE UNIQUE INDEX PARAMS__UK1 ON tb_params(type1,key1,lang_code);
+
+"""
+	
+	@abstractmethod
+	def insertBasicTables(self):
+		"""
+		Inserire le istruzioni sql che vanno eseguite alla fine di tutto
+		"""
+	
+	
+	
+	#############################################################################################################################
+	#############################################################################################################################
+	#############################################################################################################################
+	def selectParamDescByEntries(self,paramType:str,paramKey:str|None)->str|None:
+		cursoreDb=self.selectParamByEntries(paramType, paramKey, None, True)
+		results=self.fetchAll(cursoreDb)
+		if len(results)==0:
+			return None
+		result=results[0]
+		return result['desc1']
+	
+	def selectParamByEntries(self,paramType:str,paramKey:str|None,langCode:str|None,enabled:bool|None):
+		addParamKey=ModuloStringhe.isEmpty(paramKey) is False
+		addLangCode=ModuloStringhe.isEmpty(langCode) is False
+		addEnabled=enabled is not None
+		
+		sql="""
+SELECT *
+FROM tb_params
+WHERE type1=%(paramType)s
+"""+("AND key1=%(paramKey)s" if addParamKey is True else "")+"""
+"""+("AND langCode=%(langCode)s" if addLangCode is True else "")+"""
+"""+("AND enabled=%(enabled)s" if addEnabled is True else "")+"""
+;
+"""
+		params= {'paramType': paramType}
+		if addParamKey is True:
+			params['paramKey']=paramKey
+		if addLangCode is True:
+			params['langCode']=langCode
+		if addEnabled is True:
+			params['enabled']=enabled
+		
+		cursoreDb=self.initCursor()
+		with self.lock:
+			cursoreDb.execute(sql,params)
+		return cursoreDb
+	
+	
+	def updateParamDesc(self,paramType:str,paramKey:str|None,newDesc:str|None):
+		addParamKey=ModuloStringhe.isEmpty(paramKey) is False
+		addNewDesc=ModuloStringhe.isEmpty(newDesc) is False
+		
+		sqlSet=[]
+		if addNewDesc is True:
+			sqlSet.append("desc1=%(newDesc)s")
+		sqlSet=", ".join(sqlSet)
+		
+		sql="""
+UPDATE tb_params
+SET """+sqlSet+"""
+WHERE type1=%(paramType)s
+"""+("AND key1=%(paramKey)s" if addParamKey is True else "")+"""
+;
+"""
+		params={}
+		if addNewDesc is True:
+			params['newDesc']=newDesc
+		params['paramType']=paramType
+		if addParamKey is True:
+			params['paramKey']=paramKey
+		cursoreDb=self.initCursor()
+		with self.lock:
+			cursoreDb.execute(sql,params)
+		return cursoreDb
+	

modulitiz_micro/database/mysql/ModuloMysql.py

@@ -0,0 +1,162 @@
+from abc import abstractmethod
+
+import mysql.connector
+
+from modulitiz_micro.database.AbstractSql import AbstractSql
+from modulitiz_micro.database.exceptions.ExceptionDbNoData import ExceptionDbNoData
+from modulitiz_micro.database.mysql.MysqlCommonConverter import MysqlCommonConverter
+from modulitiz_nano.ModuloListe import ModuloListe
+from modulitiz_nano.ModuloStringhe import ModuloStringhe
+from modulitiz_nano.exceptions.ExceptionRuntime import ExceptionRuntime
+from modulitiz_nano.exceptions.ExceptionUtil import ExceptionUtil
+from modulitiz_nano.files.ModuloFiles import ModuloFiles
+from modulitiz_nano.sistema.ModuloSystem import ModuloSystem
+
+
+class ModuloMysql(AbstractSql):
+	"""
+	select
+	count
+	insert
+	update
+	delete
+	"""
+	
+	DATE_TIME_NOW="NOW()"
+	
+	DEFAULT_PORT=3306
+	
+	
+	def __init__(self,host: str,port: int|None,user: str,password: str,nomeDb: str,isDebug: bool):
+		super().__init__()
+		self.nomeDb=nomeDb
+		if port is None:
+			port=self.DEFAULT_PORT
+		# apro la connessione col server
+		self.connDb=mysql.connector.connect(user=user,password=password,host=host,port=port,
+				converter_class=MysqlCommonConverter)
+		self.TABLE_OPTIONS=self.getTableOptions(isDebug)
+		self.isDbNew=None
+	
+	@abstractmethod
+	def schema(self):
+		"""
+		Insert here sql instructions containing table definitions (DDL)
+		"""
+	
+	def initDdl(self):
+		#scelgo il db
+		try:
+			self.connDb.cmd_init_db(self.nomeDb)
+			self.isDbNew=False
+		except mysql.connector.ProgrammingError:
+			sqlCreaDb="CREATE DATABASE %s;"%(self.nomeDb,)
+			with self.initCursor() as cursoreDb:
+				with self.lock:
+					cursoreDb.execute(sqlCreaDb)
+			self.connDb.cmd_init_db(self.nomeDb)
+			self.isDbNew=True
+		#se il db non esisteva creo le tabelle
+		if self.isDbNew:
+			sqlStr=ModuloStringhe.normalizzaEol(self.schema())
+			for results in self.executeScript(sqlStr):
+				yield results
+	
+	@staticmethod
+	def getLastIdInserted(cursoreDb):
+		return cursoreDb.lastrowid
+	
+	def selectNow(self):
+		"""
+		Returns current db date and time.
+		"""
+		sql="SELECT {};".format(self.DATE_TIME_NOW)
+		with self.initCursor() as cursoreDb:
+			with self.lock:
+				cursoreDb.execute(sql,{})
+			output=self.fetchOne(cursoreDb)
+		return output
+	
+	def executeScript(self,sqlStr:str):
+		sqlCmds=sqlStr.split(";")
+		sqlCmds=ModuloListe.eliminaElementiVuoti(sqlCmds)
+		numCmds=len(sqlCmds)
+		with self.initCursor() as cursoreDb:
+			for index,sqlCmd in enumerate(sqlCmds):
+				sqlCmd=sqlCmd.strip()
+				try:
+					if sqlCmd!="":
+						with self.lock:
+							cursoreDb.execute(sqlCmd)
+					yield index,numCmds
+				except Exception as ex:
+					raise ExceptionRuntime(sqlCmd+"\n\n"+ExceptionUtil.toString(ex))
+	
+	def fetchAll(self,cursoreDb)->list:
+		with self.lock:
+			with cursoreDb:
+				if cursoreDb.description is None:
+					raise ExceptionDbNoData()
+				descriptions=cursoreDb.description
+				rows=cursoreDb.fetchall()
+				self.commitNoLock()		# mysql mette in cache i risultati, lo risolvo così, è un bug loro...
+		columns = [col[0] for col in descriptions]
+		rows = [dict(zip(columns, row)) for row in rows]
+		return rows
+	
+	@classmethod
+	def backup(cls,percorsoCartella: str,user: str,password: str,dbName: str,
+			ignoreTables:list|tuple|None)->list:
+		output=[
+			cls.backupDdl(percorsoCartella,user,password,dbName,ignoreTables),
+			cls.backupData(percorsoCartella,user,password,dbName,ignoreTables)
+		]
+		return output
+	
+	@classmethod
+	def backupDdl(cls,percorsoCartella: str,user: str,password: str,dbName: str,
+			ignoreTables:list|tuple|None)->str:
+		return cls.__backup(percorsoCartella,user,password,dbName,ignoreTables,True,False)
+	@classmethod
+	def backupData(cls,percorsoCartella: str,user: str,password: str,dbName: str,
+			ignoreTables:list|tuple|None)->str:
+		return cls.__backup(percorsoCartella,user,password,dbName,ignoreTables,False,True)
+	
+	@staticmethod
+	def __backup(percorsoCartella:str,user:str,password:str,dbName:str,
+			ignoreTables:list|tuple|None,onlyDdl:bool,onlyData:bool)->str:
+		if onlyDdl and onlyData:
+			raise ExceptionRuntime("valorizzare solo un'opzione alla volta")
+		cmdIgnoreTables=""
+		if ignoreTables is not None:
+			cmdIgnoreTables=" ".join(["--ignore-table=%s.%s"%(dbName,x) for x in ignoreTables])
+		nomefileSuffix=""
+		cmdOptions=""
+		if onlyDdl:
+			nomefileSuffix="_ddl"
+			cmdOptions="--no-data "+cmdIgnoreTables
+		elif onlyData:
+			nomefileSuffix="_data"
+			cmdOptions="--order-by-primary --no-create-info --quick "+cmdIgnoreTables
+		nomefileOutput=dbName+nomefileSuffix+".sql"
+		percorsoFileBackup=ModuloFiles.pathJoin(percorsoCartella,nomefileOutput)
+		cmd=r'mysqldump -u {} -p{} --databases {} --skip-add-drop-table --skip-comments {} -r "{}"'.format(user,password,dbName,cmdOptions,percorsoFileBackup)
+		output=ModuloSystem.systemCallReturnOutput(cmd,None).strip()
+		if not ModuloStringhe.isEmpty(output):
+			raise ExceptionRuntime(output)
+		return percorsoFileBackup
+	
+	@staticmethod
+	def getTableOptions(isDebug: bool) -> str:
+		return "ENGINE=%s DEFAULT CHARSET=utf8"%("InnoDB" if not isDebug else "MEMORY",)
+
+def paginazione(firstResult:int,numResults:int)->str:
+	sql=("LIMIT "+str(numResults) if numResults is not None else "")+\
+			(" OFFSET "+str(firstResult) if firstResult is not None else "")
+	return sql
+
+def add_param_list(lista:list,prefix:str)->dict:
+	params={}
+	for index,elem in enumerate(lista):
+		params[prefix+str(index)]=elem
+	return params

modulitiz_micro/database/mysql/MysqlCommonConverter.py

@@ -0,0 +1,47 @@
+from typing import Optional
+
+from mysql.connector import FieldType
+from mysql.connector.conversion import MySQLConverter
+from mysql.connector.types import DescriptionType
+from mysql.connector.types import MySQLConvertibleType
+from mysql.connector.types import MySQLProducedType
+from mysql.connector.types import PythonProducedType
+
+
+class MysqlCommonConverter(MySQLConverter):
+	def __init__(self,charset: str|None = None,
+			use_unicode: bool = True,
+			str_fallback: bool = False):
+		super().__init__(charset,use_unicode,str_fallback)
+	
+	def to_mysql(self,value) -> MySQLProducedType:
+		value=self.__to_mysql(value)
+		# default behavior
+		return super().to_mysql(value)
+	
+	@staticmethod
+	def __to_mysql(value):
+		"""
+		Gestione custom, ad esempio per IntEnum e StrEnum
+		"""
+		if value.__class__ in MySQLConvertibleType.__args__:
+			return value
+		# inizio gestione custom
+		if isinstance(value,int):
+			typePrimitive=int
+		elif isinstance(value,str):
+			typePrimitive=str
+		else:
+			return value
+		value.__class__.__name__=typePrimitive.__name__
+		return value
+	
+	def to_python(
+			self,
+			vtype: DescriptionType,
+			value: Optional[bytes],
+	) -> PythonProducedType:
+		if vtype[1] == FieldType.BIT:
+			return value==b'\x01'
+		# default behavior
+		return super().to_python(vtype, value)

modulitiz_micro/database/mysql/exceptions/ExceptionMysqlOffline.py

@@ -0,0 +1,6 @@
+import mysql.connector
+
+class ExceptionMysqlOffline(mysql.connector.InterfaceError):
+	
+	def __init__(self,*args,**kwargs):
+		super().__init__(*args,**kwargs)

modulitiz_micro/database/sqlite/AbstractBasicSQLite.py

@@ -0,0 +1,114 @@
+from abc import abstractmethod
+
+from modulitiz_nano.ModuloStringhe import ModuloStringhe
+from modulitiz_micro.database.sqlite.ModuloSQLite import AbstractSqlite
+
+
+class AbstractBasicSqlite(AbstractSqlite):
+	
+	def __init__(self,*args,**kwargs):
+		super().__init__(*args,**kwargs)
+		if not self.isDbNew:
+			return
+		sql_str=ModuloStringhe.normalizzaEol(self.schemaBasicTables())
+		with self.initCursor() as cursoreDb:
+			with self.lock:
+				cursoreDb.executescript(sql_str)
+			sql_insertBasicTables=self.insertBasicTables()
+			if not ModuloStringhe.isEmpty(sql_insertBasicTables):
+				sql_insertBasicTables=ModuloStringhe.normalizzaEol(sql_insertBasicTables)
+				with self.lock:
+					cursoreDb.executescript(sql_insertBasicTables)
+		self.commit()
+	
+	@abstractmethod
+	def insertBasicTables(self):
+		"""
+		Inserire le istruzioni sql che vanno eseguite alla fine di tutto
+		"""
+	
+	def schemaBasicTables(self):
+		return """
+
+CREATE TABLE tb_params(
+	id						INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+	type					TEXT NOT NULL,
+	key						TEXT NULL,
+	desc					TEXT NOT NULL,
+	enabled					INTEGER NOT NULL,
+	lang_code				TEXT NULL,
+	data_insert				TIMESTAMP NOT NULL
+);
+CREATE UNIQUE INDEX PARAMS__UK1 ON tb_params(
+	type,
+	IFNULL(key, 0),
+	IFNULL(lang_code, 0)
+);
+
+"""
+	
+	
+	#############################################################################################################################
+	#############################################################################################################################
+	#############################################################################################################################
+	def selectParamDescByEntries(self,paramType,paramKey)->str|None:
+		with self.selectParamByEntries(paramType, paramKey, None, True) as cursoreDb:
+			results=cursoreDb.fetchall()
+		if len(results)==0:
+			return None
+		return results[0]['desc']
+	
+	def selectParamByEntries(self,paramType,paramKey,langCode,enabled):
+		addParamKey=ModuloStringhe.isEmpty(paramKey) is False
+		addLangCode=ModuloStringhe.isEmpty(langCode) is False
+		addEnabled=ModuloStringhe.isEmpty(enabled) is False
+		
+		sql="""
+SELECT *
+FROM tb_params
+WHERE type=:paramType
+"""+("AND key=:paramKey" if addParamKey is True else "")+"""
+"""+("AND langCode=:langCode" if addLangCode is True else "")+"""
+"""+("AND enabled=:enabled" if addEnabled is True else "")+"""
+;
+"""
+		params={'paramType':paramType}
+		if addParamKey is True:
+			params['paramKey']=paramKey
+		if addLangCode is True:
+			params['langCode']=langCode
+		if addEnabled is True:
+			params['enabled']=enabled
+		cursoreDb=self.initCursor()
+		with self.lock:
+			cursoreDb.execute(sql,params)
+		return cursoreDb
+	
+	
+	def updateParamDesc(self,paramType,paramKey,newDesc):
+		addParamKey=ModuloStringhe.isEmpty(paramKey) is False
+		addNewDesc=ModuloStringhe.isEmpty(newDesc) is False
+		
+		sql_set=[]
+		if addNewDesc is True:
+			sql_set.append("desc=:newDesc")
+		sql_set=", ".join(sql_set)
+		
+		sql="""
+UPDATE tb_params
+SET """+sql_set+"""
+WHERE type=:paramType
+"""+("AND key=:paramKey" if addParamKey is True else "")+"""
+;
+"""
+		params={}
+		if addNewDesc is True:
+			params['newDesc']=newDesc
+		params['paramType']=paramType
+		if addParamKey is True:
+			params['paramKey']=paramKey
+		cursoreDb=self.initCursor()
+		with self.lock:
+			cursoreDb.execute(sql,params)
+		return cursoreDb
+