modulitiz-micro 2.26.0__py311-none-any.whl

modulitiz_micro/ModuloBase64.py

@@ -0,0 +1,61 @@
+import base64
+
+from modulitiz_micro.ModuloStringhe import ModuloStringhe
+
+
+class ModuloBase64(object):
+	"""
+	Utility di gestione del sistema di codifica base64.
+	"""
+	
+	@staticmethod
+	def codificaFile(inputFile:str,outputFile:str):
+		"""
+		Legge un file binario e scrive un file con il relativo contenuto codificato.
+		"""
+		# leggo
+		with open(inputFile,"rb") as fp:
+			contenuto=fp.read()
+		# codifico
+		encoded=base64.b64encode(contenuto)
+		# scrivo
+		with open(outputFile,"w+b") as fp:
+			fp.write(encoded)
+	@staticmethod
+	def codificaStr(decodedStr:str)->str:
+		"""
+		Converte una stringa.
+		"""
+		return base64.b64encode(decodedStr.encode(ModuloStringhe.CODIFICA_UTF8)).decode(ModuloStringhe.CODIFICA_UTF8)
+	@staticmethod
+	def codificaStrUrlSafe(decodedStr:str)->str:
+		"""
+		Converte una stringa in modo che possa essere usata come url.
+		"""
+		return base64.urlsafe_b64encode(decodedStr.encode(ModuloStringhe.CODIFICA_UTF8)).decode(ModuloStringhe.CODIFICA_UTF8)
+
+	@staticmethod
+	def decodificaFile(inputFile:str,outputFile:str):
+		"""
+		Legge il contenuto codificato di un file e lo decodifica, scrivendo l'output in un altro file.
+		"""
+		# leggo
+		with open(inputFile,"rb") as fp:
+			contenuto=fp.read()
+		# decodifico
+		decoded=base64.b64decode(contenuto)
+		# scrivo
+		with open(outputFile,"w+b") as fp:
+			fp.write(decoded)
+	@staticmethod
+	def decodificaStr(codedStr:str)->str:
+		"""
+		Decodifica una stringa.
+		"""
+		return base64.b64decode(codedStr.encode(ModuloStringhe.CODIFICA_UTF8)).decode(ModuloStringhe.CODIFICA_UTF8)
+	@staticmethod
+	def decodificaStrUrlSafe(codedStr:str)->str:
+		"""
+		Decodifica una stringa che è stata codificata per essere usata come url.
+		"""
+		return base64.urlsafe_b64decode(codedStr.encode(ModuloStringhe.CODIFICA_UTF8)).decode(ModuloStringhe.CODIFICA_UTF8)

modulitiz_micro/ModuloColorText.py

@@ -0,0 +1,35 @@
+import colorama
+import webcolors
+
+from modulitiz_micro.rete.http.ModuloHttpUtils import ModuloHttpUtils
+
+
+class ModuloColorText(object):
+	"""
+	Utility per gestire i colori e stampare a schermo testo colorato.
+	"""
+	
+	DEFAULT=	'\033[0m'
+	GRASSETTO=	DEFAULT+'\033[1m'
+	NERO=		'\033[90m'
+	ROSSO=		'\033[91m'
+	VERDE=		'\033[92m'
+	GIALLO=		'\033[93m'
+	BLU=		'\033[94m'
+	FUCSIA=		'\033[95m'
+	AZZURRO=	'\033[96m'
+	
+	def __init__(self):
+		colorama.init()
+	
+	@staticmethod
+	def wordToRGB(word:str,lang:str="en")->str|None:
+		"""
+		Traduce un colore in formato RGB, è possibile scegliere la lingua di origine.
+		"""
+		if lang!="en":
+			word=ModuloHttpUtils.translate(lang,"en",word)
+			if word is None:
+				return None
+		word=word.replace(" ","").replace("ish","")
+		return webcolors.name_to_hex(word)

modulitiz_micro/ModuloDate.py

@@ -0,0 +1,295 @@
+import time
+from datetime import UTC
+from datetime import date
+from datetime import datetime
+from datetime import time as dt_time
+from datetime import timedelta
+from datetime import timezone
+
+
+class ModuloDate(object):
+	"""
+	Utility per gestire operazioni e formattazioni sulle date.
+	"""
+	
+	FORMATO_DATA="%Y-%m-%d"
+	FORMATO_DATA_IT="%d/%m/%Y"
+	FORMATO_DATA_ORA="%Y-%m-%d %H:%M:%S"
+	FORMATO_DATA_ORA_NOMEFILE="%Y-%m-%d_%H-%M-%S"
+	FORMATO_DATA_ORA_NOSPAZI="%Y%m%d%H%M%S"
+	FORMATO_ORA="%H:%M:%S"
+	
+	
+	@staticmethod
+	def now()->datetime:
+		"""
+		Data e ora attuali.
+		"""
+		return datetime.now()
+	
+	@classmethod
+	def nowUtc(cls)->datetime:
+		"""
+		Data e ora attuali in formato UTC (quindi senza fuso orario e DST)
+		"""
+		data=datetime.now(timezone.utc)
+		data=cls.setTimezoneUtc(data)
+		return data
+	
+	@staticmethod
+	def today()->date:
+		"""
+		Data odierna, senza ora.
+		"""
+		return date.today()
+	
+	@staticmethod
+	def getSecs()->int:
+		"""
+		Timestamp in secondi in formato UTC
+		"""
+		return int(time.time())
+	
+	@staticmethod
+	def getMillis()->int:
+		"""
+		Timestamp in millisecondi in formato UTC
+		"""
+		return int(time.time()*1000)
+	
+	@classmethod
+	def getWeekDay(cls,data:datetime|None=None)->str:
+		"""
+		Se te lo restituisce in inglese devi settare il locale
+		"""
+		if data is None:
+			data=cls.now()
+		return data.date().strftime("%A")
+	
+	#
+	# conversioni
+	#
+	@classmethod
+	def dateToString(cls,data:datetime|None=None,formato:str=FORMATO_DATA_ORA)->str:
+		"""
+		Formatta un oggetto data.
+		:param data: data da formattare, se non specificata viene usata la data attuale
+		:param formato: in che modo deve essere formattata la data, se non specificato viene usato il formato inglese
+		"""
+		if data is None:
+			data=cls.now()
+		return data.strftime(formato)
+	
+	@staticmethod
+	def stringToDate(stringa:str,formato:str=FORMATO_DATA_ORA)->datetime:
+		"""
+		Trasforma una data in formato stringa a oggetto.
+		:param stringa: stringa da trasformare in data
+		:param formato: in che modo deve essere formattata la data, se non specificato viene usato il formato inglese
+		"""
+		return datetime.strptime(stringa,formato)
+	
+	@staticmethod
+	def timeToString(orario:dt_time,formato:str=FORMATO_ORA)->str:
+		"""
+		Formatta un oggetto di tipo ora.
+		:param orario: orario da formattare
+		:param formato: in che modo deve essere formattato l'orario, se non specificato viene usato il formato standard
+		"""
+		return orario.strftime(formato)
+	@classmethod
+	def stringToTime(cls,stringa:str,formato:str=FORMATO_ORA)->dt_time:
+		"""
+		Formatta un oggetto di tipo ora.
+		:param stringa: stringa da formattare in orario
+		:param formato: in che modo deve essere formattato l'orario, se non specificato viene usato il formato standard
+		"""
+		return cls.dateToTime(cls.stringToDate(stringa,formato))
+	
+	@classmethod
+	def timeToDate(cls,orario:dt_time)->datetime:
+		"""
+		Converte da oggetto orario a data completa.
+		Viene aggiunta la data odierna all'orario passato in input.
+		"""
+		return datetime.combine(cls.today(), orario)
+	
+	@staticmethod
+	def timedeltaToTime(orario:timedelta)->dt_time:
+		"""
+		Converte un oggetto timedelta a oggetto orario.
+		"""
+		return (datetime.min + orario).time()
+	
+	@staticmethod
+	def dateToTime(data:datetime)->dt_time:
+		"""
+		Rimuove la data da un oggetto data completo, lasciando solo l'orario.
+		"""
+		return data.time()
+	
+	@staticmethod
+	def dateToTimestamp(data:datetime)->int:
+		"""
+		Converte un oggetto data completo in timestamp in secondi.
+		Se ti serve avere il timestamp in formato UTC usa il metodo dedicato.
+		"""
+		return int(datetime.timestamp(data))
+	@staticmethod
+	def timestampToDate(timestamp:int|float)->datetime:
+		"""
+		Converte un timestamp in secondi in un oggetto data completo.
+		Se ti serve avere il timestamp in formato UTC usa il metodo dedicato.
+		"""
+		return datetime.fromtimestamp(timestamp)
+	
+	@classmethod
+	def dateToTimestampUtc(cls,data:datetime)->int:
+		"""
+		Converte un oggetto data completo in timestamp in secondi in formato UTC.
+		"""
+		return cls.dateToTimestamp(cls.setTimezoneUtc(data))
+	@classmethod
+	def timestampUtcToDate(cls,timestamp:int|float)->datetime:
+		"""
+		Converte un timestamp in secondi in formato UTC in un oggetto data completo.
+		Questo metodo richiede python >= 3.11
+		"""
+		return datetime.fromtimestamp(timestamp,UTC)
+	
+	#
+	# operazioni
+	#
+	@staticmethod
+	def dateDiff(data1:datetime,data2:datetime)->timedelta:
+		"""
+		Calcola la differenza di tempo (sia data che oraria) tra 2 date complete.
+		"""
+		return data1-data2
+	
+	@classmethod
+	def minutesDiff(cls,data1:datetime,data2:datetime)->int:
+		"""
+		Calcola la differenza in minuti tra 2 date complete.
+		"""
+		diff=cls.dateDiff(data1,data2)
+		diffValue=0
+		if diff.days is not None and diff.days!=0:
+			diffValue+=diff.days*24*60
+		diffValue+=int(diff.seconds/60)
+		return diffValue
+	@classmethod
+	def hoursDiff(cls,data1:datetime,data2:datetime)->int:
+		"""
+		Calcola la differenza in ore tra 2 date complete.
+		"""
+		diff=cls.dateDiff(data1, data2)
+		diffValue=0
+		if diff.days is not None and diff.days!=0:
+			diffValue+=diff.days*24
+		diffValue+=int(diff.seconds/3600)
+		return diffValue
+	@classmethod
+	def daysDiff(cls,data1:datetime,data2:datetime) -> int:
+		"""
+		Calcola la differenza in giorni tra 2 date complete.
+		"""
+		diff=cls.dateDiff(data1,data2)
+		if diff.days is not None and diff.days!=0:
+			return diff.days
+		return 0
+	
+	@staticmethod
+	def plusMinusDays(data:datetime,days:int|float)->datetime:
+		"""
+		Aggiunge o toglie giorni ad una data completa.
+		"""
+		td=timedelta(days=abs(days))
+		if days>=0:
+			return data + td
+		return data - td
+	
+	@staticmethod
+	def plusMinusHours(data:datetime,hours:int|float)->datetime:
+		"""
+		Aggiunge o toglie ore ad una data completa.
+		"""
+		td=timedelta(hours=abs(hours))
+		if hours>=0:
+			return data + td
+		return data - td
+	
+	@staticmethod
+	def plusMinusMinutes(data:datetime,minutes:int|float)->datetime:
+		"""
+		Aggiunge o toglie minuti ad una data completa.
+		"""
+		td=timedelta(minutes=abs(minutes))
+		if minutes>=0:
+			return data + td
+		return data - td
+	
+	@staticmethod
+	def plusMinusSeconds(data:datetime,seconds:int|float)->datetime:
+		"""
+		Aggiunge o toglie minuti ad una data completa.
+		"""
+		td=timedelta(seconds=abs(seconds))
+		if seconds>=0:
+			return data + td
+		return data - td
+	
+	@staticmethod
+	def setStartOfDay(data:datetime)->datetime:
+		"""
+		Imposta l'inizio del giorno ad una data completa.
+		"""
+		return data.replace(hour=0, minute=0, second=0, microsecond=0)
+	
+	@staticmethod
+	def setEndOfDay(data:datetime)->datetime:
+		"""
+		Imposta la fine del giorno ad una data completa.
+		"""
+		return data.replace(hour=23, minute=59, second=59, microsecond=999999)
+	
+	@classmethod
+	def setTimezoneLocale(cls,data:datetime)->datetime:
+		"""
+		Imposta il fuso orario locale ad una data completa.
+		"""
+		return cls.setTimezoneUtc(data).astimezone(tz=None)
+	
+	@classmethod
+	def setTimezoneUtc(cls,data:datetime)->datetime:
+		"""
+		Imposta SOLO il fuso orario UTC ad una data completa.
+		"""
+		return cls.setTimezoneFromTzInfo(data,timezone.utc)
+	
+	@staticmethod
+	def setTimezoneFromTzInfo(data:datetime,tz:datetime.tzinfo)->datetime:
+		"""
+		Imposta un fuso orario ad una data completa.
+		"""
+		return data.replace(tzinfo=tz)
+	
+	@classmethod
+	def getTimezoneLocal(cls)->datetime.tzinfo:
+		"""
+		Ritorna il fuso orario locale.
+		"""
+		return cls.now().astimezone().tzinfo
+	
+	#
+	# altre funzioni
+	#
+	@classmethod
+	def calculateElapsedSecs(cls,millisInizio:int)->str:
+		"""
+		Crea la frase che mostra quanti secondi sono trascorsi dall'inizio.
+		"""
+		elapsedSecs=int((cls.getMillis()-millisInizio)*0.001)
+		if elapsedSecs==0:
+			return ""
+		return f" in {elapsedSecs}s"

modulitiz_micro/ModuloFunzioni.py

@@ -0,0 +1,58 @@
+import random
+import sys
+
+
+class ModuloFunzioni(object):
+	"""
+	Utility riguardanti le funzioni o non catalogabili in modo definito.
+	"""
+	
+	GENERI={'m':'Maschio','f':'Femmina'}
+	
+	@staticmethod
+	def getFunctionName(n:int=0)->str:
+		"""
+		Per il nome della funzione corrente, non impostare nessun parametro o impostare 0;
+		Per il nome della funzione chiamante, impostare 1;
+		Per il nome della funzione chiamante la funzione, impostare 2;
+		E via dicendo così.
+		"""
+		return sys._getframe(n + 1).f_code.co_name
+
+	@staticmethod
+	def getFullyQualifiedName(funzione)->str:
+		"""
+		Ritorna il package + il nome della funzione;
+		in questo modo è possibile distinguere 2 funzioni con lo stesso nome, ad esempio:
+		src.funzione
+		src.package.funzione
+		src.package.modulo.funzione
+		src.package.modulo.classe.funzione
+		"""
+		return funzione.__module__+"."+funzione.__qualname__
+	
+	@staticmethod
+	def orderDict(diz:dict)->dict:
+		"""
+		Ordina gli elementi di un dizionario.
+		Nota: ha senso solo se hai intenzione di esporlo all'utente sotto forma di lista.
+		"""
+		myKeys = list(diz.keys())
+		myKeys.sort()
+		newDiz = {i: diz[i] for i in myKeys}
+		return newDiz
+	
+	@staticmethod
+	def dictGetFirstValue(diz: dict):
+		"""
+		Ritorna il valore del primo elemnto di un dizionario.
+		È ottimizzato per oggetti con molti elementi.
+		"""
+		return next(iter(diz.items()))[1]
+	
+	@staticmethod
+	def randomBoolean()->bool:
+		"""
+		Genera un valore booleano in modo randomico.
+		"""
+		return bool(random.getrandbits(1))

modulitiz_micro/ModuloListe.py

@@ -0,0 +1,150 @@
+import re
+
+from modulitiz_micro.ModuloStringhe import ModuloStringhe
+
+
+class ModuloListe(object):
+	"""
+	Utility di gestione degli oggetti liste.
+	"""
+	
+	@staticmethod
+	def mergeListsOfDicts(listaFrom: list[dict],keyFrom: str|int,listaTo: list[dict],keyTo: str|int) -> list[dict]:
+		"""
+		Esempio: queste due liste...
+		[
+			{'index':1},
+			{'index':3}
+		]
+
+		[
+			{'id':1,'val':'a'},
+			{'id':2,'val':'b'},
+			{'id':3,'val':'c'},
+			{'id':4,'val':'d'}
+		]
+
+		... diventano così
+
+		[
+			{'id':1,'val':'a'},
+			{'id':3,'val':'c'}
+		]
+		"""
+		nuovaLista=[]
+		for elemFrom in listaFrom:
+			valore=str(elemFrom[keyFrom])
+			for elemTo in listaTo:
+				if str(elemTo[keyTo])==valore:
+					nuovaLista.append(elemTo)
+		return nuovaLista
+	
+	@classmethod
+	def humanOrder(cls,lista: list) -> list:
+		"""
+		Ordina una lista in modo che sia più leggibile: ad esempio:
+		[elemento1,elemento10,elemento2]
+		viene ordinato in questo modo:
+		[elemento1,elemento2,elemento10]
+		invece che:
+		[elemento10,elemento1,elemento2]
+		"""
+		convert=lambda text:int(text) if text.isdigit() else text
+		alphanum=lambda key:[convert(c) for c in re.split(r'(\d+)',key)]
+		return sorted(lista,key=alphanum)
+	
+	@staticmethod
+	def eliminaElementi(lista: list,elemsToRemove: list|tuple) -> list:
+		"""
+		Elimina dalla lista gli elementi specificati.
+		"""
+		for elemToRemove in elemsToRemove:
+			while elemToRemove in lista:
+				lista.remove(elemToRemove)
+		return lista
+	
+	@classmethod
+	def eliminaElementiVuoti(cls,lista: list) -> list:
+		"""
+		Elimina dalla lista le stringhe vuote e gli elementi null
+		"""
+		return cls.eliminaElementi(lista,(None,""))
+	
+	@staticmethod
+	def diff(lista1: list,lista2: list) -> tuple:
+		"""
+		Calcola la differenza tra 2 liste, mostra gli elementi che mancano dalla 1a alla 2a e viceversa.
+		"""
+		set1=set(lista1)
+		set2=set(lista2)
+		toAdd=list(set1-set2)
+		toRemove=list(set2-set1)
+		return toAdd,toRemove
+	
+	@staticmethod
+	def affianca(lista1: list,lista2: list) -> list:
+		"""
+		Unisce 2 liste.
+		"""
+		return list(zip(lista1,lista2))
+	
+	@staticmethod
+	def separa(lista: list) -> list:
+		"""
+		Separa 2 liste.
+		"""
+		return [list(x) for x in zip(*lista)]
+	
+	@staticmethod
+	def chunks(lista: list,n: int):
+		"""
+		Divide una lista in una lista di liste.
+		"""
+		for i in range(0,len(lista),n):
+			yield lista[i:i+n]
+	
+	@staticmethod
+	def isEmpty(lista: list) -> bool:
+		"""
+		Verifica se una lista è null o vuota.
+		"""
+		return lista is None or lista==[]
+	
+	@staticmethod
+	def collectionContainsString(lista: list|tuple,testo: str) -> bool:
+		"""
+		Verifica se almeno un elemento di una lista o una tupla contiene una stringa.
+		"""
+		for elem in lista:
+			if ModuloStringhe.contains(elem,testo):
+				return True
+		return False
+	
+	@staticmethod
+	def stringContainsCollection(testo: str,lista: list|tuple) -> bool:
+		"""
+		Verifica se una stringa contiene almeno un elemento di una lista o una tupla.
+		"""
+		for elem in lista:
+			if ModuloStringhe.contains(testo,elem):
+				return True
+		return False
+	
+	@staticmethod
+	def collectionSafeGet(collection: dict|list|tuple,*keys):
+		"""
+		Ritorna elementi innestati in un dizionario, lista o tupla in una sola volta.
+		Se un elemento intermedio non esiste ritorna null.
+		Ad esempio:
+		'ciao' = funzione(
+			{'a':[('ciao',),]}
+			,
+			'a',0,0
+		)
+		"""
+		for key in keys:
+			try:
+				collection=collection[key]
+			except (IndexError,KeyError):
+				return
+		return collection

modulitiz_micro/ModuloMeteo.py

@@ -0,0 +1,72 @@
+import json
+
+from modulitiz_micro.ModuloDate import ModuloDate
+from modulitiz_micro.ModuloListe import ModuloListe
+from modulitiz_micro.eccezioni.http.EccezioneHttpGeneric import EccezioneHttpGeneric
+from modulitiz_micro.files import ModuloLogging
+from modulitiz_micro.rete.http.ModuloHttp import ModuloHttp
+from modulitiz_micro.rete.http.ModuloHttpUtils import ModuloHttpUtils
+
+
+class ModuloMeteo(object):
+	"""
+	Utility di gestione delle previsioni meteo.
+	"""
+	OPZIONI="lang=it&units=metric"
+	KEY="appid=e28cd365c35c12e3ed8f2d84e04398c9"
+	
+	__URL_BASE="https://api.openweathermap.org"
+	URL_ATTUALE=__URL_BASE+f"/data/2.5/weather?{OPZIONI}&{KEY}&q="
+	URL_PREVISIONE=__URL_BASE+f"/data/2.5/forecast?{OPZIONI}&{KEY}&q="
+	
+	def __init__(self,logger:ModuloLogging):
+		self.__logger=logger
+	
+	def getPrevisionePioggiaFinoADomani(self,citta:str,codStato:str)->list|None:
+		"""
+		Chiede le previsioni fino al giorno dopo e mostra solo i risultati che dicono che pioverà.
+		"""
+		adesso=ModuloDate.now()
+		domani=ModuloDate.setEndOfDay(ModuloDate.plusMinusDays(adesso,1))
+		oreDiff=ModuloDate.hoursDiff(domani, adesso)
+		elementi=self.__getPrevisioni(citta, codStato,True,None,oreDiff)
+		if elementi is None:
+			return None
+		# filtro gli elementi
+		lista=[]
+		for elem in elementi:
+			if ModuloListe.collectionSafeGet(elem,'rain') is not None:
+				lista.append(elem)
+		return lista
+	
+	def __getPrevisioni(self,citta:str,codStato:str,includiPrimaPrevisione:bool,stepHours:int|None,maxHours:int)->list|None:
+		cittaEStato=citta+","+codStato
+		url=self.URL_PREVISIONE+ModuloHttpUtils.encodeUrl(cittaEStato)
+		http=ModuloHttp(url,self.__logger,False)
+		try:
+			response=http.doGet(0,False)
+		except EccezioneHttpGeneric:
+			return None
+		responseObj=json.loads(response.responseBody)
+		lista=responseObj['list']
+		maxLista=len(lista)
+		# calcolo gli indici
+		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 includiPrimaPrevisione:
+			inds.insert(0,1)
+		# processo il json
+		output=[]
+		for ind in inds:
+			elem=lista[ind]
+			output.append(elem)
+		return output