modulitiz-micro 2.31.0__py311-none-any.whl → 2.32.0__py311-none-any.whl

modulitiz_micro/ModuloFunzioni.py

@@ -1,58 +1,70 @@
-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))
+import ast
+import random
+import sys
+
+from modulitiz_micro.files.ModuloFiles import ModuloFiles
+
+
+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 getClassesFromFileSource(filename:str)->list[str]:
+		"""
+		Reads content of file, then finds all classes in it.
+		"""
+		module=ast.parse(ModuloFiles.readFileText(filename,True))
+		classes=[node.name for node in ast.walk(module) if isinstance(node,ast.ClassDef)]
+		return classes
+	
+	@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

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

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