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

modulitiz_micro/ModuloNumeri.py

@@ -1,127 +0,0 @@
-class ModuloNumeri(object):
-	"""
-	Utility di gestione dei numeri, sia interi (senza virgola) che floating-point (con decimali) che con o senza segno.
-	"""
-	
-	UNO_DIVISO_1024=0.0009765625
-	
-	NUMERI_CARDINALI={
-		0:"zero",
-		1:"uno",
-		2:"due",
-		3:"tre",
-		4:"quattro",
-		5:"cinque",
-		6:"sei",
-		7:"sette",
-		8:"otto",
-		9:"nove",
-		10:"dieci",
-		11:"undici"
-	}
-	
-	NUMERI_ORDINALI={
-		"primo":1,
-	}
-	
-	@staticmethod
-	def isInt(valore)->bool:
-		"""
-		Determina se un valore può essere considerato un numero intero.
-		"""
-		try:
-			int(valore)
-			return True
-		except ValueError:
-			return False
-	
-	@staticmethod
-	def isFloat(valore)->bool:
-		"""
-		Determina se un valore può essere considerato un numero con la virgola.
-		"""
-		try:
-			float(valore)
-			return True
-		except ValueError:
-			return False
-
-	@staticmethod
-	def strToInt(valore:str)->int|None:
-		"""
-		Converte una stringa in numero intero.
-		"""
-		try:
-			return int(valore)
-		except ValueError:
-			return None
-
-	@staticmethod
-	def intToBool(valore:int)->bool:
-		"""
-		Converte un numero intero in valore booleano (o binario).
-		"""
-		return int(valore)==1
-
-	@staticmethod
-	def boolToInt(valore:bool)->int:
-		"""
-		Converte un valore booleano (o binario) in numero intero.
-		"""
-		return int(valore)
-
-	@classmethod
-	def byteToKilobyte(cls,byte:int)->int:
-		"""
-		Converte un numero di byte in KB
-		"""
-		return int(byte*cls.UNO_DIVISO_1024)
-	@classmethod
-	def byteToMegabyte(cls,byte:int)->int:
-		"""
-		Converte un numero di byte in MB
-		"""
-		return int(cls.byteToKilobyte(byte)*cls.UNO_DIVISO_1024)
-
-	@classmethod
-	def versionStrToInt(cls,testo:str)->int:
-		"""
-		Converte la stringa di una versione in intero.
-		NB: la versione andrebbe sempre trattata come una stringa.
-		"""
-		arr=testo.split(".")
-		testoPadded="".join([x.ljust(4,"0") for x in arr])
-		return cls.strToInt(testoPadded)
-
-	@staticmethod
-	def humanFormat(num: int) -> str:
-		"""
-		Formatta un numero in modo che sia più leggibile.
-		"""
-		magnitude=0
-		while abs(num)>=1000:
-			magnitude+=1
-			num/=1000.0
-		return '%.2f%s'%(num,['','K','M','G','T','P'][magnitude])
-	
-	@staticmethod
-	def decimalNumbersTruncate(value:float,decimals:int)->float:
-		"""
-		Rimuove la quantità di decimali voluta da un valore.
-		Il valore 1.234 se viene troncato a 2 decimali diventa 1.23
-		"""
-		factor=10**decimals
-		return int(value*factor)/factor
-	
-	@classmethod
-	def numberToWord(cls,numero:int)->str:
-		"""
-		Converte un numero in parola.
-		"""
-		return cls.NUMERI_CARDINALI[numero]
-	@classmethod
-	def wordToNumber(cls,parola:str)->int:
-		"""
-		Converte una parola in numero.
-		"""
-		return cls.NUMERI_ORDINALI[parola]

modulitiz_micro/ModuloPyinstaller.py

@@ -1,29 +0,0 @@
-import os
-import sys
-
-from modulitiz_micro.files.ModuloFiles import ModuloFiles
-
-
-class ModuloPyinstaller(object):
-	"""
-	Utility di gestione del modulo che permette di compilare sorgenti e interprete in un file eseguibile unico (exe)
-	"""
-	
-	@staticmethod
-	def isExecutableMode()->bool:
-		"""
-		Identifica se lo script viene eseguito da un eseguibile o meno.
-		"""
-		return getattr(sys, 'frozen', False)
-	
-	@classmethod
-	def cdProjectsDir(cls):
-		"""
-		Se questo metodo non viene chiamato da un eseguibile costruito con PyInstaller fa nulla,
-		altrimenti cambia la cartella corrente alla root dei progetti.
-		"""
-		if cls.isExecutableMode() is False:
-			return
-		pathExecutableDir=os.path.dirname(sys.executable)
-		originalPath=os.path.abspath(ModuloFiles.pathJoin(pathExecutableDir,"../"))
-		os.chdir(originalPath)

modulitiz_micro/ModuloStatistiche.py

@@ -1,31 +0,0 @@
-from modulitiz_micro.ModuloDate import ModuloDate
-from modulitiz_micro.ModuloNumeri import ModuloNumeri
-
-
-class ModuloStatistiche(object):
-	"""
-	Utility per la gestione delle statistiche.
-	"""
-	
-	@staticmethod
-	def calcolaProgresso(index:int, contaElementiElaborati:int, totElementi:int, secsInizio:int)->str:
-		"""
-		Calcola il tempo rimanente alla fine dell'elaborazione di un certo numero di elementi in base al trend attuale.
-		:param index: deve partire da 0
-		:param contaElementiElaborati: deve partire da 1
-		:param totElementi: numero totale di elementi
-		:param secsInizio: timestamp di inizio elaborazione
-		"""
-		secsFine=ModuloDate.getSecs()
-		percentuale=int((index*100) / totElementi)
-		
-		secondiTrascorsi=secsFine - secsInizio
-		elementiRimanenti=totElementi - index
-		secondiRimanenti=int((secondiTrascorsi / contaElementiElaborati) * elementiRimanenti)
-		tempoRimanente=ModuloDate.dateToString(ModuloDate.timestampUtcToDate(secondiRimanenti),ModuloDate.FORMATO_ORA)
-		
-		# se i numeri sono alti li conveto in un formato più leggibile
-		index=ModuloNumeri.humanFormat(index)
-		totElementi=ModuloNumeri.humanFormat(totElementi)
-		msg="Progresso: {:<5}/{}, percentuale: {:<3}%, tempo rimanente: {}".format(index, totElementi, percentuale, tempoRimanente)
-		return msg

modulitiz_micro/ModuloStringhe.py

@@ -1,180 +0,0 @@
-import locale
-import random
-import string
-
-from modulitiz_micro.ModuloDate import ModuloDate
-
-
-class ModuloStringhe(object):
-	"""
-	Utility di gestione delle stringhe.
-	"""
-	
-	CODIFICA_ASCII="ascii"
-	CODIFICA_LATIN1="latin_1"
-	CODIFICA_UTF8="utf-8"
-	
-	SEP=r"//||//"
-	
-	@classmethod
-	def setLocaleItalian(cls):
-		"""
-		Necessario per avere, ad esempio, il giorno della settimana nella lingua corretta.
-		"""
-		cls.setLocale("it_IT")
-	
-	@classmethod
-	def setLocale(cls,lang:str):
-		"""
-		Imposta la lingua predefinita.
-		"""
-		try:
-			cls.__setLocale(lang)
-		except locale.Error:
-			lang+=".utf8"
-			cls.__setLocale(lang)
-	
-	@staticmethod
-	def __setLocale(lang:str):
-		locale.setlocale(locale.LC_TIME, lang)
-	
-	@staticmethod
-	def isEmpty(val:str|None)->bool:
-		"""
-		Verifica se il valore passato in input è NULL o vuoto.
-		"""
-		if val is None:
-			return True
-		val=str(val)
-		return val==''
-	
-	@staticmethod
-	def contains(haystack:str,needle:str)->bool:
-		"""
-		Verifica se un testo è contenuto in un altro testo.
-		:param haystack: testo contenitore
-		:param needle: testo da cercare
-		"""
-		return haystack.find(needle)!=-1
-	
-	@staticmethod
-	def normalizzaEol(cont:str)->str:
-		"""
-		Converte i caratteri di fine riga secondo lo standard Unix (universale)
-		"""
-		cont=cont.replace("\r\n","\n")
-		cont=cont.replace("\r","\n")
-		return cont
-	
-	@staticmethod
-	def normalizzaTrattini(testo:str)->str:
-		"""
-		Tutti i caratteri assimilabili come un trattino vengono convertiti in trattini.
-		"""
-		#https://en.wikipedia.org/wiki/Dash#Common_dashes_and_Unicode_characters
-		testo=testo.replace(u'\u2012',"-")		#figure dash
-		testo=testo.replace(u'\u2013',"-")		#en dash
-		testo=testo.replace(u'\u2014',"-")		#em dash
-		testo=testo.replace(u'\u2015',"-")		#horizontal bar
-		#https://en.wikipedia.org/wiki/Hyphen#Unicode
-		testo=testo.replace(u'\u002D',"-")		#HYPHEN-MINUS
-		testo=testo.replace(u'\u2212',"-")		#MINUS SIGN
-		testo=testo.replace(u'\u00AD',"-")		#SOFT HYPHEN
-		testo=testo.replace(u'\u2010',"-")		#HYPHEN
-		testo=testo.replace(u'\u2011',"-")		#NON-BREAKING HYPHEN
-		testo=testo.replace(u'\u0584',"-")		#ARMENIAN HYPHEN
-		testo=testo.replace(u'\u1806',"-")		#MONGOLIAN SOFT HYPHEN
-		testo=testo.replace(u'\uFE63',"-")		#SMALL HYPHEN-MINUS
-		testo=testo.replace(u'\uFF0D',"-")		#FULLWIDTH HYPHEN-MINUS
-		testo=testo.replace(u'\u2043',"-")		#HYPHEN BULLET
-		return testo
-	
-	@staticmethod
-	def normalizzaCaratteriSpeciali(testo:str)->str:
-		"""
-		Normalizzazione altri caratteri speciali.
-		"""
-		testo=testo.replace(u'\u039b','&')		#GREEK CAPITAL LETTER LAMDA
-		return testo
-	
-	@classmethod
-	def aggiungiTimestamp(cls,nomefile:str)->str:
-		"""
-		Se il nome del file ha l'estensione aggiungo il timestamp prima dell'estensione
-		"""
-		timestamp=ModuloDate.dateToString(None,ModuloDate.FORMATO_DATA_ORA_NOSPAZI)
-		if not cls.contains(nomefile,"."):
-			return nomefile+"_"+timestamp
-		arr=nomefile.split(".")
-		nuovonome=".".join(arr[0:-1])+"_"+timestamp+"."+arr[-1]
-		return nuovonome
-	
-	@classmethod
-	def phoneNumberFormat(cls,stringa:str,sep:str):
-		"""
-		Formatta un numero di telefono rendendolo più facile da leggere.
-		"""
-		return cls.insertCharEveryN(stringa,sep,3)
-	
-	@staticmethod
-	def capitalizeEveryWord(text:str)->str:
-		"""
-		Converte in maiuscolo il primo carattere di ogni parola.
-		"""
-		arr=text.split(" ")
-		arrNew=[x.capitalize() for x in arr]
-		textNew=" ".join(arrNew)
-		return textNew
-	
-	@staticmethod
-	def splitColonne(text:str,sep:str)->list:
-		"""
-		Divide una stringa in colonne, ad ogni colonna vengono tolti gli spazi all'inizio e alla fine.
-		"""
-		colonne=text.split(sep)
-		colonne=[x.strip() for x in colonne]
-		return colonne
-	
-	@staticmethod
-	def randomString(useLower:bool,useUpper:bool,useDigits:bool,length:int)->str:
-		"""
-		Crea una stringa di caratteri e/o numeri di lunghezza configurabile.
-		"""
-		chars=""
-		if useLower:
-			chars+=string.ascii_lowercase
-		if useUpper:
-			chars+=string.ascii_uppercase
-		if useDigits:
-			chars+=string.digits
-		return ''.join(random.choices(chars, k=length))
-	
-	@staticmethod
-	def insertCharEveryN(stringa:str,sep:str,everyN:int)->str:
-		"""
-		Inserisce un carattere o un testo ogni N caratteri di un altro testo.
-		"""
-		return sep.join(stringa[i:i+everyN] for i in range(0, len(stringa), everyN))
-	
-	@staticmethod
-	def trovaCodificaCorretta(textBytes:bytes,expectedText:str)->list:
-		"""
-		Questa funzione non ti puo' dire se la codifica e' corretta,
-		devi verificarlo tu a occhio perche' piu' codifiche possono andare bene.
-		"""
-		# questa variabile la lascio qui dentro perche' e' pesante
-		codecs=('ascii','big5','big5hkscs','cp037','cp424','cp437','cp500','cp737','cp775','cp850','cp852','cp855','cp856','cp857','cp860','cp861','cp862','cp863','cp864','cp865','cp866',
-				'cp869','cp874','cp875','cp932','cp949','cp950','cp1006','cp1026','cp1140','cp1250','cp1251','cp1252','cp1253','cp1254','cp1255','cp1256','cp1257','cp1258','euc_jp',
-				'euc_jis_2004','euc_jisx0213','euc_kr','gb2312','gbk','gb18030','hz','iso2022_jp','iso2022_jp_1','iso2022_jp_2','iso2022_jp_2004','iso2022_jp_3','iso2022_jp_ext','iso2022_kr',
-				'latin_1','iso8859_2','iso8859_3','iso8859_4','iso8859_5','iso8859_6','iso8859_7','iso8859_8','iso8859_9','iso8859_10','iso8859_13','iso8859_14','iso8859_15','johab','koi8_r',
-				'koi8_u','mac_cyrillic','mac_greek','mac_iceland','mac_latin2','mac_roman','mac_turkish','ptcp154','shift_jis','shift_jis_2004','shift_jisx0213','utf_16','utf_16_be','utf_16_le',
-				'utf_7','utf_8','utf_8_sig')
-		results=[]
-		for codec in codecs:
-			try:
-				testo=textBytes.decode(codec)
-				if testo==expectedText:
-					results.append(codec)
-			except UnicodeDecodeError:
-				pass
-		return results

modulitiz_micro/android/ModuloAndroid.py

@@ -1,18 +0,0 @@
-from modulitiz_micro.sistema.ModuloSystem import ModuloSystem
-
-
-class ModuloAndroid(object):
-	@staticmethod
-	def isAaptInstalled()->bool:
-		return ModuloSystem.isAptPackageInstalled("aapt")
-	@staticmethod
-	def isAdbInstalled()->bool:
-		return ModuloSystem.isAptPackageInstalled("adb")
-	
-	@staticmethod
-	def getApkVersionName(nomefile:str)->str|None:
-		if not ModuloAndroid.isAaptInstalled():
-			return None
-		cmd=rf'''aapt dump badging {nomefile} | grep "versionName" | sed -e "s/.*versionName='//" -e "s/' .*//"'''
-		output=ModuloSystem.systemCallReturnOutput(cmd,None)
-		return output

modulitiz_micro/android/ModuloAndroidAdb.py

@@ -1,48 +0,0 @@
-from modulitiz_micro.ModuloStringhe import ModuloStringhe
-from modulitiz_micro.sistema.ModuloSystem import ModuloSystem
-
-
-class ModuloAndroidAdb(object):
-	"""
-	deviceId puo' essere l'identificativo:
-	- del dispositivo di 16 caratteri esadecimale
-	- della porta usb, del prodotto, del modello, ... (vedi il comando 'adb devices -l')
-	il transport_id non e' supportato
-	"""
-	
-	def __init__(self,deviceId:str):
-		self.deviceId=deviceId
-	
-	def isDeviceConnected(self)->bool:
-		cmd=r'adb -s "%s" get-state'%(self.deviceId,)
-		return self.__retrieveLastLineOfOutput(cmd)=='device'
-	
-	def isDeviceUnlocked(self)->bool:
-		cmd=r'adb -s "%s" shell dumpsys window | grep mDreamingLockscreen'%(self.deviceId,)
-		output=ModuloSystem.systemCallReturnOutput(cmd,None).strip()
-		valori=[x.split("=")[1] for x in output.split(" ")]
-		for valore in valori:
-			if valore=="true":
-				return False
-		return True
-	
-	def reboot(self)->bool:
-		cmd=r'adb -s "%s" reboot'%(self.deviceId,)
-		return self.__retrieveLastLineOfOutput(cmd)==''
-	def shutdown(self)->bool:
-		cmd=r'adb -s "%s" reboot -p'%(self.deviceId,)
-		return self.__retrieveLastLineOfOutput(cmd)=='Done'
-	
-	@classmethod
-	def closeServer(cls) -> bool:
-		cmd="adb kill-server"
-		return cls.__retrieveOutput(cmd)==''
-	
-	@staticmethod
-	def __retrieveOutput(cmd)->str:
-		return ModuloStringhe.normalizzaEol(ModuloSystem.systemCallReturnOutput(cmd,None)).strip()
-	@classmethod
-	def __retrieveLastLineOfOutput(cls,cmd)->str:
-		output=cls.__retrieveOutput(cmd)
-		righe=output.split("\n")
-		return righe[-1]

modulitiz_micro/android/ModuloAndroidSim.py

@@ -1,130 +0,0 @@
-import time
-
-from modulitiz_micro.ModuloDate import ModuloDate
-from modulitiz_micro.ModuloListe import ModuloListe
-from modulitiz_micro.ModuloNumeri import ModuloNumeri
-from modulitiz_micro.ModuloStringhe import ModuloStringhe
-from modulitiz_micro.sistema.ModuloSystem import ModuloSystem
-
-
-class ModuloAndroidSim(object):
-	"""
-	CREATE TABLE sms (
-		_id INTEGER PRIMARY KEY
-		thread_id INTEGER
-		address TEXT
-		person INTEGER
-		date INTEGER
-		date_sent INTEGER DEFAULT 0
-		protocol INTEGER
-		read INTEGER DEFAULT 0
-		status INTEGER DEFAULT -1
-		type INTEGER
-		reply_path_present INTEGER
-		subject TEXT
-		body TEXT
-		service_center TEXT
-		locked INTEGER DEFAULT 0
-		sub_id INTEGER DEFAULT INVALID_SUBSCRIPTION_ID
-		error_code INTEGER DEFAULT NO_ERROR_CODE
-		creator TEXT
-		seen INTEGER DEFAULT 0
-	);
-	"""
-	
-	def __init__(self,deviceId:str):
-		self.deviceId=deviceId
-		
-		self.__SEP_WITH_DELIM=(r''' "'"\"%s"\"'" '''%(ModuloStringhe.SEP.replace(r"|",r"\|"),)).strip()
-	
-	def hasDeviceCellSignal(self)->bool:
-		cmd=r'adb -s "%s" shell "dumpsys telephony.registry | grep mServiceState"'%(self.deviceId,)
-		output=ModuloStringhe.normalizzaEol(ModuloSystem.systemCallReturnOutput(cmd,None)).strip()
-		ind=output.find("=")
-		if ind==-1:
-			return False
-		serviceState=output[ind+1]
-		if not ModuloNumeri.isInt(serviceState):
-			return False
-		return int(serviceState)==0
-	
-	# operazioni di lettura
-	def smsRead(self,onlyUnread:bool)->list:
-		"""
-		Tutti i comandi che fanno operazioni di SELECT, UPDATE o DELETE richiedono il ROOT
-		"""
-		sql=self.__smsQuery(onlyUnread,False)
-		output=self.__querySmsDb(sql)
-		return ModuloListe.eliminaElementiVuoti(output.split("|"+ModuloStringhe.SEP+"\n"))
-	
-	def smsReadUntilNew(self,checkEverySecs:int|float,timeoutMin:int|float) -> list:
-		"""
-		Aspetta l'arrivo di un nuovo messaggio.
-		Questo metodo NON è asincrono.
-		"""
-		timeoutSecs=timeoutMin*60
-		tsStart=ModuloDate.getSecs()
-		results=[]
-		while ModuloListe.isEmpty(results) and (ModuloDate.getSecs()-tsStart)<timeoutSecs:
-			time.sleep(checkEverySecs)
-			results=self.smsRead(True)
-		return results
-	
-	def smsReadCount(self,onlyUnread: bool) -> int:
-		"""
-		Tutti i comandi che fanno operazioni di SELECT, UPDATE o DELETE richiedono il ROOT
-		"""
-		sql=self.__smsQuery(onlyUnread,True)
-		output=self.__querySmsDb(sql)
-		return int(output)
-	
-	def __smsQuery(self,onlyUnread:bool,isCount:bool)->str:
-		sqlSelect="COUNT(*)" if isCount else "*,%s AS sep"%(self.__SEP_WITH_DELIM,)
-		sql="SELECT %s FROM sms WHERE 1=1 %s;"%(sqlSelect,("AND read=0" if onlyUnread else ""),)
-		return sql
-	
-	# operazioni di modifica / cancellazione
-	def smsDelete(self,idSms:int)->str:
-		"""
-		Tutti i comandi che fanno operazioni di SELECT, UPDATE o DELETE richiedono il ROOT
-		"""
-		sql="DELETE FROM sms WHERE _id=%d;"%(idSms,)
-		return self.__querySmsDb(sql)
-	def smsUpdateAsRed(self,idSms:int)->str:
-		"""
-		Tutti i comandi che fanno operazioni di SELECT, UPDATE o DELETE richiedono il ROOT
-		"""
-		sql="UPDATE sms SET read=1 WHERE _id=%d AND read=0;"%(idSms,)
-		return self.__querySmsDb(sql)
-	def smsUpdateManyAsRed(self,idsSms:list[int])->str|None:
-		"""
-		Tutti i comandi che fanno operazioni di SELECT, UPDATE o DELETE richiedono il ROOT
-		"""
-		if not idsSms:
-			return None
-		idsSmsStr=",".join(str(x) for x in idsSms)
-		sql="UPDATE sms SET read=1 WHERE _id IN(%s) AND read=0;"%(idsSmsStr,)
-		return self.__querySmsDb(sql)
-		
-	def __querySmsDb(self,sqlQuery:str)->str:
-		"""
-		Richiede il ROOT sul device
-		"""
-		cmd=r'''adb -s "%s" shell "su -c 'sqlite3 "/data/data/com.android.providers.telephony/databases/mmssms.db" \"%s\"'" '''%(self.deviceId,sqlQuery)
-		output=ModuloSystem.systemCallReturnOutput(cmd,None).strip()
-		output=ModuloStringhe.normalizzaEol(output)
-		return output
-	
-	def smsSend(self,unlockPin:int,numeroDest:str,msg:str)->str:
-		msg=msg.replace(" ",r"\ ")
-		# premo invio prima di inserire il pin, in questo modo forzo il focus sull'input text
-		cmd=r"""adb -s "%s" shell "input keyevent KEYCODE_POWER && sleep 1 && input keyevent KEYCODE_ENTER && sleep 0.5"
-adb -s "%s" shell "input text \"%d\" && sleep 0.5 && input keyevent KEYCODE_ENTER"
-adb -s "%s" shell am start -a android.intent.action.SENDTO -d sms:"%s" --es sms_body "%s" --ez exit_on_sent true
-adb -s "%s" shell "sleep 2 && input keyevent 61 && sleep 0.5 && input keyevent KEYCODE_ENTER && sleep 0.5 && am force-stop com.android.mms && input keyevent KEYCODE_POWER && echo \"FINE\""
-"""%(self.deviceId,
-	self.deviceId,unlockPin,
-	self.deviceId,numeroDest,msg,
-	self.deviceId)
-		output=ModuloStringhe.normalizzaEol(ModuloSystem.systemCallReturnOutput(cmd,None)).strip()
-		return output

modulitiz_micro/android/beans/SmsBean.py

@@ -1,12 +0,0 @@
-from modulitiz_micro.ModuloDate import ModuloDate
-from modulitiz_micro.android.enums.AndroidSmsTypeEnum import AndroidSmsTypeEnum
-
-
-class SmsBean(object):
-	def __init__(self,arr:list[str]):
-		self.id=int(arr[0])
-		self.numCell=arr[2]
-		self.data=ModuloDate.timestampToDate(int(arr[4])*0.001)
-		self.dataInvio=ModuloDate.timestampToDate(int(arr[5])*0.001)
-		self.type=AndroidSmsTypeEnum(int(arr[9])).name.lower()
-		self.body=arr[12]

modulitiz_micro/android/enums/AndroidSmsTypeEnum.py

@@ -1,17 +0,0 @@
-from enum import IntEnum
-from enum import auto
-from enum import unique
-
-
-@unique
-class AndroidSmsTypeEnum(IntEnum):
-	"""
-	Tipi di sms/mms
-	"""
-	ALL=0
-	RECEIVED=auto()
-	SENT=auto()
-	DRAFT=auto()
-	OUTBOX=auto()
-	FAILED_OUTGOING=auto()
-	QUEUED=auto()

modulitiz_micro/eccezioni/EccezioneBase.py

@@ -1,7 +0,0 @@
-from modulitiz_micro.eccezioni.EccezioneRuntime import EccezioneRuntime
-
-
-class EccezioneBase(EccezioneRuntime):
-	
-	def __init__(self,*args,**kwargs):
-		super().__init__(*args,**kwargs)

modulitiz_micro/eccezioni/EccezioneRuntime.py

@@ -1,7 +0,0 @@
-class EccezioneRuntime(RuntimeError):
-	
-	def __init__(self,*args,**kwargs):
-		super().__init__(*args)
-	
-	def getMessage(self)->str:
-		return " ".join(self.args)

modulitiz_micro/eccezioni/EccezioneSoNonSupportato.py

@@ -1,7 +0,0 @@
-from modulitiz_micro.eccezioni.EccezioneBase import EccezioneBase
-
-
-class EccezioneSoNonSupportato(EccezioneBase):
-	
-	def __init__(self,*args,**kwargs):
-		super().__init__(*args,**kwargs)