modulitiz-micro 2.45.0__py311-none-any.whl → 2.46.0__py311-none-any.whl

modulitiz_micro/sistema/ModuloEnvVars.py

@@ -1,34 +1,34 @@
-import os
-
-from modulitiz_nano.sistema.ModuloSystem import ModuloSystem
-
-
-class ModuloEnvVars(object):
-	
-	@classmethod
-	def add(cls,nomeVar:str,valore:str,addFirst:bool):
-		if not ModuloSystem.isWindows():
-			separatore=":"
-		else:
-			separatore=";"
-		nomeVar=nomeVar.upper()
-		if not cls.exist(nomeVar):
-			cls.setOrReplace(nomeVar,valore)
-			return
-		if addFirst:
-			cls.setOrReplace(nomeVar,valore+separatore+os.environ[nomeVar])
-		else:
-			if not os.environ[nomeVar].endswith(separatore):
-				os.environ[nomeVar]+=separatore
-			os.environ[nomeVar]+=valore
-	@staticmethod
-	def setOrReplace(nomeVar:str,valore:str):
-		os.environ[nomeVar]=valore
-
-	@staticmethod
-	def getOrNone(nomeVar:str)->str|None:
-		return os.environ.get(nomeVar,None)
-	
-	@staticmethod
-	def exist(nomeVar:str)->bool:
-		return nomeVar in os.environ
+import os
+
+from modulitiz_nano.sistema.ModuloSystem import ModuloSystem
+
+
+class ModuloEnvVars(object):
+	
+	@classmethod
+	def add(cls,nomeVar:str,valore:str,addFirst:bool):
+		if not ModuloSystem.isWindows():
+			separatore=":"
+		else:
+			separatore=";"
+		nomeVar=nomeVar.upper()
+		if not cls.exist(nomeVar):
+			cls.setOrReplace(nomeVar,valore)
+			return
+		if addFirst:
+			cls.setOrReplace(nomeVar,valore+separatore+os.environ[nomeVar])
+		else:
+			if not os.environ[nomeVar].endswith(separatore):
+				os.environ[nomeVar]+=separatore
+			os.environ[nomeVar]+=valore
+	@staticmethod
+	def setOrReplace(nomeVar:str,valore:str):
+		os.environ[nomeVar]=valore
+
+	@staticmethod
+	def getOrNone(nomeVar:str)->str|None:
+		return os.environ.get(nomeVar,None)
+	
+	@staticmethod
+	def exist(nomeVar:str)->bool:
+		return nomeVar in os.environ

modulitiz_micro/sistema/ModuloSystemPipe.py

@@ -1,67 +1,67 @@
-import multiprocessing
-import queue
-import subprocess
-import threading
-import time
-
-import psutil
-
-from modulitiz_nano.files.ModuloLogging import ModuloLogging
-from modulitiz_nano.multithread.ModuloThread import ModuloThread
-from modulitiz_nano.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,))
+import multiprocessing
+import queue
+import subprocess
+import threading
+import time
+
+import psutil
+
+from modulitiz_nano.files.ModuloLogging import ModuloLogging
+from modulitiz_nano.multithread.ModuloThread import ModuloThread
+from modulitiz_nano.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/AbstractModuloTelegram.py

@@ -1,53 +1,53 @@
-from abc import ABC
-from abc import abstractmethod
-
-from telethon import TelegramClient
-
-from modulitiz_nano.ModuloStringhe import ModuloStringhe
-from modulitiz_nano.util.decorators.noAwait import noAwait
-
-
-class AbstractModuloTelegram(ABC):
-	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.
-		"""
+from abc import ABC
+from abc import abstractmethod
+
+from telethon import TelegramClient
+
+from modulitiz_nano.ModuloStringhe import ModuloStringhe
+from modulitiz_nano.util.decorators.noAwait import noAwait
+
+
+class AbstractModuloTelegram(ABC):
+	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

@@ -1,26 +1,26 @@
-from modulitiz_micro.social.telegram.AbstractModuloTelegram import AbstractModuloTelegram
-
-
-class ModuloTelegramSimple(AbstractModuloTelegram):
-	"""
-	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)
+from modulitiz_micro.social.telegram.AbstractModuloTelegram import AbstractModuloTelegram
+
+
+class ModuloTelegramSimple(AbstractModuloTelegram):
+	"""
+	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/globalvar/AbstractBasicGlobalVarBean.py

@@ -1,15 +1,15 @@
-from modulitiz_micro.rete.ntp.ModuloNtpIt import ModuloNtpIt
-
-from modulitiz_nano.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)
-	
+from modulitiz_micro.rete.ntp.ModuloNtpIt import ModuloNtpIt
+
+from modulitiz_nano.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/scheduler/ModuleScheduler.py

@@ -1,26 +1,26 @@
-import schedule
-
-from modulitiz_nano.ModuloListe import ModuloListe
-
-
-class ModuleScheduler(object):
-	@staticmethod
-	def cancelJobByTag(tag:str):
-		schedule.clear(tag)
-	
-	@classmethod
-	def rescheduleJob(cls,tag:str,timeStr:str)->schedule.Job|None:
-		# recupero il job
-		jobs=schedule.get_jobs(tag)
-		if ModuloListe.isEmpty(jobs):
-			return None
-		job=jobs[0]
-		# cambio l'orario
-		job.at(timeStr)
-		# cancello quello vecchio
-		cls.cancelJobByTag(tag)
-		# lo aggiungo alla lista
-		job.scheduler.jobs.append(job)
-		# lo rischedulo
-		job._schedule_next_run()
-		return job
+import schedule
+
+from modulitiz_nano.ModuloListe import ModuloListe
+
+
+class ModuleScheduler(object):
+	@staticmethod
+	def cancelJobByTag(tag:str):
+		schedule.clear(tag)
+	
+	@classmethod
+	def rescheduleJob(cls,tag:str,timeStr:str)->schedule.Job|None:
+		# recupero il job
+		jobs=schedule.get_jobs(tag)
+		if ModuloListe.isEmpty(jobs):
+			return None
+		job=jobs[0]
+		# cambio l'orario
+		job.at(timeStr)
+		# cancello quello vecchio
+		cls.cancelJobByTag(tag)
+		# lo aggiungo alla lista
+		job.scheduler.jobs.append(job)
+		# lo rischedulo
+		job._schedule_next_run()
+		return job

modulitiz_micro/weather/AbstractModuleWeather.py

@@ -1,31 +1,31 @@
-import json
-from abc import ABC
-
-from modulitiz_micro.eccezioni.http.EccezioneHttpGeneric import EccezioneHttpGeneric
-from modulitiz_micro.rete.http.ModuloHttp import ModuloHttp
-from modulitiz_micro.rete.http.ModuloHttpUtils import ModuloHttpUtils
-from modulitiz_nano.files.ModuloLogging import ModuloLogging
-
-
-class AbstractModuleWeather(ABC):
-	OPTIONS="lang=it&units=metric"
-	KEY="appid=e28cd365c35c12e3ed8f2d84e04398c9"
-	
-	__BASE_URL="https://api.openweathermap.org"
-	URL_CURRENT=__BASE_URL+f"/data/2.5/weather?{OPTIONS}&{KEY}&q="
-	URL_FORECAST=__BASE_URL+f"/data/2.5/forecast?{OPTIONS}&{KEY}&q="
-	
-	def __init__(self,logger:ModuloLogging):
-		self._logger=logger
-	
-	def _makeForecastRequest(self,baseUrl:str,city:str,codState:str):
-		return self._makeGenericRequest(baseUrl,city, codState)['list']
-	
-	def _makeGenericRequest(self,baseUrl:str,city:str,codState:str):
-		url=baseUrl+ModuloHttpUtils.encodeUrl(city+","+codState)
-		http=ModuloHttp(url,self._logger,False)
-		try:
-			response=http.doGet(0,False)
-		except EccezioneHttpGeneric:
-			return None
-		return json.loads(response.responseBody)
+import json
+from abc import ABC
+
+from modulitiz_micro.eccezioni.http.EccezioneHttpGeneric import EccezioneHttpGeneric
+from modulitiz_micro.rete.http.ModuloHttp import ModuloHttp
+from modulitiz_micro.rete.http.ModuloHttpUtils import ModuloHttpUtils
+from modulitiz_nano.files.ModuloLogging import ModuloLogging
+
+
+class AbstractModuleWeather(ABC):
+	OPTIONS="lang=it&units=metric"
+	KEY="appid=e28cd365c35c12e3ed8f2d84e04398c9"
+	
+	__BASE_URL="https://api.openweathermap.org"
+	URL_CURRENT=__BASE_URL+f"/data/2.5/weather?{OPTIONS}&{KEY}&q="
+	URL_FORECAST=__BASE_URL+f"/data/2.5/forecast?{OPTIONS}&{KEY}&q="
+	
+	def __init__(self,logger:ModuloLogging):
+		self._logger=logger
+	
+	def _makeForecastRequest(self,baseUrl:str,city:str,codState:str):
+		return self._makeGenericRequest(baseUrl,city, codState)['list']
+	
+	def _makeGenericRequest(self,baseUrl:str,city:str,codState:str):
+		url=baseUrl+ModuloHttpUtils.encodeUrl(city+","+codState)
+		http=ModuloHttp(url,self._logger,False)
+		try:
+			response=http.doGet(0,False)
+		except EccezioneHttpGeneric:
+			return None
+		return json.loads(response.responseBody)

modulitiz_micro/weather/ModuleWeather.py

@@ -1,62 +1,62 @@
-from modulitiz_micro.weather.AbstractModuleWeather import AbstractModuleWeather
-from modulitiz_nano.ModuloDate import ModuloDate
-from modulitiz_nano.ModuloListe import ModuloListe
-
-
-class ModuleWeather(AbstractModuleWeather):
-	"""
-	Utility for current weather and forecasts.
-	"""
-	OPTIONS="lang=it&units=metric"
-	KEY="appid=e28cd365c35c12e3ed8f2d84e04398c9"
-	
-	__BASE_URL="https://api.openweathermap.org"
-	URL_CURRENT=__BASE_URL+f"/data/2.5/weather?{OPTIONS}&{KEY}&q="
-	URL_FORECAST=__BASE_URL+f"/data/2.5/forecast?{OPTIONS}&{KEY}&q="
-	
-	def __init__(self,*args,**kwargs):
-		super().__init__(*args,**kwargs)
-	
-	def getCurrent(self,city:str,codState:str)-> dict:
-		return self._makeGenericRequest(self.URL_CURRENT,city,codState)
-	
-	def getForecastRainUntilTomorrow(self,city:str,codState:str)-> list|None:
-		"""
-		Chiede le previsioni fino al giorno dopo e mostra solo i risultati che dicono che pioverà.
-		"""
-		now=ModuloDate.now()
-		tomorrow=ModuloDate.setEndOfDay(ModuloDate.plusMinusDays(now,1))
-		hoursDiff=ModuloDate.hoursDiff(tomorrow, now)
-		elements=self.__getForecasts(city, codState,True,None,hoursDiff)
-		if elements is None:
-			return None
-		# filter elements
-		results=[]
-		for elem in elements:
-			if ModuloListe.collectionSafeGet(elem,'rain') is not None:
-				results.append(elem)
-		return results
-	
-	def __getForecasts(self,city:str,codState:str,includeFirstForecast:bool,stepHours: int|None,maxHours:int)-> list|None:
-		results=self._makeForecastRequest(self.URL_FORECAST,city,codState)
-		maxLista=len(results)
-		# calculate indexes
-		if maxHours is not None:
-			maxInd=int(maxHours/3)+1
-			if maxInd>=maxLista:
-				maxInd=maxLista-1
-		else:
-			maxInd=maxLista-1
-		if stepHours is None:
-			step=1
-		else:
-			step=int(stepHours/3)
-		inds=list(range(4,maxInd,step))
-		if includeFirstForecast:
-			inds.insert(0,1)
-		# process json
-		output=[]
-		for ind in inds:
-			elem=results[ind]
-			output.append(elem)
-		return output
+from modulitiz_micro.weather.AbstractModuleWeather import AbstractModuleWeather
+from modulitiz_nano.ModuloDate import ModuloDate
+from modulitiz_nano.ModuloListe import ModuloListe
+
+
+class ModuleWeather(AbstractModuleWeather):
+	"""
+	Utility for current weather and forecasts.
+	"""
+	OPTIONS="lang=it&units=metric"
+	KEY="appid=e28cd365c35c12e3ed8f2d84e04398c9"
+	
+	__BASE_URL="https://api.openweathermap.org"
+	URL_CURRENT=__BASE_URL+f"/data/2.5/weather?{OPTIONS}&{KEY}&q="
+	URL_FORECAST=__BASE_URL+f"/data/2.5/forecast?{OPTIONS}&{KEY}&q="
+	
+	def __init__(self,*args,**kwargs):
+		super().__init__(*args,**kwargs)
+	
+	def getCurrent(self,city:str,codState:str)-> dict:
+		return self._makeGenericRequest(self.URL_CURRENT,city,codState)
+	
+	def getForecastRainUntilTomorrow(self,city:str,codState:str)-> list|None:
+		"""
+		Chiede le previsioni fino al giorno dopo e mostra solo i risultati che dicono che pioverà.
+		"""
+		now=ModuloDate.now()
+		tomorrow=ModuloDate.setEndOfDay(ModuloDate.plusMinusDays(now,1))
+		hoursDiff=ModuloDate.hoursDiff(tomorrow, now)
+		elements=self.__getForecasts(city, codState,True,None,hoursDiff)
+		if elements is None:
+			return None
+		# filter elements
+		results=[]
+		for elem in elements:
+			if ModuloListe.collectionSafeGet(elem,'rain') is not None:
+				results.append(elem)
+		return results
+	
+	def __getForecasts(self,city:str,codState:str,includeFirstForecast:bool,stepHours: int|None,maxHours:int)-> list|None:
+		results=self._makeForecastRequest(self.URL_FORECAST,city,codState)
+		maxLista=len(results)
+		# calculate indexes
+		if maxHours is not None:
+			maxInd=int(maxHours/3)+1
+			if maxInd>=maxLista:
+				maxInd=maxLista-1
+		else:
+			maxInd=maxLista-1
+		if stepHours is None:
+			step=1
+		else:
+			step=int(stepHours/3)
+		inds=list(range(4,maxInd,step))
+		if includeFirstForecast:
+			inds.insert(0,1)
+		# process json
+		output=[]
+		for ind in inds:
+			elem=results[ind]
+			output.append(elem)
+		return output