modulitiz-micro 2.40.0__py311-none-any.whl → 2.42.0__py311-none-any.whl

{modulitiz_micro-2.40.0.dist-info → modulitiz_micro-2.42.0.dist-info/licenses}/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2023-2040 tiz
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2023-2040 tiz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

modulitiz_micro/ModuleEnum.py

@@ -1,8 +0,0 @@
-class ModuleEnum(object):
-	@staticmethod
-	def isValueIn(value, enumClass)->bool:
-		try:
-			enumClass(value)
-		except ValueError:
-			return False
-		return True

modulitiz_micro/ModuloBase64.py

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

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

@@ -1,295 +0,0 @@
-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 lavorare con 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

@@ -1,71 +0,0 @@
-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.
-		Also counts inner classes.
-		"""
-		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 +0,0 @@
-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