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

modulitiz_micro/sistema/ModuloSystem.py

@@ -1,298 +0,0 @@
-import getpass
-import os
-import platform
-import signal
-import subprocess
-import sys
-from typing import Callable
-
-import psutil
-
-from modulitiz_micro.ModuloColorText import ModuloColorText
-from modulitiz_micro.ModuloFunzioni import ModuloFunzioni
-from modulitiz_micro.ModuloListe import ModuloListe
-from modulitiz_micro.ModuloStringhe import ModuloStringhe
-from modulitiz_micro.eccezioni.EccezioneRuntime import EccezioneRuntime
-from modulitiz_micro.eccezioni.EccezioneSoNonSupportato import EccezioneSoNonSupportato
-from modulitiz_micro.sistema.EnvVarsEnum import EnvVarsEnum
-
-
-class ModuloSystem(object):
-	ESTENSIONI_POTENZIALMENTE_ESEGUIBILI=(".exe",".msi",".cmd",".bat",".vbs")
-	
-	CODIFICA_WINDOWS_CMD='cp437'
-	
-	CMD_PAUSE=r'''python -c "input('pause:')"'''
-	WINDOWS_PATTERN_ECHO="""echo|set /p="{}" & echo."""
-	
-	@classmethod
-	def handleCtrlC(cls,handler:Callable=None):
-		cls.handleEvent(handler, signal.SIGINT)
-	@classmethod
-	def handleEvent(cls,handler:Callable=None,signalType=None):
-		if handler is None:
-			handler=cls.__signalHandler
-		signal.signal(signalType,handler)
-
-	@staticmethod
-	def __signalHandler(_signalType, _frame):
-		print("\nUscita...")
-		sys.exit(0)
-
-	@staticmethod
-	def sendCtrlcProcessChilds(ppid:int):
-		try:
-			parent = psutil.Process(ppid)
-		except psutil.NoSuchProcess:
-			return
-		children = parent.children(recursive=True)
-		for process in children:
-			ModuloSystem.sendCtrlcProcess(process.pid)
-
-	@staticmethod
-	def sendCtrlcProcess(pid:int):
-		if pid<=0:
-			raise EccezioneRuntime("Il pid deve essere maggiore di 0")
-		if ModuloSystem.isWindows():
-			segnale=signal.CTRL_C_EVENT
-		else:
-			segnale=signal.SIGINT
-		os.kill(pid,segnale)
-	
-	
-	@classmethod
-	def systemCallCallbackOutput(cls,cmd:str, callbackOutput:Callable,codifica:str|None):
-		for riga in cls.systemCallYieldOutput(cmd,codifica):
-			callbackOutput(riga)
-	@classmethod
-	def systemCallPrintOutput(cls,cmd: str,codifica: str|None):
-		for riga in cls.systemCallYieldOutput(cmd,codifica):
-			print(">>> "+riga)
-	
-	@classmethod
-	def systemCallPrintOutputColor(cls,cmd: str,codifica: str|None):
-		for riga in cls.systemCallYieldOutput(cmd,codifica):
-			print("%s>>>%s %s"%(ModuloColorText.BLU,ModuloColorText.DEFAULT,riga))
-	
-	@classmethod
-	def systemCallYieldOutput(cls,cmd:str, codifica:str|None):
-		if codifica is None:
-			codifica=cls.CODIFICA_WINDOWS_CMD
-		with cls.systemCall(cmd,True) as pipe:
-			# scorro l'output
-			for line in iter(pipe.stdout.readline,b''):
-				rigaDecoded=line.decode(codifica,'replace').rstrip()
-				yield rigaDecoded
-	
-	@classmethod
-	def systemCallReturnOutput(cls,cmd: str,codifica: str|None) -> str|None:
-		if codifica is None:
-			codifica=cls.CODIFICA_WINDOWS_CMD
-		with cls.systemCall(cmd,True) as pipe:
-			output=cls.fromPipeToString(pipe,None,codifica)
-		return output
-	
-	@classmethod
-	def systemCall(cls,cmd:str, useStdOut:bool)->subprocess.Popen:
-		"""
-		useStdOut		se mostrare o meno l'output a schermo
-		"""
-		if useStdOut is True:
-			stdOut=subprocess.PIPE
-		else:
-			stdOut=subprocess.DEVNULL
-		# sistemo variabili ambiente
-		envVars=os.environ
-		if not cls.isWindows():
-			originalCommand=envVars.get("_",None)
-			if originalCommand is not None:
-				originalCommand=os.path.dirname(originalCommand)
-				envVarPath=envVars[EnvVarsEnum.PATH]
-				if originalCommand+":" not in envVarPath or ":"+originalCommand not in envVarPath or ":"+originalCommand+":" not in envVarPath:
-					envVars[EnvVarsEnum.PATH]=originalCommand+":"+envVarPath
-		# se ci sono piu' comandi separati li eseguo insieme
-		righe=ModuloListe.eliminaElementiVuoti(ModuloStringhe.normalizzaEol(cmd).split("\n"))
-		cmdFinal=" && ".join(righe)
-		# creo l'oggetto
-		pipe=subprocess.Popen(cmdFinal,shell=True,
-			stdin=subprocess.PIPE,
-			stdout=stdOut,
-			stderr=subprocess.STDOUT,
-			cwd=os.getcwd(), env=envVars)
-		return pipe
-	
-	@classmethod
-	def systemCallWaitAndClose(cls,cmd: str,useStdOut: bool):
-		with cls.systemCall(cmd,useStdOut) as pipe:
-			pipe.wait()
-	
-	@classmethod
-	def fromPipeToString(cls,pipe: subprocess.Popen,stdinData:bytes|None,codifica:str|None)->str|None:
-		if codifica is None:
-			codifica=cls.CODIFICA_WINDOWS_CMD
-		# chiedo i dati
-		output=pipe.communicate(stdinData)[0]
-		if output is None:
-			return None
-		output=output.decode(codifica,'replace')
-		return output
-	
-	@staticmethod
-	def stdinReadMultipleLines(numLinesEmptyToExit:int=2)->list:
-		countLinesEmpty=0
-		output=[]
-		while True:
-			line=sys.stdin.readline().rstrip("\n")
-			if line=='':
-				countLinesEmpty+=1
-				if countLinesEmpty==numLinesEmptyToExit:
-					break
-			else:
-				countLinesEmpty=0
-			output.append(line)
-		return output
-	
-	@classmethod
-	def setTitoloFinestra(cls,titolo:str):
-		if not cls.isWindows():
-			return
-		# preparo il comando
-		cmd="title "+titolo
-		#invio il comando
-		cls.systemCallWaitAndClose(cmd,False)
-	
-
-	@staticmethod
-	def pause():
-		input("Premere il tasto INVIO per continuare...")
-
-	@staticmethod
-	def getHostname()->str:
-		return platform.node()
-	@staticmethod
-	def getUsername()->str:
-		return getpass.getuser()
-
-	@staticmethod
-	def getCmdSleep()->str:
-		if ModuloSystem.isWindows():
-			return "timeout "
-		return "sleep "
-
-	@staticmethod
-	def getTempFolder()->str:
-		if ModuloSystem.isWindows():
-			return os.environ[EnvVarsEnum.TMP]
-		return "/tmp"
-	
-	@staticmethod
-	def getFolderNull()->str:
-		if ModuloSystem.isWindows():
-			return 'NUL'
-		return "/dev/null"
-	
-	@staticmethod
-	def isWindows()->bool:
-		return os.name=='nt'
-
-	@staticmethod
-	def isSystem64bit()->bool:
-		return sys.maxsize > 2**32
-
-	@classmethod
-	def shutdown(cls,delay:int=30):
-		if cls.isWindows():
-			cmd='{} {} && shutdown /p'
-		else:
-			cmd='{} {} && systemctl poweroff'
-		cmd=cmd.format(cls.getCmdSleep(),delay)
-		# in questo caso la pipe deve restare aperta
-		cls.systemCall(cmd,True)
-	@classmethod
-	def reboot(cls,delay:int=30):
-		if cls.isWindows():
-			cmd='{} {} && shutdown /r'
-		else:
-			cmd='{} {} && reboot now'
-		cmd=cmd.format(cls.getCmdSleep(),delay)
-		# in questo caso la pipe deve restare aperta
-		cls.systemCall(cmd,True)
-	
-	@staticmethod
-	def findPidByName(nomeExe:str)->int|None:
-		process=ModuloSystem.findProcessByName(nomeExe)
-		if process is None:
-			return None
-		return process.pid
-
-	@staticmethod
-	def findProcessByName(nomeExe:str)->psutil.Process|None:
-		for p in psutil.process_iter():
-			currentName=""
-			currentCmdLine=""
-			currentNomeExe=""
-			try:
-				currentName = p.name()
-				currentCmdLine=" ".join(p.cmdline())
-				currentNomeExe = p.exe()
-			except (psutil.AccessDenied, psutil.ZombieProcess, SystemError):
-				pass
-			except psutil.NoSuchProcess:
-				continue
-			if ModuloStringhe.contains(currentName,nomeExe) or ModuloStringhe.contains(currentCmdLine,nomeExe) or os.path.basename(currentNomeExe) == nomeExe:
-				return p
-
-	@classmethod
-	def isAptPackageInstalled(cls,nome:str)->bool:
-		if cls.isWindows():
-			raise EccezioneSoNonSupportato("Windows non supportato")
-		cmd=fr'''apt list --installed | grep {nome}/'''
-		output=cls.systemCallReturnOutput(cmd,None)
-		righe=ModuloStringhe.normalizzaEol(output).split("\n")
-		righe=ModuloListe.eliminaElementiVuoti(righe)
-		for riga in righe:
-			if riga.startswith(nome):
-				return True
-		return False
-
-	@staticmethod
-	def getNumOfCores()->int:
-		return os.cpu_count()
-
-	@staticmethod
-	def getLoadPerc()->float:
-		"""
-		Restituisce la percentuale di cpu utilizzata dall'ultima chiamata a questa funzione
-		"""
-		return psutil.cpu_percent()
-
-	@classmethod
-	def getLoadAveragesPerc(cls)->list:
-		numCores=cls.getNumOfCores()
-		lista=psutil.getloadavg()
-		return [x/numCores*100 for x in lista]
-	
-	@classmethod
-	def getTempCpu(cls)->list[tuple[str,int]]|None:
-		"""
-		funziona solo su linux, ritorna una mappa:
-		nome sensore e valore sensore
-		"""
-		if cls.isWindows():
-			return None
-		sensors=psutil.sensors_temperatures(fahrenheit=False)
-		sensor=ModuloFunzioni.dictGetFirstValue(sensors)
-		lista=[]
-		for valore in sensor:
-			obj:psutil._common.shwtemp=valore
-			lista.append((obj.label,int(obj.current)))
-		return lista
-	
-	@staticmethod
-	def getBattery()->tuple|None:
-		battery=psutil.sensors_battery()
-		if battery is None:
-			return None
-		percent=int(battery.percent)
-		isPlugged=battery.power_plugged
-		return percent,isPlugged

modulitiz_micro/util/beans/conf/AbstractBasicConfBean.py

@@ -1,11 +0,0 @@
-from modulitiz_micro.files.ModuloFiles import ModuloFiles
-
-from modulitiz_micro.util.beans.conf.AbstractConfBean import AbstractConfBean
-
-
-class AbstractBasicConfBean(AbstractConfBean):
-	
-	def __init__(self,clazz,*args,**kwargs):
-		super().__init__(*args,**kwargs)
-		self.INPUT_FILE_CONF=ModuloFiles.pathJoin(self.CARTELLA_BASE_PROGETTO,"conf.json")
-		self.fileConf=clazz(self.INPUT_FILE_CONF)

modulitiz_micro/util/beans/conf/AbstractConfBean.py

@@ -1,16 +0,0 @@
-from abc import ABC
-
-from modulitiz_micro.ModuloPyinstaller import ModuloPyinstaller
-from modulitiz_micro.files.ModuloFiles import ModuloFiles
-from modulitiz_micro.sistema.EnvVarsEnum import EnvVarsEnum
-from modulitiz_micro.sistema.ModuloEnvVars import ModuloEnvVars
-
-
-class AbstractConfBean(ABC):
-	
-	def __init__(self,cartellaBase:str|None,nomeProgetto:str):
-		self.CARTELLA_BASE_PROGETTO:str|None=None
-		if cartellaBase is not None:
-			self.CARTELLA_BASE_PROGETTO=ModuloFiles.pathJoin(cartellaBase,nomeProgetto)
-		self.IS_DEBUG=(ModuloEnvVars.getOrNone(EnvVarsEnum.MODULITIZ_IS_DEBUG)=="1" and not ModuloPyinstaller.isExecutableMode())
-		self.NOME_PROGETTO=nomeProgetto

modulitiz_micro/util/beans/fileconf/AbstractBasicFileConfBean.py

@@ -1,11 +0,0 @@
-from modulitiz_micro.util.beans.fileconf.AbstractFileConfBean import AbstractFileConfBean
-
-
-class AbstractBasicFileConfBean(AbstractFileConfBean):
-	"""
-	Classe che può essere usata come base per definire la struttura del file di configurazione del programma
-	"""
-	
-	def __init__(self,*args,**kwargs):
-		super().__init__(*args,**kwargs)
-		self.percorsoCartellaEsterna=self._diz['percorsoCartellaEsterna']

modulitiz_micro/util/beans/fileconf/AbstractFileConfBean.py

@@ -1,13 +0,0 @@
-import json
-from abc import ABC
-
-from modulitiz_micro.files.ModuloFiles import ModuloFiles
-
-
-class AbstractFileConfBean(ABC):
-	"""
-	Classe che può essere usata come base per definire la struttura del file di configurazione del programma
-	"""
-	
-	def __init__(self,nomefile:str):
-		self._diz=json.loads(ModuloFiles.readFileText(nomefile,True))

modulitiz_micro/util/beans/globalvar/AbstractGlobalVarBean.py

@@ -1,34 +0,0 @@
-from abc import ABC
-from typing import NewType
-
-from modulitiz_micro.ModuloDate import ModuloDate
-from modulitiz_micro.files.ModuloLogging import ModuloLogging
-from modulitiz_micro.sistema.ModuloSystem import ModuloSystem
-from modulitiz_micro.util.beans.conf.AbstractConfBean import AbstractConfBean
-
-
-class AbstractGlobalVarBean(ABC):
-	"""
-	Classe da usare come base per definire la struttura di una classe che raggrupperà gli oggetti che verranno usati nel programma
-	"""
-	
-	def __init__(self,confBean:NewType("T",AbstractConfBean),projectTitle:str,projectVersion:str,projectStartYear:int,isDebug:bool|None):
-		self.confBean=confBean
-		self.projectTitle=projectTitle
-		self.projectVersion=projectVersion
-		self.projectStartYear=projectStartYear
-		
-		self.projectHeader="%s V%s"%(projectTitle,projectVersion)
-		
-		if isDebug is None:
-			isDebug=confBean.IS_DEBUG
-		self.logger=ModuloLogging(cartellaBase=confBean.CARTELLA_BASE_PROGETTO,isDebug=isDebug)
-		currentYear=ModuloDate.dateToString(None,"%Y")
-		ModuloSystem.setTitoloFinestra(projectTitle)
-		self.logger.info("""
-############################################################
-	%s - Since %d - Copyright %s
-############################################################""",self.projectHeader,projectStartYear,currentYear)
-		self.isRequestedStop=False
-		self.isRequestedExit=False
-	

modulitiz_micro/util/decorators/noAwait.py

@@ -1,23 +0,0 @@
-import asyncio
-from functools import wraps
-
-
-def noAwait(funzione):
-	"""
-	Usare questo decorator per evitare di propagare async e await in tutto il codice.
-	Esempio dell'uso:
-	
-	@noAwait
-	async def funzione(self):
-		await funzioneAsync()
-	"""
-	
-	@wraps(funzione)
-	def wrapped(*args, **kwargs):
-		try:
-			loop=asyncio.get_event_loop_policy().get_event_loop()
-		except RuntimeError:
-			loop=asyncio.new_event_loop()
-		asyncio.set_event_loop(loop)
-		loop.run_until_complete(funzione(*args,**kwargs))
-	return wrapped

modulitiz_micro/util/pip/AbstractModuloPip.py

@@ -1,41 +0,0 @@
-import re
-from abc import ABC
-
-from modulitiz_micro.ModuloListe import ModuloListe
-from modulitiz_micro.ModuloStringhe import ModuloStringhe
-from modulitiz_micro.sistema.ModuloSystem import ModuloSystem
-
-
-class AbstractModuloPip(ABC):
-	REGEX_VERSION=r"\d+\.\d+\.\d+"
-	_PREFIX_OK="Successfully installed "
-	
-	@classmethod
-	def _versionFromFileRequirements(cls,rigaIn:str,args:str) -> list:
-		cmd='pip index versions --pre %s %s'%(rigaIn,args)
-		output=ModuloSystem.systemCallReturnOutput(cmd,None)
-		righe=ModuloListe.eliminaElementiVuoti(ModuloStringhe.normalizzaEol(output).split("\n"))
-		righe=cls._parseResults(righe)
-		result=[]
-		if len(righe)<3:
-			return result
-		
-		result.append(cls._search(righe[-2],r"INSTALLED:\s+(%s)"))
-		result.append(cls._search(righe[-1],r"LATEST:\s+(%s)"))
-		return result
-	
-	@staticmethod
-	def _parseResults(righe:list)->list:
-		output=[]
-		for riga in righe:
-			riga=riga.strip()
-			if not ModuloStringhe.isEmpty(riga) and not riga.startswith("["):
-				output.append(riga)
-		return output
-	
-	@classmethod
-	def _search(cls,riga:str,regex:str)->str|None:
-		ricerca=re.search(regex%(cls.REGEX_VERSION,),riga)
-		if ricerca is None:
-			return None
-		return ricerca.group(1).strip()

modulitiz_micro/util/pip/ModuloPip.py

@@ -1,49 +0,0 @@
-from modulitiz_micro.ModuloListe import ModuloListe
-from modulitiz_micro.ModuloStringhe import ModuloStringhe
-from modulitiz_micro.files.ModuloFiles import ModuloFiles
-from modulitiz_micro.sistema.ModuloSystem import ModuloSystem
-from modulitiz_micro.util.pip.AbstractModuloPip import AbstractModuloPip
-
-
-class ModuloPip(AbstractModuloPip):
-	
-	@classmethod
-	def updateFromFileRequirements(cls,percorsoCartellaDipendenze: str) -> tuple[bool,str]:
-		fileDipendenze=ModuloFiles.pathJoin(percorsoCartellaDipendenze,"requirements.txt")
-		cmd='pip install -U -r "%s"'%(fileDipendenze,)
-		output=ModuloSystem.systemCallReturnOutput(cmd,None)
-		# check output
-		righe=ModuloListe.eliminaElementiVuoti(ModuloStringhe.normalizzaEol(output).split("\n"))
-		ultimeRigheReversed=righe[-10:]
-		ultimeRigheReversed.reverse()
-		isError=False
-		for riga in ultimeRigheReversed:
-			if riga.startswith(cls._PREFIX_OK):
-				elencoModuliAggiornati=riga.replace(cls._PREFIX_OK,"")
-				return True,elencoModuliAggiornati
-			if not isError and (riga.startswith("ERROR:") or riga.startswith("Exception:")):
-				isError=True
-		if isError:
-			msg="Aggiornamento moduli non riuscito:\n{}".format(output[-1000:])
-			return False,msg
-		return True," nessun aggiornamento"
-	
-	@classmethod
-	def versionsFromFileRequirements(cls,percorsoCartellaDipendenze: str) -> list:
-		fileDipendenze=ModuloFiles.pathJoin(percorsoCartellaDipendenze,"requirements.txt")
-		if ModuloFiles.getFileSize(fileDipendenze)<=0:
-			return []
-		cont=ModuloStringhe.normalizzaEol(ModuloFiles.readFileText(fileDipendenze,None))
-		righe=ModuloListe.eliminaElementiVuoti(cont.split("\n"))
-		results=[]
-		# memorizzo opzioni
-		argsList=[]
-		for riga in righe:
-			if riga.startswith("-"):
-				argsList.append(riga)
-		args=" ".join(argsList)
-		# elaboro ogni modulo
-		for riga in righe:
-			if not riga.startswith("-"):
-				results.append(cls._versionFromFileRequirements(riga,args))
-		return results

modulitiz_micro/util/spooler/AbstractSpooler.py

@@ -1,14 +0,0 @@
-from abc import ABC
-
-from modulitiz_micro.util.spooler.beans.QueueBean import QueueBean
-
-
-class AbstractSpooler(ABC):
-	beans:dict[str,QueueBean]={}
-	
-	@classmethod
-	def _areJobsNotDone(cls)->bool:
-		for bean in cls.beans.values():
-			if bean.size>0:
-				return True
-		return False

modulitiz_micro/util/spooler/Spooler.py

@@ -1,18 +0,0 @@
-import time
-
-from modulitiz_micro.util.spooler.AbstractSpooler import AbstractSpooler
-from modulitiz_micro.util.spooler.beans.QueueBean import QueueBean
-
-
-class Spooler(AbstractSpooler):
-	@staticmethod
-	def increaseSize(bean:QueueBean):
-		bean.size+=1
-	@staticmethod
-	def decreaseSize(bean:QueueBean):
-		bean.size-=1
-	
-	@classmethod
-	def waitUntilJobsDone(cls):
-		while cls._areJobsNotDone():
-			time.sleep(0.1)

modulitiz_micro/util/spooler/beans/QueueBean.py

@@ -1,8 +0,0 @@
-import threading
-
-
-class QueueBean(object):
-	def __init__(self):
-		self.lock=threading.Lock()
-		self.size=0
-		self.countConsecutiveOverSize=0

modulitiz_micro/util/spooler/decorators/spooler.py

@@ -1,49 +0,0 @@
-from functools import wraps
-
-from modulitiz_micro.ModuloFunzioni import ModuloFunzioni
-from modulitiz_micro.util.spooler.Spooler import Spooler
-from modulitiz_micro.util.spooler.beans.QueueBean import QueueBean
-from modulitiz_micro.util.spooler.eccezioni.EccezioneSpooler import EccezioneSpooler
-from modulitiz_micro.util.spooler.eccezioni.EccezioneSpoolerFull import EccezioneSpoolerFull
-
-
-def spooler(maxSize:int,notifyIfConsecutiveSizeGreaterThan:int=0):
-	"""
-	Usare questo decorator per produrre (creare) la coda di azioni e consumarla (scodare) non appena c'è uno slot libero.
-	:param maxSize: dimensione massima della coda
-	:param notifyIfConsecutiveSizeGreaterThan: cosa fare se la coda è piena:
-		- 0: notifica sempre
-		- >0: notifica solo se maggiore di N
-	"""
-	# controllo parametri di input
-	if notifyIfConsecutiveSizeGreaterThan>maxSize:
-		raise EccezioneSpooler("%d non può essere maggiore di %d"%(notifyIfConsecutiveSizeGreaterThan,maxSize))
-	
-	def decorator(funzione):
-		@wraps(funzione)
-		def wrapped(*args,**kwargs):
-			fullPathFunction=ModuloFunzioni.getFullyQualifiedName(funzione)
-			bean=Spooler.beans.get(fullPathFunction,None)
-			if bean is None:
-				bean=QueueBean()
-				Spooler.beans[fullPathFunction]=bean
-			# controllo se ho raggiunto o superato il limite
-			if bean.size>=maxSize:
-				bean.countConsecutiveOverSize+=1
-				if bean.countConsecutiveOverSize>notifyIfConsecutiveSizeGreaterThan:
-					bean.countConsecutiveOverSize=0
-					raise EccezioneSpoolerFull()
-			else:
-				bean.countConsecutiveOverSize=0
-			# chiamo la funzione
-			Spooler.increaseSize(bean)
-			try:
-				with bean.lock:
-					output=funzione(*args,**kwargs)
-			except Exception as e:
-				Spooler.decreaseSize(bean)
-				raise e
-			Spooler.decreaseSize(bean)
-			return output
-		return wrapped
-	return decorator

modulitiz_micro/util/spooler/eccezioni/EccezioneSpooler.py

@@ -1,7 +0,0 @@
-from modulitiz_micro.eccezioni.EccezioneBase import EccezioneBase
-
-
-class EccezioneSpooler(EccezioneBase):
-	
-	def __init__(self,msg:str):
-		super().__init__(msg)

modulitiz_micro/util/spooler/eccezioni/EccezioneSpoolerFull.py

@@ -1,7 +0,0 @@
-from modulitiz_micro.util.spooler.eccezioni.EccezioneSpooler import EccezioneSpooler
-
-
-class EccezioneSpoolerFull(EccezioneSpooler):
-	
-	def __init__(self):
-		super().__init__("Spooler pieno")

modulitiz_micro/util/unittesting/AbstractOverrideTestUtil.py

@@ -1,31 +0,0 @@
-from abc import ABC
-
-from modulitiz_micro.eccezioni.EccezioneRuntime import EccezioneRuntime
-
-
-class AbstractOverrideTestUtil(ABC):
-	"""
-	Solo le funzioni statiche devono essere revertate
-	"""
-	
-	def __init__(self):
-		super().__init__()
-		self._cache={}
-	
-	def __enter__(self):
-		self._cache.clear()
-		return self
-	
-	def __exit__(self,*args,**kwargs):
-		self._cache.clear()
-	
-	@staticmethod
-	def getMockedFunction(throwExc:Exception|None,expectedValue: str|tuple|None):
-		"""
-		Must use only 1 param.
-		"""
-		if throwExc is not None:
-			return lambda *args,**kwargs:(_ for _ in ()).throw(throwExc)
-		elif expectedValue is not None:
-			return lambda *args,**kwargs:expectedValue
-		raise EccezioneRuntime("Use only 1 param")

modulitiz_micro/util/unittesting/AbstractTestUtil.py

@@ -1,11 +0,0 @@
-import unittest
-
-
-class AbstractTestUtil(unittest.TestCase):
-	overrideTestUtil=None
-	
-	def __init__(self,*args,**kwargs):
-		super().__init__(*args,**kwargs)
-		logger=type('test',(),{})()
-		logger.exception=logger.error=logger.warning=logger.info=logger.debug=print
-		self.logger=logger

modulitiz_micro/util/unittesting/ModuloRunUnitTest.py

@@ -1,25 +0,0 @@
-import os
-import pkgutil
-import unittest
-
-
-class ModuloRunUnitTest(object):
-	
-	@classmethod
-	def startTests(cls,currentFilePath:str):
-		suite=cls.__createTestSuite(currentFilePath)
-		unittest.TextTestRunner(verbosity=2).run(suite)
-	
-	@staticmethod
-	def __createTestSuite(currentFilePath:str)->unittest.TestSuite:
-		paths = [x[0] for x in os.walk(os.path.dirname(currentFilePath))]
-		testLoader=unittest.TestLoader()
-		suite=unittest.TestSuite()
-		for modFinder, modName, _isPkg in pkgutil.walk_packages(paths):
-			spec=modFinder.find_spec(modName)
-			loader=spec.loader
-			module=loader.load_module(modName)
-			# carico ogni test presente in un modulo
-			for tests in testLoader.loadTestsFromModule(module):
-				suite.addTests(tests)
-		return suite