modulitiz-micro 2.26.0__py311-none-any.whl

modulitiz_micro/multithreading/ModuloThread.py

@@ -0,0 +1,26 @@
+import threading
+
+from modulitiz_micro.files.ModuloLogging import ModuloLogging
+from modulitiz_micro.multithreading.ModuloThreadLogger import ModuloThreadLogger
+from modulitiz_micro.multithreading.ModuloThreadWithCallbackError import ModuloThreadWithCallbackError
+
+
+class ModuloThread(object):
+	@staticmethod
+	def startDaemon(logger:ModuloLogging,funzione,args:tuple)->ModuloThreadLogger:
+		d=ModuloThreadLogger(logger,name='th__'+funzione.__name__,target=funzione,args=args,daemon=True)
+		d.start()
+		return d
+	@staticmethod
+	def startDaemonWithCallbackError(callbackError,funzione,args:tuple)->ModuloThreadWithCallbackError:
+		d=ModuloThreadWithCallbackError(callbackError,name='th__'+funzione.__name__,target=funzione,args=args,daemon=True)
+		d.start()
+		return d
+	
+	@staticmethod
+	def numeroThreadsAttivi()->int:
+		"""
+		Non e' incluso il main, ovviamente.
+		Se usi pydev debugger devi sottrarre altri 2 o 3 threads
+		"""
+		return threading.active_count()-1

modulitiz_micro/multithreading/ModuloThreadLogger.py

@@ -0,0 +1,8 @@
+from modulitiz_micro.files.ModuloLogging import ModuloLogging
+from modulitiz_micro.multithreading.ModuloThreadWithCallbackError import ModuloThreadWithCallbackError
+
+
+class ModuloThreadLogger(ModuloThreadWithCallbackError):
+	
+	def __init__(self,logger:ModuloLogging,**kwargs):
+		super().__init__(lambda ex:logger.exception('Eccezione nel thread:'),**kwargs)

modulitiz_micro/multithreading/ModuloThreadWithCallbackError.py

@@ -0,0 +1,25 @@
+import threading
+
+
+class ModuloThreadWithCallbackError(threading.Thread):
+	"""
+	This class should always be used in preference to threading.Thread.
+
+	The interface provided by this class is identical to that of threading.Thread,
+	however, if an exception occurs in the thread the callback function is called,
+	rather than printed to stderr.
+
+	This is important in daemon style applications where stderr is redirected to /dev/null.
+	"""
+	
+	def __init__(self,callbackError,**kwargs):
+		super().__init__(**kwargs)
+		self.callbackError=callbackError
+		self._realRun=self.run
+		self.run=self.__wrapRun
+	
+	def __wrapRun(self):
+		try:
+			self._realRun()
+		except Exception as ex:
+			self.callbackError(ex)

modulitiz_micro/nlp/ModuloNlp.py

@@ -0,0 +1,36 @@
+class ModuloNlp(object):
+	
+	@staticmethod
+	def giornoRelativoToParola(giornoRel:int)->str|None:
+		match giornoRel:
+			case -1: return "ieri"
+			case 0: return "oggi"
+			case 1: return "domani"
+			case 2: return "dopodomani"
+			case _: return None
+	
+	@staticmethod
+	def giornoRelativoToNum(giornoRel:str)->int|None:
+		match giornoRel:
+			case "ieri": return -1
+			case "oggi": return 0
+			case "domani": return 1
+			case "dopodomani": return 2
+			case _: return None
+	
+	@staticmethod
+	def verboEssere(isPassato:bool)->str:
+		if isPassato:
+			return "era"
+		return "è"
+	
+	@staticmethod
+	def articolo(isDeterminativo:bool,isMaschile:bool)->str:
+		if isDeterminativo:
+			if isMaschile:
+				return "il"
+			return "la"
+		if isMaschile:
+			return "un"
+		return "una"
+	

modulitiz_micro/nlp/ModuloNlpDateAndTime.py

@@ -0,0 +1,59 @@
+from modulitiz_micro.ModuloDate import ModuloDate
+from modulitiz_micro.ModuloNumeri import ModuloNumeri
+from modulitiz_micro.nlp.ModuloNlp import ModuloNlp
+
+
+class ModuloNlpDateAndTime(object):
+	@staticmethod
+	def dateToString(data,anno:str)->str:
+		dataStr=ModuloDate.dateToString(data,"%w %A %d %B")
+		numGiornoSett,giornoSett,giorno,mese=dataStr.split(" ")
+		# sistemo grammaticalmente gli articoli, verbi, ...
+		numGiornoSett=int(numGiornoSett)
+		giorno=int(giorno)
+		articoloGiornoMese="il "
+		giornoParola=giorno
+		if giorno in (1,8,11):
+			articoloGiornoMese="l'"
+			giornoParola=ModuloNumeri.numberToWord(giorno)
+		verbo=ModuloNlp.verboEssere(data<ModuloDate.now())
+		articoloGiornoSett=ModuloNlp.articolo(False,numGiornoSett!=0)
+		output=f"{articoloGiornoMese}{giornoParola} {mese}{anno} {verbo} {articoloGiornoSett} {giornoSett}"
+		output=output.lower()
+		return output
+	
+	@classmethod
+	def minutesToTimeRelative(cls,minutes:int,arrotonda:bool)->str:
+		prefixTempo=""
+		minutes,hoursDiff,hoursWord=cls.__minutesToHours(minutes)
+		# minuti
+		minutesWord=minutes
+		if minutes==1:
+			minutesWord="un"
+		elif 10<minutes<60:
+			if arrotonda is True and minutes%10!=0:
+				prefixTempo=" circa"
+				minutes=round(minutes,-1)
+			minutesWord=minutes
+		output="Fino a"+prefixTempo
+		if hoursDiff>0:
+			output+=" %s or%s"%(hoursWord,("a" if hoursDiff==1 else "e"))
+			if minutes>0:
+				output+=" e"
+		if minutes>0:
+			output+=" %s minut%s"%(minutesWord,("o" if minutes==1 else "i"))
+		return output
+	
+	@staticmethod
+	def __minutesToHours(minutes:int)->tuple:
+		hoursDiff=0
+		hoursWord=""
+		if minutes<60:
+			return minutes,hoursDiff,hoursWord
+		hoursDiff=minutes//60
+		minutes=minutes%60
+		if hoursDiff==1:
+			hoursWord="un"
+		else:
+			hoursWord=hoursDiff
+		return minutes,hoursDiff,hoursWord

modulitiz_micro/rete/ModuloEmail.py

@@ -0,0 +1,69 @@
+import smtplib
+
+from modulitiz_micro.ModuloDate import ModuloDate
+from modulitiz_micro.ModuloListe import ModuloListe
+from modulitiz_micro.ModuloStringhe import ModuloStringhe
+
+
+class ModuloEmail(object):
+	SERVER_GOOGLE_INVIO=('smtp.gmail.com',smtplib.SMTP_SSL_PORT)
+	SERVER_VIRGILIO_INVIO=('out.virgilio.it',smtplib.SMTP_SSL_PORT)
+	
+	def __init__(self,credenzialiServer:tuple,isDebug:bool=False):
+		self.credenzialiServer=credenzialiServer
+		self.isDebug=isDebug
+		self.connEmail=None
+		self.utente=None
+		self.isLogged=False
+	
+	def login(self,utente:str|None=None,password:str|None=None):
+		if self.isLogged:
+			return
+		self.connEmail=smtplib.SMTP_SSL(*self.credenzialiServer)
+		if self.isDebug:
+			self.connEmail.set_debuglevel(1)
+		# se serve setto l'autenticazione
+		if utente is not None and password is not None:
+			self.utente=utente
+			self.connEmail.login(utente,password)
+		self.isLogged=True
+	
+	def inviaEmail(self, mittente:str|None,destinatari, oggetto:str, messaggio:str,
+			isHtml:bool, dataInvio=ModuloDate.now(), cc=None, ccn=None)->dict:
+		# controllo i parametri
+		dataInvio=ModuloDate.dateToString(dataInvio)
+		if isinstance(destinatari, str):
+			destinatari=[destinatari]
+		if mittente is None:
+			mittente=self.utente
+		domain=self.utente.split("@")[-1]
+		messageId=f"{ModuloDate.getSecs()}@{domain}"
+		# creo il messaggio
+		message=f"""Date: {dataInvio}
+From: {mittente}
+Subject: {oggetto}
+To: {", ".join(destinatari)}
+Message-ID: <{messageId}>
+"""
+		if not ModuloListe.isEmpty(cc):
+			message+=("Cc: "+", ".join(cc))+"\n"
+		if not ModuloListe.isEmpty(ccn):
+			message+=("Bcc: "+", ".join(ccn))+"\n"
+		message+="Content-Type: text/html;\n"
+		# converto il messaggio in formato html
+		if not isHtml:
+			messaggio=ModuloStringhe.normalizzaEol(messaggio).replace("\n","<br/>\n")
+		messaggio=messaggio.encode(ModuloStringhe.CODIFICA_ASCII,"xmlcharrefreplace").decode(ModuloStringhe.CODIFICA_UTF8)
+		message+="\n"+messaggio
+		# invio la mail
+		try:
+			return self.connEmail.sendmail(mittente,destinatari,message)
+		except smtplib.SMTPServerDisconnected as ex:
+			return {"":str(ex)}
+	
+	def close(self):
+		if self.connEmail is None:
+			return
+		self.connEmail.quit()
+		self.connEmail=None
+		self.isLogged=False

modulitiz_micro/rete/ModuloNetworking.py

@@ -0,0 +1,64 @@
+import os
+import socket
+from contextlib import closing
+from uuid import getnode
+
+from _socket import gaierror
+
+from modulitiz_micro.ModuloListe import ModuloListe
+from modulitiz_micro.ModuloStringhe import ModuloStringhe
+from modulitiz_micro.eccezioni.EccezioneRuntime import EccezioneRuntime
+from modulitiz_micro.sistema.ModuloSystem import ModuloSystem
+
+
+class ModuloNetworking(object):
+	@staticmethod
+	def getMacAddress()->str:
+		mac=("%012X" % getnode())
+		return mac
+
+	@staticmethod
+	def getIp()->str|None:
+		sockObj = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+		sockObj.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+		# doesn't even have to be reachable
+		try:
+			sockObj.connect(('255.255.255.255', 1))
+			indirizzoIp = sockObj.getsockname()[0]
+		except gaierror:
+			indirizzoIp = None
+		finally:
+			sockObj.close()
+		return indirizzoIp
+
+	@staticmethod
+	def isHttpPortOpen(host:str|None,port:int)->bool:
+		# controllo host
+		if host is None:
+			host="127.0.0.1"
+		# controllo porta
+		with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as sock:
+			if sock.connect_ex((host, port)) == 0:
+				return True
+		return False
+
+	@staticmethod
+	def checkPing(indirizzoIp:str)->bool:
+		# costruisco il comando a seconda del sistema operativo
+		comando="ping "
+		if ModuloSystem.isWindows():
+			comando+="-n"
+		elif os.name=='posix':
+			comando+="-c"
+		else:
+			raise EccezioneRuntime("Tipologia del sistema operativo non riconosciuta: "+os.name)
+		comando+=" 1 " + indirizzoIp
+		# eseguo il comando
+		outputComando=ModuloStringhe.normalizzaEol(ModuloSystem.systemCallReturnOutput(comando,None))
+		righe=outputComando.split("\n")
+		righe=ModuloListe.eliminaElementiVuoti(righe)
+		for riga in righe:
+			if ModuloStringhe.contains(riga, "%"):
+				numPacchettiPersi=int(riga.split("=")[1].split("(")[0].strip())
+				return numPacchettiPersi==0
+		return False

modulitiz_micro/rete/ModuloOpenVpn.py

@@ -0,0 +1,15 @@
+from modulitiz_micro.sistema.ModuloSystem import ModuloSystem
+
+
+class ModuloOpenVpn(object):
+	def __init__(self,percorsoOpenVpn:str):
+		self.__percorsoOpenVpn=percorsoOpenVpn
+	
+	def startVpn(self,isOpenVpnAlreadyRunning:bool,filenameOvpn:str):
+		"""
+		Send a command to start vpn to a new or already running instance of the GUI.
+		https://community.openvpn.net/openvpn/wiki/OpenVPN-GUI-New#gui-help
+		"""
+		subCmd="--command connect" if isOpenVpnAlreadyRunning else "--connect"
+		cmd=r'start "" "{}" {} {}.ovpn'.format(self.__percorsoOpenVpn,subCmd,filenameOvpn)
+		ModuloSystem.systemCallWaitAndClose(cmd,False)

modulitiz_micro/rete/http/ModuloHttp.py

@@ -0,0 +1,114 @@
+import gzip
+import logging
+import ssl
+import urllib
+from urllib.parse import urlencode
+from urllib.request import Request
+
+import brotli
+
+from modulitiz_micro.ModuloBase64 import ModuloBase64
+from modulitiz_micro.ModuloStringhe import ModuloStringhe
+from modulitiz_micro.eccezioni.EccezioneRuntime import EccezioneRuntime
+from modulitiz_micro.files.ModuloLogging import ModuloLogging
+from modulitiz_micro.rete.http.ModuloHttpConnectionSafe import ModuloHttpConnectionSafe
+from modulitiz_micro.rete.http.beans.HttpResponseBean import HttpResponseBean
+from modulitiz_micro.rete.http.decorators.catchAndRaiseHttpExceptions import catchAndRaiseHttpExceptions
+
+
+class ModuloHttp(object):
+	"""
+	Utility per gestione richieste di rete secondo il protocollo HTTP.
+	"""
+	
+	UA_ANDROID="Mozilla/5.0 (Linux; Android 12.0; SM-G900P Build/LRX21T) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.87 Mobile Safari/537.36"
+	
+	UA_MACOS_CHROME="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36"
+	UA_WINDOWS_CHROME="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36"
+	UA_WINDOWS_FIREFOX="Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:86.0) Gecko/20100101 Firefox/86.0"
+	
+	UAS=[UA_MACOS_CHROME,UA_WINDOWS_CHROME,UA_WINDOWS_FIREFOX]
+	
+	URL_CERCA_GOOGLE="https://www.google.it/search?q="
+	URLS_GET_IP=('https://ipecho.net/plain','https://ipinfo.io/ip','https://api.ipify.org')
+	
+	REGEX_INDIRIZZO_IP=r"\b(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\b"
+	
+	STATUS_OK=200
+	STATUS_OK_PARTIAL_CONTENT=206
+	
+	
+	def __init__(self,url:str,logger:ModuloLogging|None,useProxy:bool=False):
+		logging.getLogger("urllib3").propagate=False
+		
+		self.__requestObj=Request(url)
+		self.__logger=logger
+		
+		self.setUserAgent(self.UA_WINDOWS_FIREFOX)
+		self.addHeader('Accept-Encoding','gzip, deflate, br')		# questo serve per ridurre la dimensione della risposta
+		if useProxy is True:
+			self.addHeader('Origin','localhost')
+		self.connectionSafe=ModuloHttpConnectionSafe(self.__logger)
+		self.postData=None
+	
+	def doGet(self,retries:int,ignoreCerts:bool=False)->HttpResponseBean:
+		"""
+		Esegue una richiesta di tipo GET
+		"""
+		if retries==0:
+			return self.__getOrPost(True,ignoreCerts)
+		return self.connectionSafe.run(retries,0,self.__getOrPost,True,ignoreCerts)
+	
+	def doPost(self, postData:dict, retries:int,ignoreCerts:bool=False)->HttpResponseBean:
+		"""
+		Esegue una richiesta di tipo POST
+		"""
+		self.postData=postData
+		if retries==0:
+			return self.__getOrPost(False,ignoreCerts)
+		return self.connectionSafe.run(retries,0,self.__getOrPost,False,ignoreCerts)
+	
+	@catchAndRaiseHttpExceptions
+	def __getOrPost(self, isGet:bool,ignoreCerts:bool)->HttpResponseBean:
+		if not isGet:
+			postData=urlencode(self.postData).encode()
+			self.__requestObj.data=postData
+		# ignoro certificati
+		ctx=None
+		if ignoreCerts:
+			ctx=ssl.create_default_context()
+			ctx.check_hostname=False
+			ctx.verify_mode=ssl.CERT_NONE
+		with urllib.request.urlopen(self.__requestObj,context=ctx) as response:
+			responseBody=response.read()
+			responseHeaders=response.info()
+			status=response.status
+		# se il server manda il contenuto in formato compresso lo decomprimo
+		contentEncoding=responseHeaders.get('Content-Encoding')
+		if contentEncoding=="gzip":
+			responseBody=gzip.decompress(responseBody)
+		elif contentEncoding=="br":
+			responseBody=brotli.decompress(responseBody)
+		elif contentEncoding is not None and contentEncoding!= "deflate":
+			raise EccezioneRuntime("Codifica '"+contentEncoding+"' non gestita.")
+		return HttpResponseBean(status,responseBody,responseHeaders)
+	
+	# opzioni aggiuntive
+	def addHeader(self,nome:str,valore):
+		if ModuloStringhe.isEmpty(valore):
+			return
+		self.__requestObj.add_header(nome,valore)
+	
+	def setUserAgent(self,userAgent:str=None):
+		if ModuloStringhe.isEmpty(userAgent):
+			userAgent=self.UA_ANDROID
+		else:
+			userAgent=userAgent.strip()
+		self.addHeader('User-Agent',userAgent)
+	
+	def setDownloadRange(self,inizio:int,fine:int):
+		self.addHeader('Range',"bytes="+str(inizio)+"-"+str(fine))
+	
+	def setAuthenticationBasic(self,username:str,password:str):
+		authStr=ModuloBase64.codificaStr('%s:%s' % (username, password))
+		self.addHeader('Authorization',"Basic "+authStr)

modulitiz_micro/rete/http/ModuloHttpConnectionSafe.py

@@ -0,0 +1,91 @@
+import socket
+import time
+from urllib.error import URLError
+
+import requests
+
+from modulitiz_micro.ModuloFunzioni import ModuloFunzioni
+from modulitiz_micro.ModuloStringhe import ModuloStringhe
+from modulitiz_micro.eccezioni.http.EccezioneHttpGeneric import EccezioneHttpGeneric
+from modulitiz_micro.files.ModuloLogging import ModuloLogging
+
+
+class ModuloHttpConnectionSafe(object):
+	"""
+	Utility che serve per gestire eventuali errori di rete e riprova a fare la richiesta in caso di errore
+	"""
+	
+	def __init__(self,logger: ModuloLogging|None):
+		self.__logger=logger
+		
+		self.isLoggerEnabled=self.__logger is not None
+		self.contaTentativi=0
+		self.nomeFunzChiamanti=[]
+		self.msgFunzChiamanti=None
+	
+	def run(self, retries:int,retriesBeforeNotify: int, funzione, *args,**kwargs):
+		"""
+		se 'retries' e' = -1 allora continua a provare all'infinito
+		se 'retriesBeforeNotify' e' = 0 allora in caso di errore di rete notifica subito
+		"""
+		ritorno = None
+		while self._buildIf(self.contaTentativi,retries):
+			try:
+				ritorno = funzione(*args,**kwargs)
+				self.contaTentativi = -1
+			except (EccezioneHttpGeneric,ConnectionError, TimeoutError, URLError,
+					requests.exceptions.ConnectionError, socket.gaierror) as ex:
+				# controllo il tipo di errore
+				ModuloHttpConnectionSafe.__checkCodeExc(ex)
+				# gestisco l'assenza di connessione
+				self.contaTentativi += 1
+				# scrivo un messaggio di avviso
+				if retriesBeforeNotify == 0 or self.contaTentativi >= retriesBeforeNotify:
+					self.__buildMsgAndNotify()
+				ModuloHttpConnectionSafe.__dynamicPauseOrRaiseExc(self.contaTentativi, ex)
+		self.contaTentativi=0
+		self.nomeFunzChiamanti.clear()
+		return ritorno
+	
+	@staticmethod
+	def _buildIf(contaTentativi:int,retries:int)->bool:
+		return contaTentativi >= 0 and (retries==-1 or contaTentativi<retries)
+	
+	def __buildMsgAndNotify(self):
+		if not self.nomeFunzChiamanti:
+			self.msgFunzChiamanti="Errore di connessione nella funzione "+ModuloFunzioni.getFunctionName(1)+"()"
+			i=0
+			while -1<i<2:
+				nomeFunz = ModuloFunzioni.getFunctionName(i+2)
+				if not ModuloStringhe.isEmpty(nomeFunz):
+					self.msgFunzChiamanti += f", chiamata da {nomeFunz}()"
+					i+=1
+				else:
+					i=-1
+		msg=self.msgFunzChiamanti+f"; tentativo numero: {self.contaTentativi}"
+		if self.isLoggerEnabled:
+			self.__logger.error(msg)
+		else:
+			print(msg)
+	
+	@staticmethod
+	def __checkCodeExc(ex: Exception):
+		try:
+			codiceErrore = ex.code
+		except AttributeError:
+			codiceErrore = 0
+		if codiceErrore in (404, 500):
+			raise ex
+	
+	@staticmethod
+	def __dynamicPauseOrRaiseExc(contaTentativi: int, ex: Exception):
+		if 0 < contaTentativi <= 20:
+			time.sleep(10)
+		elif 20 < contaTentativi <= 30:
+			time.sleep(60)
+		elif 20 < contaTentativi <= 50:
+			time.sleep(60 * 2)
+		elif 50 < contaTentativi <= 100:
+			time.sleep(60 * 5)
+		else:
+			raise ex

modulitiz_micro/rete/http/ModuloHttpUtils.py

@@ -0,0 +1,66 @@
+import json
+import random
+from urllib.parse import quote_plus
+from urllib.parse import unquote_plus
+
+import requests
+
+from modulitiz_micro.ModuloStringhe import ModuloStringhe
+from modulitiz_micro.eccezioni.http.EccezioneHttpGeneric import EccezioneHttpGeneric
+from modulitiz_micro.files.ModuloLogging import ModuloLogging
+from modulitiz_micro.rete.http.ModuloHttp import ModuloHttp
+from modulitiz_micro.rete.http.ModuloHttpConnectionSafe import ModuloHttpConnectionSafe
+from modulitiz_micro.rete.http.decorators.catchAndRaiseHttpExceptions import catchAndRaiseHttpExceptions
+
+
+class ModuloHttpUtils(object):
+	@staticmethod
+	def isUrlAvailable(logger:ModuloLogging|None,url:str,retries:int,ignoreCerts:bool=False) -> bool:
+		if retries!=0:
+			connectionSafe=ModuloHttpConnectionSafe(logger)
+			return connectionSafe.run(retries,0,ModuloHttpUtils.__isUrlAvailable,url,ignoreCerts)
+		try:
+			return ModuloHttpUtils.__isUrlAvailable(url,ignoreCerts)
+		except EccezioneHttpGeneric:
+			return False
+	
+	@staticmethod
+	@catchAndRaiseHttpExceptions
+	def __isUrlAvailable(url:str,ignoreCerts:bool) -> bool:
+		with requests.get(url,stream=True,verify=(not ignoreCerts)) as response:
+			return response.status_code==ModuloHttp.STATUS_OK
+	
+	@staticmethod
+	def getIp() -> str|None:
+		url=random.choice(ModuloHttp.URLS_GET_IP)
+		http=ModuloHttp(url,None)
+		try:
+			response=http.doGet(2,False)
+		except EccezioneHttpGeneric:
+			return None
+		if response is None:
+			return None
+		return response.responseBody.decode(ModuloStringhe.CODIFICA_UTF8)
+	
+	@classmethod
+	def translate(cls,langFrom:str|None,langTo:str,msg:str) -> str|None:
+		if langFrom is None:
+			langFrom="auto"
+		msg=cls.encodeUrl(msg)
+		url=f'https://translate.googleapis.com/translate_a/single?client=gtx&sl={langFrom}&tl={langTo}&dt=t&q={msg}'
+		http=ModuloHttp(url,None)
+		try:
+			response=http.doGet(3,False)
+		except EccezioneHttpGeneric:
+			return None
+		responseText=response.responseBody.decode(ModuloStringhe.CODIFICA_UTF8)
+		result=json.loads(responseText)
+		output="".join(x[0] for x in result[0])
+		return output
+	
+	@staticmethod
+	def encodeUrl(url: str) -> str:
+		return quote_plus(url)
+	@staticmethod
+	def decodeUrl(url: str) -> str:
+		return unquote_plus(url)

modulitiz_micro/rete/http/beans/HttpResponseBean.py

@@ -0,0 +1,5 @@
+class HttpResponseBean(object):
+	def __init__(self,status:int,responseBody:bytes,responseHeaders:dict):
+		self.status=status
+		self.responseBody=responseBody
+		self.responseHeaders=responseHeaders

modulitiz_micro/rete/http/decorators/catchAndRaiseHttpExceptions.py

@@ -0,0 +1,22 @@
+import socket
+from functools import wraps
+from urllib.error import URLError
+
+import requests
+
+from modulitiz_micro.eccezioni.http.EccezioneHttpGeneric import EccezioneHttpGeneric
+
+
+def catchAndRaiseHttpExceptions(funzione):
+	"""
+	Cattura tutte le eccezioni http di vario tipo e rilancia un'eccezione custom
+	"""
+	
+	@wraps(funzione)
+	def wrapped(*args,**kwargs):
+		try:
+			return funzione(*args,**kwargs)
+		except (ConnectionError,TimeoutError,URLError,
+				requests.exceptions.ConnectionError,socket.gaierror) as ex:
+			raise EccezioneHttpGeneric() from ex
+	return wrapped

modulitiz_micro/rete/ntp/AbstractModuloNtp.py

@@ -0,0 +1,73 @@
+import socket
+import struct
+from abc import ABC
+
+from modulitiz_micro.ModuloDate import ModuloDate
+from modulitiz_micro.eccezioni.http.EccezioneHttpGeneric import EccezioneHttpGeneric
+from modulitiz_micro.files.ModuloLogging import ModuloLogging
+from modulitiz_micro.rete.http.ModuloHttpConnectionSafe import ModuloHttpConnectionSafe
+from modulitiz_micro.rete.http.decorators.catchAndRaiseHttpExceptions import catchAndRaiseHttpExceptions
+
+
+class AbstractModuloNtp(ABC):
+	REFRESH_CACHE_EVERY_SECS=4*3600*1000		# frequenza richiesta NTP, l'rpi sballa di 45 minuti ogni 24 ore
+	OFFSET_MILLIS=1		# offset correzione errore
+	TIMEOUT=10
+	
+	__PORTA=123						# numero della porta (UDP)
+	__BUF=1024
+	__TIME1970=2208988800			# reference time, secondi da 1900-01-01 00:00:00 a 1970-01-01 00:00:00 = 70 anni
+	__MSG=('\x1b' + 47 * '\0').encode()
+	
+	
+	def __init__(self,host:str,logger:ModuloLogging):
+		self.logger=logger
+		self.connectionSafe = ModuloHttpConnectionSafe(logger)
+		self.host=host
+		self.lastNtpResponse=0
+		self.lastNtpTimestampUtc=0
+	
+	def getTimestampUtcFromNtp(self,useCache:bool=True,retryIfError:bool=True)->int:
+		if useCache is True and self.lastNtpResponse!=0:
+			# controllo se e' passato poco tempo dall'ultima chiamata ntp
+			diffMillisLastResponse=(ModuloDate.getMillis()-self.lastNtpResponse)
+			if diffMillisLastResponse<self.REFRESH_CACHE_EVERY_SECS:
+				# calcolo l'ora attuale usando il cronometro interno
+				return self.lastNtpTimestampUtc+diffMillisLastResponse+self.OFFSET_MILLIS
+		# invio la richiesta e in caso di errore...
+		if not retryIfError:
+			#... uso il cronometro interno
+			try:
+				timestampUtc=self.__ntpSendPacket()
+			except EccezioneHttpGeneric:
+				timestampUtc=None
+		else:
+			#... riprovo
+			timestampUtc=self.connectionSafe.run(1,3,self.__ntpSendPacket)
+		if timestampUtc is None:
+			diffMillisLastResponse=(ModuloDate.getMillis()-self.lastNtpResponse)
+			return self.lastNtpTimestampUtc+diffMillisLastResponse+self.OFFSET_MILLIS
+		timestampUtc=timestampUtc*1000
+		# successo
+		self.lastNtpResponse=ModuloDate.getMillis()
+		self.lastNtpTimestampUtc=timestampUtc
+		return self.lastNtpTimestampUtc
+	
+	def getDatetimeFromNtp(self,useCache:bool=True,retryIfError:bool=True):
+		tsSec=self.getTimestampUtcFromNtp(useCache,retryIfError)//1000
+		return ModuloDate.timestampUtcToDate(tsSec)
+	
+	@catchAndRaiseHttpExceptions
+	def __ntpSendPacket(self)->int:
+		# connect to server
+		client=socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+		client.settimeout(self.TIMEOUT)
+		client.sendto(self.__MSG,(self.host,self.__PORTA))
+		# ricevo i dati
+		response=client.recvfrom(self.__BUF)[0]
+		# chiudo la socket
+		client.close()
+		# estraggo il timestamp
+		tsSec=struct.unpack("!12I",response)[10]
+		tsSec-=self.__TIME1970
+		return tsSec