modulitiz-micro 3.0.0__py314-none-any.whl

modulitiz_micro/SerialModule.py

@@ -0,0 +1,55 @@
+import serial
+import serial.tools.list_ports
+
+from modulitiz_nano.ModuloColorText import ModuloColorText
+from modulitiz_nano.ModuloDate import ModuloDate
+from modulitiz_nano.sistema.EncodingEnum import EncodingEnum
+
+
+class SerialModule(object):
+	"""
+	Utility di gestione della connessione seriale / RS232
+	"""
+	
+	def __init__(self):
+		self.conn=None
+	
+	def populate(self,port: str,baudrate: int):
+		self.conn=serial.Serial(port,baudrate,timeout=1)
+	
+	@staticmethod
+	def findFirstPortConnected()->str|None:
+		ports:list|tuple=serial.tools.list_ports.comports()
+		if not ports:
+			return None
+		return min(ports)[0]
+	
+	def isOpen(self)->bool:
+		"""
+		Controlla se la connessione alla porta è aperta.
+		"""
+		return self.conn is not None and self.conn.isOpen()
+	
+	def read(self, exitCallback):
+		"""
+		Reads serial strings and prints it to standard output.
+		"""
+		try:
+			while not exitCallback():
+				character=self.conn.read(1).decode(EncodingEnum.UTF8,"replace")
+				if character!="\n":
+					msg=character
+				else:
+					msg="\n%s%s >>> %s"%(ModuloDate.dateToString(None,ModuloDate.FORMATO_ORA),ModuloColorText.BLU,ModuloColorText.DEFAULT)
+				print(msg,end="",flush=True)
+		finally:
+			self.close()
+	
+	def close(self):
+		"""
+		Chiude la connessione alla porta.
+		"""
+		if not self.isOpen():
+			return
+		self.conn.close()
+		self.conn=None

modulitiz_micro/SunUtil.py

@@ -0,0 +1,22 @@
+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 ModuloDate.removeTimezoneInfo(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()
+		dateTime=ModuloDate.plusMinusDays(dateTime,1)
+		sun=Sun(lat,long)
+		return ModuloDate.removeTimezoneInfo(sun.get_sunset_time(dateTime,ModuloDate.getTimezoneLocal(dateTime)))

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_nano.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,112 @@
+from abc import abstractmethod
+
+from modulitiz_micro.database.mysql.ModuloMysql import ModuloMysql
+from modulitiz_nano.ModuloStringhe import ModuloStringhe
+
+
+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:
+		with self.lock:
+			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()
+		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()
+		cursoreDb.execute(sql,params)
+		return cursoreDb

modulitiz_micro/database/mysql/ModuloMysql.py

@@ -0,0 +1,157 @@
+from abc import abstractmethod
+
+import mysql.connector
+
+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.database.AbstractSql import AbstractSql
+from modulitiz_nano.exceptions.ExceptionRuntime import ExceptionRuntime
+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
+		# open connection
+		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:
+				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:
+			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!="":
+						cursoreDb.execute(sqlCmd)
+					yield index,numCmds
+				except Exception as ex:
+					raise ExceptionRuntime(sqlCmd) from ex
+	
+	def fetchAll(self,cursoreDb)->list:
+		with cursoreDb:
+			if cursoreDb.description is None:
+				raise ExceptionDbNoData()
+			descriptions=cursoreDb.description
+			rows=cursoreDb.fetchall()
+			self.commit()		# 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|None,numResults:int|None)->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,55 @@
+from typing import Optional
+from typing import override
+
+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)
+	
+	@override
+	@classmethod
+	def _bit_to_python(cls,value: bytes, dsc: Optional[DescriptionType] = None) -> bool:
+		return super()._bit_to_python(value, dsc)==1
+	
+	@override
+	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
+	
+	@override
+	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/dom/DomModule.py

@@ -0,0 +1,48 @@
+from bs4 import BeautifulSoup
+from bs4 import ResultSet
+from bs4 import Tag
+
+from modulitiz_nano.files.ModuloFiles import ModuloFiles
+
+
+class DomModule(object):
+	def __init__(self, filePath: str|None, htmlString: str|None):
+		if filePath is not None:
+			self.filePath=filePath
+			htmlString=ModuloFiles.readFileText(filePath, True)
+		self.htmlString=htmlString
+		self.dom=self.__createObj()
+	
+	@staticmethod
+	def innerHTML(tag:Tag)->str:
+		"""
+		dato in input un tag html della classe BeautifulSoup, restituisce il codice html all'interno di questo tag
+		"""
+		return "".join([str(x) for x in tag.contents])
+	
+	def selector(self,cssSelector:str)->ResultSet[Tag]:
+		"""
+		estrae tutti gli elementi che corrispondono al css selector
+		"""
+		return self.dom.select(cssSelector)
+	
+	@staticmethod
+	def getAttributeValue(tag:Tag, nomeAttr:str):
+		return tag.attrs[nomeAttr]
+	
+	@staticmethod
+	def setAttributeValue(tag:Tag, nomeAttr:str, value):
+		tag.attrs[nomeAttr]=value
+		return tag
+	
+	@staticmethod
+	def setInnerHtml(tag:Tag, value):
+		tag.string=value
+	
+	def save(self):
+		htmlOut=str(self.dom).encode()
+		with open(self.filePath, "wb") as file:
+			file.write(htmlOut)
+	
+	def __createObj(self)->BeautifulSoup:
+		return BeautifulSoup(self.htmlString, features="xml")

modulitiz_micro/exceptions/ExceptionCtrlC.py

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

modulitiz_micro/exceptions/ExceptionScheduler.py

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

modulitiz_micro/exceptions/http/ExceptionHttp.py

@@ -0,0 +1,8 @@
+from modulitiz_nano.exceptions.ExceptionBase import ExceptionBase
+
+
+class ExceptionHttp(ExceptionBase):
+	
+	def __init__(self,httpCode:int|None,*args):
+		super().__init__(*args)
+		self.httpCode=httpCode

modulitiz_micro/exceptions/http/ExceptionHttp404.py

@@ -0,0 +1,7 @@
+from modulitiz_micro.exceptions.http.ExceptionHttp import ExceptionHttp
+
+
+class ExceptionHttp404(ExceptionHttp):
+	
+	def __init__(self):
+		super().__init__(404)

modulitiz_micro/exceptions/http/ExceptionHttpGeneric.py

@@ -0,0 +1,7 @@
+from modulitiz_micro.exceptions.http.ExceptionHttp import ExceptionHttp
+
+
+class ExceptionHttpGeneric(ExceptionHttp):
+	
+	def __init__(self):
+		super().__init__(None)

modulitiz_micro/exceptions/http/ExceptionHttpRetriesExceeded.py

@@ -0,0 +1,7 @@
+from modulitiz_micro.exceptions.http.ExceptionHttpGeneric import ExceptionHttpGeneric
+
+
+class ExceptionHttpRetriesExceeded(ExceptionHttpGeneric):
+	
+	def __init__(self):
+		super().__init__()

modulitiz_micro/files/cache/decorators/cacheRam.py

@@ -0,0 +1,26 @@
+from functools import wraps
+
+from cachetools import TTLCache
+from cachetools import cached
+
+from modulitiz_nano.ModuloNumeri import ModuloNumeri
+
+
+def cacheRam(minsBeforeExpiry: int|float|None):
+	"""
+	Usare questo decorator per mettere in cache delle informazioni.
+	Alla base usa una libreria di terze parti.
+	:param minsBeforeExpiry: se null mantiene i dati in memoria per 1 giorno
+	"""
+	
+	__secsBeforeExpiry=24*3600 if minsBeforeExpiry is None else ModuloNumeri.decimalNumbersTruncate(minsBeforeExpiry*60,2)
+	__cache=cached(TTLCache(20,__secsBeforeExpiry))
+	
+	def decorator(funzione):
+		__funzione=__cache(funzione)
+		
+		@wraps(funzione)
+		def wrapped(*args,**kwargs):
+			return __funzione(*args,**kwargs)
+		return wrapped
+	return decorator

modulitiz_micro/files/git/ModuloGit.py

@@ -0,0 +1,32 @@
+import git
+
+from modulitiz_micro.files.git.decorators.catchAndRaiseGitExceptions import catchAndRaiseGitExceptions
+
+
+class ModuloGit(object):
+	def __init__(self, repoPath:str):
+		self.inner=git.Repo(repoPath)
+	
+	@catchAndRaiseGitExceptions
+	def getWorkingCopyRevision(self)->str:
+		return self.inner.head.object.hexsha
+	
+	@catchAndRaiseGitExceptions
+	def getRemoteRevision(self)->str:
+		return self.inner.remotes[0].fetch()[0].ref.object.hexsha
+	
+	@catchAndRaiseGitExceptions
+	def addFile(self,filenamePath:str):
+		self.inner.index.add(filenamePath)
+	
+	@catchAndRaiseGitExceptions
+	def removeFile(self,filenamePath:str):
+		self.inner.index.remove(filenamePath,working_tree=True)
+	
+	@catchAndRaiseGitExceptions
+	def resetCurrentLocalBranch(self):
+		self.inner.head.reset(working_tree=True)
+	
+	@catchAndRaiseGitExceptions
+	def update(self)->str:
+		return self.inner.remotes[0].pull()[0].ref.object.hexsha

modulitiz_micro/files/git/decorators/catchAndRaiseGitExceptions.py

@@ -0,0 +1,19 @@
+from functools import wraps
+
+from git import GitCommandError
+
+from modulitiz_micro.files.git.exceptions.ExceptionGit import ExceptionGit
+
+
+def catchAndRaiseGitExceptions(function):
+	"""
+	Cattura tutte le eccezioni git di vario tipo e rilancia un'eccezione custom
+	"""
+	
+	@wraps(function)
+	def wrapped(*args,**kwargs):
+		try:
+			return function(*args,**kwargs)
+		except (GitCommandError,) as ex:
+			raise ExceptionGit() from ex
+	return wrapped

modulitiz_micro/files/git/exceptions/ExceptionGit.py

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