modulitiz-micro 2.45.0__py311-none-any.whl → 2.46.0__py311-none-any.whl

modulitiz_micro/files/cache/decorators/cacheRam.py

@@ -1,26 +1,26 @@
-from functools import wraps
-
-from cachetools import TTLCache
-from cachetools import cached
-
-from modulitiz_nano.ModuloNumeri import ModuloNumeri
-
-
-def cacheRam(minsBeforeExpiry: int|float|None):
-	"""
-	Usare questo decorator per mettere in cache delle informazioni.
-	Alla base usa una libreria di terze parti.
-	:param minsBeforeExpiry: se null mantiene i dati in memoria per 1 giorno
-	"""
-	
-	__secsBeforeExpiry=24*3600 if minsBeforeExpiry is None else ModuloNumeri.decimalNumbersTruncate(minsBeforeExpiry*60,2)
-	__cache=cached(TTLCache(20,__secsBeforeExpiry))
-	
-	def decorator(funzione):
-		__funzione=__cache(funzione)
-		
-		@wraps(funzione)
-		def wrapped(*args,**kwargs):
-			return __funzione(*args,**kwargs)
-		return wrapped
-	return decorator
+from functools import wraps
+
+from cachetools import TTLCache
+from cachetools import cached
+
+from modulitiz_nano.ModuloNumeri import ModuloNumeri
+
+
+def cacheRam(minsBeforeExpiry: int|float|None):
+	"""
+	Usare questo decorator per mettere in cache delle informazioni.
+	Alla base usa una libreria di terze parti.
+	:param minsBeforeExpiry: se null mantiene i dati in memoria per 1 giorno
+	"""
+	
+	__secsBeforeExpiry=24*3600 if minsBeforeExpiry is None else ModuloNumeri.decimalNumbersTruncate(minsBeforeExpiry*60,2)
+	__cache=cached(TTLCache(20,__secsBeforeExpiry))
+	
+	def decorator(funzione):
+		__funzione=__cache(funzione)
+		
+		@wraps(funzione)
+		def wrapped(*args,**kwargs):
+			return __funzione(*args,**kwargs)
+		return wrapped
+	return decorator

modulitiz_micro/files/git/ModuloGit.py

@@ -1,28 +1,28 @@
-import git
-
-from modulitiz_micro.files.git.decorators.catchAndRaiseGitExceptions import catchAndRaiseGitExceptions
-
-
-class ModuloGit(object):
-	def __init__(self, repoPath:str):
-		self.inner=git.Repo(repoPath)
-	
-	@catchAndRaiseGitExceptions
-	def getWorkingCopyRevision(self)->str:
-		return self.inner.head.object.hexsha
-	
-	@catchAndRaiseGitExceptions
-	def getRemoteRevision(self)->str:
-		return self.inner.remotes[0].fetch()[0].ref.object.hexsha
-	
-	@catchAndRaiseGitExceptions
-	def addFile(self,filenamePath:str):
-		self.inner.index.add(filenamePath)
-	
-	@catchAndRaiseGitExceptions
-	def removeFile(self,filenamePath:str):
-		self.inner.index.remove(filenamePath,working_tree=True)
-	
-	@catchAndRaiseGitExceptions
-	def update(self)->str:
-		return self.inner.remotes[0].pull()[0].ref.object.hexsha
+import git
+
+from modulitiz_micro.files.git.decorators.catchAndRaiseGitExceptions import catchAndRaiseGitExceptions
+
+
+class ModuloGit(object):
+	def __init__(self, repoPath:str):
+		self.inner=git.Repo(repoPath)
+	
+	@catchAndRaiseGitExceptions
+	def getWorkingCopyRevision(self)->str:
+		return self.inner.head.object.hexsha
+	
+	@catchAndRaiseGitExceptions
+	def getRemoteRevision(self)->str:
+		return self.inner.remotes[0].fetch()[0].ref.object.hexsha
+	
+	@catchAndRaiseGitExceptions
+	def addFile(self,filenamePath:str):
+		self.inner.index.add(filenamePath)
+	
+	@catchAndRaiseGitExceptions
+	def removeFile(self,filenamePath:str):
+		self.inner.index.remove(filenamePath,working_tree=True)
+	
+	@catchAndRaiseGitExceptions
+	def update(self)->str:
+		return self.inner.remotes[0].pull()[0].ref.object.hexsha

modulitiz_micro/files/git/decorators/catchAndRaiseGitExceptions.py

@@ -1,19 +1,19 @@
-from functools import wraps
-
-from git import GitCommandError
-
-from modulitiz_micro.files.git.exceptions.EccezioneGit import EccezioneGit
-
-
-def catchAndRaiseGitExceptions(funzione):
-	"""
-	Cattura tutte le eccezioni git di vario tipo e rilancia un'eccezione custom
-	"""
-	
-	@wraps(funzione)
-	def wrapped(*args,**kwargs):
-		try:
-			return funzione(*args,**kwargs)
-		except (GitCommandError,) as ex:
-			raise EccezioneGit() from ex
-	return wrapped
+from functools import wraps
+
+from git import GitCommandError
+
+from modulitiz_micro.files.git.exceptions.EccezioneGit import EccezioneGit
+
+
+def catchAndRaiseGitExceptions(funzione):
+	"""
+	Cattura tutte le eccezioni git di vario tipo e rilancia un'eccezione custom
+	"""
+	
+	@wraps(funzione)
+	def wrapped(*args,**kwargs):
+		try:
+			return funzione(*args,**kwargs)
+		except (GitCommandError,) as ex:
+			raise EccezioneGit() from ex
+	return wrapped

modulitiz_micro/files/git/exceptions/EccezioneGit.py

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

modulitiz_micro/gestionedom/GestioneDom.py

@@ -1,44 +1,44 @@
-from bs4 import BeautifulSoup
-
-from modulitiz_nano.ModuloStringhe import ModuloStringhe
-from modulitiz_nano.files.ModuloFiles import ModuloFiles
-
-
-class GestioneDom(object):
-	def __init__(self, percorsoNomefile: str | None, htmlString:str):
-		if percorsoNomefile is not None:
-			self.percorsoNomefile=percorsoNomefile
-			htmlString=ModuloFiles.readFileText(percorsoNomefile, True)
-		self.htmlString=htmlString
-		self.dom=self.__createObj()
-	
-	@staticmethod
-	def innerHTML(tag):
-		"""
-		dato in input un tag html della classe BeautifulSoup, restituisce il codice html all'interno di questo tag
-		"""
-		return "".join([str(x) for x in tag.contents])
-	
-	def selector(self,cssSelector:str):
-		"""
-		estrae tutti gli elementi che corrispondono al css selector
-		"""
-		elementi=self.dom.select(cssSelector)
-		return elementi
-	
-	@staticmethod
-	def getAttributeValue(tag, nomeAttr:str):
-		oldValue=tag.attrs[nomeAttr]
-		return oldValue
-	@staticmethod
-	def setAttributeValue(tag, nomeAttr:str, value):
-		tag.attrs[nomeAttr]=value
-		return tag
-	
-	def save(self):
-		htmlOut=str(self.dom).encode(ModuloStringhe.CODIFICA_UTF8)
-		with ModuloFiles.open(self.percorsoNomefile, "wb") as file:
-			file.write(htmlOut)
-	
-	def __createObj(self)->BeautifulSoup:
-		return BeautifulSoup(self.htmlString, features="html.parser")
+from bs4 import BeautifulSoup
+
+from modulitiz_nano.ModuloStringhe import ModuloStringhe
+from modulitiz_nano.files.ModuloFiles import ModuloFiles
+
+
+class GestioneDom(object):
+	def __init__(self, percorsoNomefile: str | None, htmlString:str):
+		if percorsoNomefile is not None:
+			self.percorsoNomefile=percorsoNomefile
+			htmlString=ModuloFiles.readFileText(percorsoNomefile, True)
+		self.htmlString=htmlString
+		self.dom=self.__createObj()
+	
+	@staticmethod
+	def innerHTML(tag):
+		"""
+		dato in input un tag html della classe BeautifulSoup, restituisce il codice html all'interno di questo tag
+		"""
+		return "".join([str(x) for x in tag.contents])
+	
+	def selector(self,cssSelector:str):
+		"""
+		estrae tutti gli elementi che corrispondono al css selector
+		"""
+		elementi=self.dom.select(cssSelector)
+		return elementi
+	
+	@staticmethod
+	def getAttributeValue(tag, nomeAttr:str):
+		oldValue=tag.attrs[nomeAttr]
+		return oldValue
+	@staticmethod
+	def setAttributeValue(tag, nomeAttr:str, value):
+		tag.attrs[nomeAttr]=value
+		return tag
+	
+	def save(self):
+		htmlOut=str(self.dom).encode(ModuloStringhe.CODIFICA_UTF8)
+		with ModuloFiles.open(self.percorsoNomefile, "wb") as file:
+			file.write(htmlOut)
+	
+	def __createObj(self)->BeautifulSoup:
+		return BeautifulSoup(self.htmlString, features="html.parser")

modulitiz_micro/iot/ModuleIotDevice.py

@@ -1,62 +1,62 @@
-from modulitiz_nano.ModuloNumeri import ModuloNumeri
-from modulitiz_nano.ModuloStringhe import ModuloStringhe
-from modulitiz_nano.eccezioni.EccezioneRuntime import EccezioneRuntime
-from modulitiz_micro.eccezioni.http.EccezioneHttp import EccezioneHttp
-from modulitiz_nano.files.ModuloLogging import ModuloLogging
-from modulitiz_micro.iot.beans.IotDeviceBean import IotDeviceBean
-from modulitiz_micro.iot.enums.IotOSEnum import IotOSEnum
-from modulitiz_micro.iot.espurna.ModuleEspurna import ModuleEspurna
-from modulitiz_micro.rete.http.ModuloHttp import ModuloHttp
-
-
-class ModuleIotDevice(object):
-	def __init__(self, logger:ModuloLogging|None, deviceBean:IotDeviceBean):
-		self.__logger=logger
-		self.__deviceBean=deviceBean
-	
-	def getRelayStatus(self, relayNum:int)->bool:
-		"""
-		@param relayNum: Depending on which OS you choose, can be relative (0, 1, ...) or GPIO
-		"""
-		if self.__deviceBean.os==IotOSEnum.ESPURNA:
-			url=ModuleEspurna.URL_GET_RELAY.format(ip=self.__deviceBean.ip,relayNum=relayNum,apiKey=self.__deviceBean.key)
-		else:
-			raise EccezioneRuntime("Iot os '%s' not known"%(self.__deviceBean.os,))
-		return ModuloNumeri.intToBool(ModuloNumeri.strToInt(self.__sendRequest(url)))
-	
-	def setRelayStatus(self,relayNum: int,status: bool):
-		"""
-		@param relayNum: Depending on which OS you choose, can be relative (0, 1, ...) or GPIO
-		@param status: value to set, can only be false or true
-		"""
-		self.__setRelayStatus(relayNum,status)
-	
-	def setRelayStatusToggle(self,relayNum: int):
-		self.__setRelayStatus(relayNum,None)
-	
-	def __setRelayStatus(self, relayNum:int, status:bool|None):
-		"""
-		@param relayNum: Depending on which OS you choose, can be relative (0, 1, ...) or GPIO
-		@param status: value to set, can be: false = off, true = on, null/None = toggle
-		"""
-		if self.__deviceBean.os==IotOSEnum.ESPURNA:
-			if status is not None:
-				statusStr=str(ModuloNumeri.boolToInt(status))
-			else:
-				statusStr=2
-			url=ModuleEspurna.URL_SET_RELAY.format(ip=self.__deviceBean.ip,relayNum=relayNum,apiKey=self.__deviceBean.key,status=statusStr)
-		else:
-			raise EccezioneRuntime("Iot os '%s' not known"%(self.__deviceBean.os,))
-		# check output
-		statusOutput=ModuloNumeri.intToBool(int(self.__sendRequest(url)))
-		if status is None or status==statusOutput:
-			return
-		raise EccezioneRuntime("Wrong expected status: %d != %d"%(status,statusOutput))
-	
-	def __sendRequest(self, url:str)->str:
-		http=ModuloHttp(url,self.__logger,False)
-		http.setUserAgent()
-		bean=http.doGet(0, False)
-		if bean.status!=ModuloHttp.STATUS_OK:
-			raise EccezioneHttp(bean.status)
-		return bean.responseBody.decode(ModuloStringhe.CODIFICA_UTF8)
+from modulitiz_nano.ModuloNumeri import ModuloNumeri
+from modulitiz_nano.ModuloStringhe import ModuloStringhe
+from modulitiz_nano.eccezioni.EccezioneRuntime import EccezioneRuntime
+from modulitiz_micro.eccezioni.http.EccezioneHttp import EccezioneHttp
+from modulitiz_nano.files.ModuloLogging import ModuloLogging
+from modulitiz_micro.iot.beans.IotDeviceBean import IotDeviceBean
+from modulitiz_micro.iot.enums.IotOSEnum import IotOSEnum
+from modulitiz_micro.iot.espurna.ModuleEspurna import ModuleEspurna
+from modulitiz_micro.rete.http.ModuloHttp import ModuloHttp
+
+
+class ModuleIotDevice(object):
+	def __init__(self, logger:ModuloLogging|None, deviceBean:IotDeviceBean):
+		self.__logger=logger
+		self.__deviceBean=deviceBean
+	
+	def getRelayStatus(self, relayNum:int)->bool:
+		"""
+		@param relayNum: Depending on which OS you choose, can be relative (0, 1, ...) or GPIO
+		"""
+		if self.__deviceBean.os==IotOSEnum.ESPURNA:
+			url=ModuleEspurna.URL_GET_RELAY.format(ip=self.__deviceBean.ip,relayNum=relayNum,apiKey=self.__deviceBean.key)
+		else:
+			raise EccezioneRuntime("Iot os '%s' not known"%(self.__deviceBean.os,))
+		return ModuloNumeri.intToBool(ModuloNumeri.strToInt(self.__sendRequest(url)))
+	
+	def setRelayStatus(self,relayNum: int,status: bool):
+		"""
+		@param relayNum: Depending on which OS you choose, can be relative (0, 1, ...) or GPIO
+		@param status: value to set, can only be false or true
+		"""
+		self.__setRelayStatus(relayNum,status)
+	
+	def setRelayStatusToggle(self,relayNum: int):
+		self.__setRelayStatus(relayNum,None)
+	
+	def __setRelayStatus(self, relayNum:int, status:bool|None):
+		"""
+		@param relayNum: Depending on which OS you choose, can be relative (0, 1, ...) or GPIO
+		@param status: value to set, can be: false = off, true = on, null/None = toggle
+		"""
+		if self.__deviceBean.os==IotOSEnum.ESPURNA:
+			if status is not None:
+				statusStr=str(ModuloNumeri.boolToInt(status))
+			else:
+				statusStr=2
+			url=ModuleEspurna.URL_SET_RELAY.format(ip=self.__deviceBean.ip,relayNum=relayNum,apiKey=self.__deviceBean.key,status=statusStr)
+		else:
+			raise EccezioneRuntime("Iot os '%s' not known"%(self.__deviceBean.os,))
+		# check output
+		statusOutput=ModuloNumeri.intToBool(int(self.__sendRequest(url)))
+		if status is None or status==statusOutput:
+			return
+		raise EccezioneRuntime("Wrong expected status: %d != %d"%(status,statusOutput))
+	
+	def __sendRequest(self, url:str)->str:
+		http=ModuloHttp(url,self.__logger,False)
+		http.setUserAgent()
+		bean=http.doGet(0, False)
+		if bean.status!=ModuloHttp.STATUS_OK:
+			raise EccezioneHttp(bean.status)
+		return bean.responseBody.decode(ModuloStringhe.CODIFICA_UTF8)

modulitiz_micro/keylogger/EccezioneKeyLogger.py

@@ -1,7 +1,7 @@
-from modulitiz_nano.eccezioni.EccezioneBase import EccezioneBase
-
-
-class EccezioneKeyLogger(EccezioneBase):
-	
-	def __init__(self):
-		super().__init__("Ricevuto comando da tastiera di chiusura programma")
+from modulitiz_nano.eccezioni.EccezioneBase import EccezioneBase
+
+
+class EccezioneKeyLogger(EccezioneBase):
+	
+	def __init__(self):
+		super().__init__("Ricevuto comando da tastiera di chiusura programma")

modulitiz_micro/keylogger/ModuloKeylogger.py

@@ -1,73 +1,73 @@
-import threading
-import time
-from typing import Callable
-
-from modulitiz_nano.sistema.ModuloSystem import ModuloSystem
-
-if ModuloSystem.isWindows():
-	from pynput.keyboard import Key, Listener
-
-
-class ModuloKeylogger(object):
-	IS_AVAILABLE=ModuloSystem.isWindows()
-	EXIT_KEY=None
-	EXIT_KEY_2=None
-	if IS_AVAILABLE:
-		EXIT_KEY=Key.pause
-		EXIT_KEY_2=Key.menu
-	
-	__lastKeyPressed=None
-	__numKeyPressed=0
-	__callbackOnKeyPress=None
-	
-	@staticmethod
-	def getTasto(key):
-		try:
-			tasto=key.char
-		except AttributeError:
-			tasto=key
-		if tasto is None:
-			return str(key.vk)
-		return str(tasto).replace("Key.","")
-	
-	@classmethod
-	def start(cls,callbackOnKeyPress:Callable,runNewProcess:bool):
-		"""
-		Se la liberia non e' disponibile non verra' caricata, ad esempio se usi la cli
-		"""
-		# controllo se e' disponibile
-		if not cls.IS_AVAILABLE:
-			return
-		# lancio gli handler
-		cls.__callbackOnKeyPress=callbackOnKeyPress
-		if runNewProcess is True:
-			processo=threading.Thread(target=cls.__tStartListening,args=(cls.__onKeyPressHandler,cls.__onKeyReleaseHandler),daemon=True)
-			processo.start()
-			return
-		cls.__startListening(cls.__onKeyPressHandler,cls.__onKeyReleaseHandler)
-	
-	@staticmethod
-	def __startListening(onKeyPressHandler,onKeyReleaseHandler):
-		with Listener(on_press=onKeyPressHandler,on_release=onKeyReleaseHandler) as listener:
-			listener.join()
-	@classmethod
-	def __tStartListening(cls,onKeyPressHandler,onKeyReleaseHandler):
-		cls.__startListening(onKeyPressHandler,onKeyReleaseHandler)
-		while True:
-			time.sleep(1)
-	
-	#
-	#key handlers
-	#
-	@classmethod
-	def __onKeyPressHandler(cls,key):
-		if cls.__lastKeyPressed==key:
-			return
-		cls.__callbackOnKeyPress(key,cls.__numKeyPressed)
-		
-		cls.__lastKeyPressed=key
-		cls.__numKeyPressed+=1
-	@classmethod
-	def __onKeyReleaseHandler(cls,key):
-		cls.__lastKeyPressed=None
-		cls.__numKeyPressed-=1
+import threading
+import time
+from typing import Callable
+
+from modulitiz_nano.sistema.ModuloSystem import ModuloSystem
+
+if ModuloSystem.isWindows():
+	from pynput.keyboard import Key, Listener
+
+
+class ModuloKeylogger(object):
+	IS_AVAILABLE=ModuloSystem.isWindows()
+	EXIT_KEY=None
+	EXIT_KEY_2=None
+	if IS_AVAILABLE:
+		EXIT_KEY=Key.pause
+		EXIT_KEY_2=Key.menu
+	
+	__lastKeyPressed=None
+	__numKeyPressed=0
+	__callbackOnKeyPress=None
+	
+	@staticmethod
+	def getTasto(key):
+		try:
+			tasto=key.char
+		except AttributeError:
+			tasto=key
+		if tasto is None:
+			return str(key.vk)
+		return str(tasto).replace("Key.","")
+	
+	@classmethod
+	def start(cls,callbackOnKeyPress:Callable,runNewProcess:bool):
+		"""
+		Se la liberia non e' disponibile non verra' caricata, ad esempio se usi la cli
+		"""
+		# controllo se e' disponibile
+		if not cls.IS_AVAILABLE:
+			return
+		# lancio gli handler
+		cls.__callbackOnKeyPress=callbackOnKeyPress
+		if runNewProcess is True:
+			processo=threading.Thread(target=cls.__tStartListening,args=(cls.__onKeyPressHandler,cls.__onKeyReleaseHandler),daemon=True)
+			processo.start()
+			return
+		cls.__startListening(cls.__onKeyPressHandler,cls.__onKeyReleaseHandler)
+	
+	@staticmethod
+	def __startListening(onKeyPressHandler,onKeyReleaseHandler):
+		with Listener(on_press=onKeyPressHandler,on_release=onKeyReleaseHandler) as listener:
+			listener.join()
+	@classmethod
+	def __tStartListening(cls,onKeyPressHandler,onKeyReleaseHandler):
+		cls.__startListening(onKeyPressHandler,onKeyReleaseHandler)
+		while True:
+			time.sleep(1)
+	
+	#
+	#key handlers
+	#
+	@classmethod
+	def __onKeyPressHandler(cls,key):
+		if cls.__lastKeyPressed==key:
+			return
+		cls.__callbackOnKeyPress(key,cls.__numKeyPressed)
+		
+		cls.__lastKeyPressed=key
+		cls.__numKeyPressed+=1
+	@classmethod
+	def __onKeyReleaseHandler(cls,key):
+		cls.__lastKeyPressed=None
+		cls.__numKeyPressed-=1

modulitiz_micro/rete/ModuleAndroidTVRemote.py

@@ -0,0 +1,107 @@
+import asyncio
+import os.path
+
+from androidtvremote2 import AndroidTVRemote
+from androidtvremote2 import CannotConnect
+from androidtvremote2 import ConnectionClosed
+from androidtvremote2 import InvalidAuth
+
+from modulitiz_micro.rete.ModuloNetworking import ModuloNetworking
+from modulitiz_nano.eccezioni.EccezioneRuntime import EccezioneRuntime
+from modulitiz_nano.files.ModuloLogging import ModuloLogging
+from modulitiz_nano.util.decorators.noAwait import noAwait
+
+
+class ModuleAndroidTVRemote(object):
+	API_PORT=6466
+	PAIR_PORT=6467
+	
+	def __init__(self,logger:ModuloLogging,clientName:str,outputDir:str,ip:str):
+		self.__logger=logger
+		self.__clientName=clientName
+		self.__outputDir=outputDir
+		self.__ip=ip
+		
+		self.conn:AndroidTVRemote|None=None
+	
+	@noAwait
+	async def populate(self):
+		# check availability
+		if not ModuloNetworking.checkPing(self.__ip):
+			raise EccezioneRuntime(f"Ip {self.__ip} not found")
+		self.__isPortOpen(self.API_PORT)
+		self.__isPortOpen(self.API_PORT)
+		# create connection
+		certFile=os.path.join(self.__outputDir,"cert.pem")
+		keyFile=os.path.join(self.__outputDir,"key.pem")
+		self.conn=AndroidTVRemote(self.__clientName,certFile,keyFile,self.__ip)
+		# pairing
+		self.__logger.debug("Start pairing")
+		if await self.conn.async_generate_cert_if_missing():
+			self.__logger.debug("Generated new certificate")
+			await self.__pair()
+		while True:
+			try:
+				await self.conn.async_connect()
+				break
+			except InvalidAuth:
+				self.__logger.exception("Need to pair again")
+				await self.__pair()
+			except (CannotConnect,ConnectionClosed):
+				self.__logger.exception("Cannot connect, exiting")
+				return
+		await asyncio.sleep(0.2)
+		self.__logger.debug("Pair ok")
+	
+	async def __pair(self):
+		name,mac=await self.conn.async_get_name_and_mac()
+		self.__logger.info(f"Start Pairing with {self.conn.host} {name} {mac}, this will turn on the Android TV")
+		await self.conn.async_start_pairing()
+		while True:
+			pairing_code=await asyncio.to_thread(input,"Enter pairing code: ")
+			try:
+				return await self.conn.async_finish_pairing(pairing_code)
+			except InvalidAuth:
+				self.__logger.exception("Invalid pairing code")
+				continue
+			except ConnectionClosed:
+				self.__logger.exception("Initialize pair again")
+				await self.__pair()
+	
+	def getVolumeLevel(self)->int:
+		return self.conn.volume_info["level"]
+	
+	@noAwait
+	async def setVolumeLevel(self,level: int):
+		currentLevel=self.getVolumeLevel()
+		diff=currentLevel-level
+		if diff==0:
+			return
+		cmd="VOLUME_DOWN" if diff>0 else "VOLUME_UP"
+		# pause needed for elaborating data
+		await asyncio.sleep(0.4)
+		for _ in range(abs(diff)):
+			self.conn.send_key_command(cmd)
+		await asyncio.sleep(0.4)
+		# check if level is correct
+		currentLevel=self.getVolumeLevel()
+		if level!=currentLevel:
+			raise EccezioneRuntime(f"Current volume level {currentLevel} don't equals {level}")
+	
+	@noAwait
+	async def sendCommand(self,cmd:str):
+		# pause needed for elaborating data
+		await asyncio.sleep(0.4)
+		self.conn.send_key_command(cmd)
+		await asyncio.sleep(0.4)
+	
+	def close(self):
+		if self.conn is None:
+			return
+		self.conn.disconnect()
+		self.conn = None
+	
+	def __isPortOpen(self,port:int):
+		if ModuloNetworking.isHttpPortOpen(self.__ip,port):
+			return
+		raise EccezioneRuntime(f"Port {port} on ip {self.__ip} not open")