modulitiz-micro 2.26.0__py311-none-any.whl

modulitiz_micro/sistema/ModuloSystem.py

@@ -0,0 +1,298 @@
+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/sistema/ModuloSystemPipe.py

@@ -0,0 +1,67 @@
+import multiprocessing
+import queue
+import subprocess
+import threading
+import time
+
+import psutil
+
+from modulitiz_micro.files.ModuloLogging import ModuloLogging
+from modulitiz_micro.multithreading.ModuloThread import ModuloThread
+from modulitiz_micro.sistema.ModuloSystem import ModuloSystem
+
+
+class ModuloSystemPipe(object):
+	
+	@classmethod
+	def read(cls,logger: ModuloLogging,pipe: subprocess.Popen,timeout:int|float) -> str|None:
+		event=threading.Event()
+		q=multiprocessing.Queue()
+		ModuloThread.startDaemon(logger,cls.__read,(pipe,q,event))
+		
+		output=""
+		pauseInterval=0.1
+		contaTimeout=0
+		continua=True
+		while continua:
+			outputBefore=output
+			try:
+				output+=q.get_nowait()
+			except queue.Empty:
+				pass
+			continua=(output=="" or output!=outputBefore)
+			if continua:
+				if output=="":
+					contaTimeout+=pauseInterval
+				else:
+					contaTimeout=0
+				time.sleep(pauseInterval)
+			else:
+				if contaTimeout<=timeout:
+					time.sleep(pauseInterval)
+					continua=True
+					contaTimeout+=pauseInterval
+		event.set()
+		return output.rstrip()
+	
+	@staticmethod
+	def __read(pipe: subprocess.Popen,q: multiprocessing.Queue,event: threading.Event):
+		chunk=pipe.stdout.readline()
+		while chunk:
+			q.put_nowait(chunk.decode())
+			if event.is_set():
+				return
+			chunk=pipe.stdout.readline()
+	
+	@staticmethod
+	def closeAndCheck(process:psutil.Process|subprocess.Popen,alias:str,timeout:int,callbackError,callbackSuccess):
+		ModuloSystem.sendCtrlcProcess(process.pid)
+		try:
+			exitCode=process.wait(timeout)
+		except subprocess.TimeoutExpired:
+			callbackError(alias+" non terminato correttamente nel tempo utile")
+			return
+		if exitCode is None or exitCode==0:
+			callbackSuccess(alias+" terminato con successo")
+			return
+		callbackError(alias+" non terminato correttamente, esito=%s"%(exitCode,))

modulitiz_micro/social/telegram/ModuloTelegram.py

@@ -0,0 +1,52 @@
+from abc import abstractmethod
+
+from telethon import TelegramClient
+
+from modulitiz_micro.ModuloStringhe import ModuloStringhe
+from modulitiz_micro.util.decorators.noAwait import noAwait
+
+
+class ModuloTelegram(object):
+	def __init__(self,apiId:int,apiHash:str,nomefileSessione:str,phoneNumWithCountryCode:str):
+		self.apiId=apiId
+		self.apiHash=apiHash
+		self.nomefileSessione=nomefileSessione
+		self.phoneNumWithCountryCode=phoneNumWithCountryCode
+		
+		self.client:TelegramClient|None = None
+	
+	@noAwait
+	async def connect(self):
+		self.client = TelegramClient(self.nomefileSessione, self.apiId, self.apiHash)
+		await self.client.connect()
+		# se il client non e' autorizzato richiedo la verifica
+		if await self.client.is_user_authorized():
+			return
+		await self.client.send_code_request(self.phoneNumWithCountryCode)
+		await self.client.sign_in(self.phoneNumWithCountryCode, self.getVerificationCodefromUser())
+	
+	def sendMessageWithConnectAndClose(self,username: str|None,msg: str):
+		"""
+		Apre la connessione, invia il messaggio e chiude la connessione.
+		:param username: il nome utente del destinatario a cui mandare il messaggio
+		:param msg: il testo del messaggio da inviare
+		"""
+		if ModuloStringhe.isEmpty(username):
+			return
+		self.connect()
+		self.sendMessage(username,msg)
+		self.close()
+	
+	@noAwait
+	async def sendMessage(self,username:str,msg:str):
+		await self.client.send_message(username, msg, parse_mode='html')
+	
+	def close(self):
+		self.client.disconnect()
+	
+	@staticmethod
+	@abstractmethod
+	def getVerificationCodefromUser()->str:
+		"""
+		Deve ritornare una stringa che corrisponde al codice di verifica inserito dall'utente.
+		"""

modulitiz_micro/social/telegram/ModuloTelegramSimple.py

@@ -0,0 +1,26 @@
+from modulitiz_micro.social.telegram.ModuloTelegram import ModuloTelegram
+
+
+class ModuloTelegramSimple(ModuloTelegram):
+	"""
+	Utility di gestione semplice per il sistema di messaggistica istantanea Telegram.
+	"""
+	
+	def __init__(self,usernameDestinatario:str|None,*args,**kwargs):
+		super().__init__(*args,**kwargs)
+		self.usernameDestinatario=usernameDestinatario
+	
+	@staticmethod
+	def getVerificationCodefromUser()->str:
+		"""
+		Specifica in che modo chiedere all'utente il codice di verifica,
+		viene chiesto solo la prima volta che ci si collega.
+		"""
+		return input('Inserisci il codice di verifica: ')
+	
+	def sendMessageDefaultDestinatario(self,msg:str):
+		"""
+		Invia il messaggio al destinatario di default specificato nella creazione di quest'oggetto.
+		:param msg: il testo del messaggio da inviare
+		"""
+		super().sendMessageWithConnectAndClose(self.usernameDestinatario,msg)

modulitiz_micro/util/beans/conf/AbstractBasicConfBean.py

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

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

@@ -0,0 +1,11 @@
+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._dizionario['percorsoCartellaEsterna']

modulitiz_micro/util/beans/fileconf/AbstractFileConfBean.py

@@ -0,0 +1,13 @@
+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._dizionario=json.loads(ModuloFiles.readFileText(nomefile,True))

modulitiz_micro/util/beans/globalvar/AbstractBasicGlobalVarBean.py

@@ -0,0 +1,15 @@
+from modulitiz_micro.rete.ntp.ModuloNtpIt import ModuloNtpIt
+
+from modulitiz_micro.util.beans.globalvar.AbstractGlobalVarBean import AbstractGlobalVarBean
+
+
+class AbstractBasicGlobalVarBean(AbstractGlobalVarBean):
+	"""
+	Classe da usare come base per definire la struttura di una classe che raggrupperà gli oggetti che verranno usati nel programma
+	"""
+	
+	def __init__(self,useNtp:bool,*args,**kwargs):
+		super().__init__(*args,**kwargs)
+		if useNtp:
+			self.moduloNtp=ModuloNtpIt(self.logger)
+	

modulitiz_micro/util/beans/globalvar/AbstractGlobalVarBean.py

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

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

@@ -0,0 +1,41 @@
+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 %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

@@ -0,0 +1,49 @@
+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)
+		# controllo 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