modulitiz-micro 2.43.0__py311-none-any.whl → 2.44.1__py311-none-any.whl

modulitiz_micro/database/mysql/AbstractBasicMysql.py

@@ -1,114 +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
-	
+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

@@ -1,163 +1,163 @@
-from abc import abstractmethod
-
-import mysql.connector
-
-from modulitiz_nano.ModuloListe import ModuloListe
-from modulitiz_nano.ModuloStringhe import ModuloStringhe
-from modulitiz_micro.database.AbstractSql import AbstractSql
-from modulitiz_micro.database.eccezioni.EccezioneDbNoData import EccezioneDbNoData
-from modulitiz_micro.database.mysql.MysqlCommonConverter import MysqlCommonConverter
-from modulitiz_nano.eccezioni.EccezioneRuntime import EccezioneRuntime
-from modulitiz_nano.files.ModuloFiles import ModuloFiles
-from modulitiz_nano.files.ModuloLogging import ModuloLogging
-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,porta: int|None,user: str,password: str,nomeDb: str,isDebug: bool):
-		super().__init__()
-		self.nomeDb=nomeDb
-		if porta is None:
-			porta=self.DEFAULT_PORT
-		# apro la connessione col server
-		self.connDb=mysql.connector.connect(user=user,password=password,host=host,port=porta,
-				converter_class=MysqlCommonConverter)
-		self.initCursor()
-		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)
-		cursoreDb=self.initCursor()
-		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 EccezioneRuntime(sqlCmd+"\n\n"+ModuloLogging.exceptionToString(ex))
-	
-	def fetchAll(self,cursoreDb)->list:
-		with cursoreDb:
-			if cursoreDb.description is None:
-				raise EccezioneDbNoData()
-			descriptions=cursoreDb.description
-			with self.lock:
-				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 EccezioneRuntime("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 EccezioneRuntime(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
+from abc import abstractmethod
+
+import mysql.connector
+
+from modulitiz_nano.ModuloListe import ModuloListe
+from modulitiz_nano.ModuloStringhe import ModuloStringhe
+from modulitiz_micro.database.AbstractSql import AbstractSql
+from modulitiz_micro.database.eccezioni.EccezioneDbNoData import EccezioneDbNoData
+from modulitiz_micro.database.mysql.MysqlCommonConverter import MysqlCommonConverter
+from modulitiz_nano.eccezioni.EccezioneRuntime import EccezioneRuntime
+from modulitiz_nano.files.ModuloFiles import ModuloFiles
+from modulitiz_nano.files.ModuloLogging import ModuloLogging
+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,porta: int|None,user: str,password: str,nomeDb: str,isDebug: bool):
+		super().__init__()
+		self.nomeDb=nomeDb
+		if porta is None:
+			porta=self.DEFAULT_PORT
+		# apro la connessione col server
+		self.connDb=mysql.connector.connect(user=user,password=password,host=host,port=porta,
+				converter_class=MysqlCommonConverter)
+		self.initCursor()
+		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)
+		cursoreDb=self.initCursor()
+		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 EccezioneRuntime(sqlCmd+"\n\n"+ModuloLogging.exceptionToString(ex))
+	
+	def fetchAll(self,cursoreDb)->list:
+		with cursoreDb:
+			if cursoreDb.description is None:
+				raise EccezioneDbNoData()
+			descriptions=cursoreDb.description
+			with self.lock:
+				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 EccezioneRuntime("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 EccezioneRuntime(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

@@ -1,47 +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)
+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/eccezioni/EccezioneMysqlOffline.py

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