modulitiz-micro 2.26.0__py311-none-any.whl

modulitiz_micro/ModuloNumeri.py

@@ -0,0 +1,130 @@
+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:
+			ris=int(valore)
+			return ris
+		except ValueError:
+			return None
+
+	@staticmethod
+	def intToBool(valore:int)->bool:
+		"""
+		Converte un numero intero in valore booleano (o binario).
+		"""
+		if int(valore)==1:
+			return True
+		return False
+
+	@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

@@ -0,0 +1,29 @@
+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/ModuloSeriale.py

@@ -0,0 +1,61 @@
+import serial
+
+from modulitiz_micro.sistema.ModuloSystem import ModuloSystem
+
+
+class ModuloSeriale(object):
+	"""
+	Utility di gestione dela connessione seriale RS232
+	"""
+	
+	COM_PORTS=[]
+	
+	def __init__(self):
+		self.connessione=None
+	
+	@classmethod
+	def populate(cls):
+		"""
+		Popola le variabili di classe.
+		"""
+		if ModuloSystem.isWindows():
+			COM_PORTS=cls.__generaElencoPorte("COM",1)
+		else:
+			COM_PORTS=cls.__generaElencoPorte("/dev/tty",0)
+			COM_PORTS.extend(cls.__generaElencoPorte("/dev/ttyS",0))
+			COM_PORTS.extend(cls.__generaElencoPorte("/dev/ttyUSB",0))
+		cls.COM_PORTS=COM_PORTS
+	
+	def apriPrimaPortaDisponibile(self):
+		"""
+		Prova ad aprire la prima porta disponibile che trova.
+		"""
+		for porta in self.COM_PORTS:
+			try:
+				connessioneSeriale=serial.Serial(port=porta, baudrate=9600, rtscts=True, dsrdtr=True, exclusive=True)
+				connessioneSeriale.dtr=True
+				connessioneSeriale.dtr=False
+				self.connessione=connessioneSeriale
+				return
+			except (OSError,serial.SerialException):
+				pass
+	
+	def isOpen(self)->bool:
+		"""
+		Controlla se la connessione alla porta è aperta.
+		"""
+		return self.connessione is not None and self.connessione.isOpen()
+	
+	def close(self):
+		"""
+		Chiude la connessione alla porta.
+		"""
+		if not self.isOpen():
+			return
+		self.connessione.close()
+		self.connessione=None
+
+	@staticmethod
+	def __generaElencoPorte(prefisso:str,inizio:int)->list:
+		return [prefisso+str(i) for i in range(inizio,16)]
+	

modulitiz_micro/ModuloStatistiche.py

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

@@ -0,0 +1,180 @@
+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)->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/ModuloTarghe.py

@@ -0,0 +1,46 @@
+from modulitiz_micro.ModuloNumeri import ModuloNumeri
+from modulitiz_micro.ModuloStringhe import ModuloStringhe
+from modulitiz_micro.gestionedom.GestioneDom import GestioneDom
+from modulitiz_micro.rete.http.ModuloHttp import ModuloHttp
+
+
+class ModuloTarghe(object):
+	"""
+	Utility di gestione delle targhe delle auto.
+	"""
+	
+	URL="https://autokar.it/targhe"
+	
+	@classmethod
+	def getAnno(cls,targa:str)->int|None:
+		"""
+		Cerca la targa e restituisce approssimativamente l'anno di immatricolazione.
+		:param targa: la targa dell'auto da cercare.
+		"""
+		http=ModuloHttp(cls.URL,None,False)
+		responseBody=http.doGet(3,True).responseBody.decode(ModuloStringhe.CODIFICA_LATIN1)
+		gestioneDom=GestioneDom(None,responseBody)
+		elementi=gestioneDom.selector(".entry-content p")
+		targaIniziale=targa[:2]
+		for elem in elementi:
+			anno=cls.__getAnno(elem,targaIniziale)
+			if anno is not None:
+				return anno
+	
+	@classmethod
+	def __getAnno(cls,tag,targaIniziale:str)->int|None:
+		elementi=tag.contents
+		if len(elementi)!=2:
+			return None
+		try:
+			testo=elementi[0].contents[0]
+		except AttributeError:
+			return None
+		if targaIniziale!=testo:
+			return None
+		annoStr=elementi[1].strip()
+		anno=ModuloNumeri.strToInt(annoStr)
+		if anno is not None:
+			return anno
+		anno=int(annoStr.split(" ")[0])
+		return anno

modulitiz_micro/android/ModuloAndroid.py

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

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

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

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