modulitiz-micro 2.31.0__py311-none-any.whl → 2.32.0__py311-none-any.whl

modulitiz_micro/files/ModuloFiles.py

@@ -1,173 +1,173 @@
-import glob
-import os
-import shutil
-
-from modulitiz_micro.ModuloDate import ModuloDate
-from modulitiz_micro.ModuloListe import ModuloListe
-from modulitiz_micro.ModuloStringhe import ModuloStringhe
-from modulitiz_micro.eccezioni.EccezioneRuntime import EccezioneRuntime
-
-
-class ModuloFiles(object):
-	@staticmethod
-	def open(*args,**kwargs):
-		return open(newline="\n",*args,**kwargs)
-	
-	@classmethod
-	def readFileBinary(cls,filename:str)->str:
-		"""
-		Convert digital data to binary format
-		Puo' essere usato, ad esempio, per inserire un file di tipo BLOB su sqlite
-		"""
-		return cls.readFile(filename,'rb',None)
-	@classmethod
-	def readFileText(cls,filename:str,useUtf8:bool|None)->str:
-		return cls.readFile(filename,'rt',useUtf8)
-	@staticmethod
-	def readFile(filename:str,mode:str,useUtf8:bool|None):
-		codifica=None
-		if useUtf8 is not None:
-			if useUtf8 is True:
-				codifica=ModuloStringhe.CODIFICA_UTF8
-			else:
-				codifica='latin-1'
-		with open(filename,mode,encoding=codifica) as fp:
-			cont=fp.read()
-		return cont
-
-	@staticmethod
-	def getFileSize(nomefile:str)->int:
-		"""
-		Se non trova nessun file ritorna -1
-		"""
-		try:
-			statinfo=os.stat(nomefile)
-			return statinfo.st_size
-		except FileNotFoundError:
-			return -1
-
-	@classmethod
-	def getFolderSize(cls, path:str)->int:
-		if not os.path.exists(path) or os.path.isfile(path):
-			return -1
-		count=0
-		for root,cartelle,filenames in os.walk(path):
-			for filename in filenames:
-				count+=cls.getFileSize(os.path.join(root,filename))
-		return count
-	
-	@staticmethod
-	def getTimestampUtcUltimaModifica(nomefile:str)->int:
-		return int(os.path.getmtime(nomefile))
-
-	@staticmethod
-	def normalizzaSlashPath(percorso:str)->str:
-		percorso=os.path.normpath(percorso)
-		return percorso.replace("\\","/")
-
-	@classmethod
-	def pathJoin(cls,path1:str|None,path2:str|None)->str|None:
-		if ModuloStringhe.isEmpty(path1):
-			return path2
-		if ModuloStringhe.isEmpty(path2):
-			return path1
-		# normalizzazione
-		path1=cls.normalizzaSlashPath(path1)
-		path2=cls.normalizzaSlashPath(path2)
-		# concatenazione
-		path=os.path.join(path1,path2)
-		path=cls.normalizzaSlashPath(path)
-		return path
-
-	@classmethod
-	def pathAbsToRel(cls,percorso:str,root:str):
-		percorso=percorso.replace(root,"")
-		percorso=cls.normalizzaSlashPath(percorso)
-		if percorso.startswith("/"):
-			percorso=percorso[1:]
-		return percorso
-
-	@staticmethod
-	def normalizzaPercorsoLocale(percorso:str):
-		percorso=os.path.normpath(os.path.abspath(percorso))
-		return percorso
-	@classmethod
-	def normalizzaPercorsoRemoto(cls,percorso:str):
-		return cls.normalizzaSlashPath(percorso)
-
-	@classmethod
-	def rinominaConTimestamp(cls,nomefile:str):
-		nomefileSenzaEstensione,ext=cls.getNomefileEdEstensione(nomefile)
-		nomefileNew=nomefileSenzaEstensione+"_"+ModuloDate.dateToString(None, ModuloDate.FORMATO_DATA_ORA_NOMEFILE)+ext
-		os.rename(nomefile,nomefileNew)
-
-	@staticmethod
-	def sposta(sourceFilename:str,destFilename:str):
-		shutil.move(sourceFilename,destFilename)
-
-	@staticmethod
-	def copia(sourceFilename:str,destFilename:str):
-		try:
-			shutil.copy2(sourceFilename,destFilename)
-		except Exception:
-			raise EccezioneRuntime("Errore copia file "+sourceFilename+" in "+destFilename)
-
-	@classmethod
-	def eliminaContenutoCartella(cls,percorso:str):
-		"""
-		elimina tutto il contenuto di una cartella ma non la cartella
-		"""
-		for root,cartelle,nomefiles in os.walk(percorso):
-			for nomefile in nomefiles:
-				os.unlink(cls.pathJoin(root, nomefile))
-			for cartella in cartelle:
-				shutil.rmtree(cls.pathJoin(root, cartella))
-
-	@staticmethod
-	def deleteByPattern(pattern:str):
-		filesDaElim=glob.glob(pattern)
-		for fileDaElim in filesDaElim:
-			os.remove(fileDaElim)
-
-	@staticmethod
-	def getNomefileEdEstensione(nomefile:str)->tuple:
-		arr=nomefile.split(".")
-		nomefileSenzaEstensione=".".join(arr[0:-1])
-		ext="."+arr[-1]
-		return nomefileSenzaEstensione,ext
-
-	@classmethod
-	def walk(cls,root:str,excludeFiles:list|tuple,excludeDirs:list|tuple,minByteSize:int|None,maxByteSize:int|None):
-		"""
-		Questa funzione e' uguale a os.walk() ma restituisce anche il path relativo oltre a quello assoluto.
-		"""
-		root=cls.normalizzaPercorsoLocale(root)
-		for result in os.walk(root):
-			yield from cls.__walk(root,excludeFiles,excludeDirs,minByteSize,maxByteSize,result)
-			
-	@classmethod
-	def __walk(cls,root: str,excludeFiles: list|tuple,excludeDirs: list|tuple,minByteSize: int|None,maxByteSize: int|None,
-			result:tuple[str, list[str], list[str]]):
-		percorso,cartelle,nomefiles=result
-		percorsoRel=cls.pathAbsToRel(percorso,root)
-		# elaboro i file
-		for index,nomefile in enumerate(nomefiles):
-			nomefileRelPath=cls.pathJoin(percorsoRel,nomefile)
-			# escludo i file che sono nella blacklist
-			if nomefileRelPath in excludeFiles:
-				nomefiles[index]=""
-				continue
-			# controllo dimensione file
-			if maxByteSize is not None or minByteSize is not None:
-				bytesFile=cls.getFileSize(cls.pathJoin(root,nomefileRelPath))
-				if(maxByteSize is not None and bytesFile>maxByteSize) or (minByteSize is not None and bytesFile<minByteSize):
-					nomefiles[index]=""
-		nomefiles=ModuloListe.eliminaElementiVuoti(nomefiles)
-		#elaboro le cartelle
-		for index,cartella in enumerate(cartelle):
-			cartellaRelPath=cls.normalizzaPercorsoRemoto(cls.pathJoin(percorsoRel,cartella))
-			#escludo le cartelle che sono nella blacklist
-			if cartellaRelPath in excludeDirs:
-				cartelle[index]=""
-		cartelle=ModuloListe.eliminaElementiVuoti(cartelle)
-		yield percorsoRel,percorso,cartelle,nomefiles
+import glob
+import os
+import shutil
+
+from modulitiz_micro.ModuloDate import ModuloDate
+from modulitiz_micro.ModuloListe import ModuloListe
+from modulitiz_micro.ModuloStringhe import ModuloStringhe
+from modulitiz_micro.eccezioni.EccezioneRuntime import EccezioneRuntime
+
+
+class ModuloFiles(object):
+	@staticmethod
+	def open(*args,**kwargs):
+		return open(newline="\n",*args,**kwargs)
+	
+	@classmethod
+	def readFileBinary(cls,filename:str)->str:
+		"""
+		Convert digital data to binary format
+		Puo' essere usato, ad esempio, per inserire un file di tipo BLOB su sqlite
+		"""
+		return cls.readFile(filename,'rb',None)
+	@classmethod
+	def readFileText(cls,filename:str,useUtf8:bool|None)->str:
+		return cls.readFile(filename,'rt',useUtf8)
+	@staticmethod
+	def readFile(filename:str,mode:str,useUtf8:bool|None):
+		codifica=None
+		if useUtf8 is not None:
+			if useUtf8 is True:
+				codifica=ModuloStringhe.CODIFICA_UTF8
+			else:
+				codifica='latin-1'
+		with open(filename,mode,encoding=codifica) as fp:
+			cont=fp.read()
+		return cont
+
+	@staticmethod
+	def getFileSize(nomefile:str)->int:
+		"""
+		Se non trova nessun file ritorna -1
+		"""
+		try:
+			statinfo=os.stat(nomefile)
+			return statinfo.st_size
+		except FileNotFoundError:
+			return -1
+
+	@classmethod
+	def getFolderSize(cls, path:str)->int:
+		if not os.path.exists(path) or os.path.isfile(path):
+			return -1
+		count=0
+		for root,dirs,filenames in os.walk(path):
+			for filename in filenames:
+				count+=cls.getFileSize(os.path.join(root,filename))
+		return count
+	
+	@staticmethod
+	def getTimestampUtcUltimaModifica(nomefile:str)->int:
+		return int(os.path.getmtime(nomefile))
+
+	@staticmethod
+	def normalizzaSlashPath(percorso:str)->str:
+		percorso=os.path.normpath(percorso)
+		return percorso.replace("\\","/")
+
+	@classmethod
+	def pathJoin(cls,path1:str|None,path2:str|None)->str|None:
+		if ModuloStringhe.isEmpty(path1):
+			return path2
+		if ModuloStringhe.isEmpty(path2):
+			return path1
+		# normalizzazione
+		path1=cls.normalizzaSlashPath(path1)
+		path2=cls.normalizzaSlashPath(path2)
+		# concatenazione
+		path=os.path.join(path1,path2)
+		path=cls.normalizzaSlashPath(path)
+		return path
+
+	@classmethod
+	def pathAbsToRel(cls,percorso:str,root:str):
+		percorso=percorso.replace(root,"")
+		percorso=cls.normalizzaSlashPath(percorso)
+		if percorso.startswith("/"):
+			percorso=percorso[1:]
+		return percorso
+
+	@staticmethod
+	def normalizzaPercorsoLocale(percorso:str):
+		percorso=os.path.normpath(os.path.abspath(percorso))
+		return percorso
+	@classmethod
+	def normalizzaPercorsoRemoto(cls,percorso:str):
+		return cls.normalizzaSlashPath(percorso)
+
+	@classmethod
+	def rinominaConTimestamp(cls,nomefile:str):
+		nomefileSenzaEstensione,ext=cls.getBaseFileNameAndExtension(nomefile)
+		nomefileNew=nomefileSenzaEstensione+"_"+ModuloDate.dateToString(None, ModuloDate.FORMATO_DATA_ORA_NOMEFILE)+ext
+		os.rename(nomefile,nomefileNew)
+
+	@staticmethod
+	def sposta(sourceFilename:str,destFilename:str):
+		shutil.move(sourceFilename,destFilename)
+
+	@staticmethod
+	def copia(sourceFilename:str,destFilename:str):
+		try:
+			shutil.copy2(sourceFilename,destFilename)
+		except Exception:
+			raise EccezioneRuntime("Errore copia file "+sourceFilename+" in "+destFilename)
+
+	@classmethod
+	def eliminaContenutoCartella(cls,percorso:str):
+		"""
+		elimina tutto il contenuto di una cartella ma non la cartella
+		"""
+		for root,dirs,nomefiles in os.walk(percorso):
+			for nomefile in nomefiles:
+				os.unlink(cls.pathJoin(root, nomefile))
+			for cartella in dirs:
+				shutil.rmtree(cls.pathJoin(root, cartella))
+
+	@staticmethod
+	def deleteByPattern(pattern:str):
+		filesDaElim=glob.glob(pattern)
+		for fileDaElim in filesDaElim:
+			os.remove(fileDaElim)
+
+	@staticmethod
+	def getBaseFileNameAndExtension(nomefile:str)->tuple:
+		arr=nomefile.split(".")
+		nomefileSenzaEstensione=".".join(arr[0:-1])
+		ext="."+arr[-1]
+		return nomefileSenzaEstensione,ext
+
+	@classmethod
+	def walk(cls,root:str,excludeFiles:list|tuple,excludeDirs:list|tuple,minByteSize:int|None,maxByteSize:int|None):
+		"""
+		Questa funzione e' uguale a os.walk() ma restituisce anche il path relativo oltre a quello assoluto.
+		"""
+		root=cls.normalizzaPercorsoLocale(root)
+		for result in os.walk(root):
+			yield from cls.__walk(root,excludeFiles,excludeDirs,minByteSize,maxByteSize,result)
+			
+	@classmethod
+	def __walk(cls,root: str,excludeFiles: list|tuple,excludeDirs: list|tuple,minByteSize: int|None,maxByteSize: int|None,
+			result:tuple[str, list[str], list[str]]):
+		percorso,dirs,nomefiles=result
+		percorsoRel=cls.pathAbsToRel(percorso,root)
+		# elaboro i file
+		for index,nomefile in enumerate(nomefiles):
+			nomefileRelPath=cls.pathJoin(percorsoRel,nomefile)
+			# escludo i file che sono nella blacklist
+			if nomefileRelPath in excludeFiles:
+				nomefiles[index]=""
+				continue
+			# controllo dimensione file
+			if maxByteSize is not None or minByteSize is not None:
+				bytesFile=cls.getFileSize(cls.pathJoin(root,nomefileRelPath))
+				if(maxByteSize is not None and bytesFile>maxByteSize) or (minByteSize is not None and bytesFile<minByteSize):
+					nomefiles[index]=""
+		nomefiles=ModuloListe.eliminaElementiVuoti(nomefiles)
+		#elaboro le cartelle
+		for index,cartella in enumerate(dirs):
+			cartellaRelPath=cls.normalizzaPercorsoRemoto(cls.pathJoin(percorsoRel,cartella))
+			#escludo le cartelle che sono nella blacklist
+			if cartellaRelPath in excludeDirs:
+				dirs[index]=""
+		dirs=ModuloListe.eliminaElementiVuoti(dirs)
+		yield percorsoRel,percorso,dirs,nomefiles

modulitiz_micro/files/ModuloLogging.py

@@ -1,69 +1,69 @@
-import logging
-import os
-import sys
-
-from modulitiz_micro.ModuloDate import ModuloDate
-from modulitiz_micro.files.ModuloFiles import ModuloFiles
-
-
-class ModuloLogging(logging.Logger):
-	CARTELLA_LOG="logs"
-	NOMEFILE_PREFIX="log"
-	NOMEFILE_EXT=".txt"
-	# dimensione massima del file di log in byte
-	MAX_FILE_SIZE=10*1024*1024
-	
-	def __init__(self,nomefileFullPath:str|None=None,cartellaBase:str|None=None,isDebug:bool=False):
-		super().__init__("modulitiz")
-		logFormatterConsole = self.__getOutputFormatter(False)
-		logLevel=logging.INFO if not isDebug else logging.DEBUG
-		# imposto livello
-		self.setLevel(logLevel)
-		# creo console logger
-		consoleHandler=logging.StreamHandler(sys.stdout)
-		consoleHandler.setLevel(logLevel)
-		consoleHandler.setFormatter(logFormatterConsole)
-		self.addHandler(consoleHandler)
-		# creo file logger
-		self.__addFileHandler(nomefileFullPath,cartellaBase,isDebug)
-	
-	def close(self):
-		self.handlers.clear()
-	
-	@staticmethod
-	def exceptionToString(eccezione)->str:
-		formatter=logging.Formatter()
-		lastEccezione=sys.exc_info()
-		try:
-			msg=formatter.formatException(eccezione)
-		except TypeError:
-			msg=formatter.formatException(lastEccezione)
-		return msg
-	
-	@staticmethod
-	def __getOutputFormatter(isDebug:bool)->logging.Formatter:
-		formato='%(asctime)s '+('[%(filename)s:%(lineno)s]\t' if isDebug is True else '')+'[%(levelname)s]\t%(message)s'
-		return logging.Formatter(formato)
-	
-	def __addFileHandler(self,nomefileFullPath:str|None,cartellaBase:str|None,isDebug:bool):
-		# controllo se loggare anche su file
-		if nomefileFullPath is None and cartellaBase is None:
-			return
-		# controllo che la cartella dei log esista
-		if cartellaBase is None:
-			cartellaBase=self.CARTELLA_LOG
-		else:
-			cartellaBase=ModuloFiles.pathJoin(cartellaBase,self.CARTELLA_LOG)
-		if not os.path.exists(cartellaBase):
-			os.makedirs(cartellaBase,exist_ok=True)
-		
-		# creo il nome del file
-		if nomefileFullPath is None:
-			nomefileFullPath=ModuloFiles.pathJoin(cartellaBase,self.NOMEFILE_PREFIX+self.NOMEFILE_EXT)
-		# se il file e' troppo grande ne creo uno nuovo
-		if ModuloFiles.getFileSize(nomefileFullPath)>=self.MAX_FILE_SIZE:
-			os.rename(nomefileFullPath,nomefileFullPath+"_"+ModuloDate.dateToString(None,ModuloDate.FORMATO_DATA_ORA_NOMEFILE))
-		# file handler
-		fileHandler=logging.FileHandler(nomefileFullPath)
-		fileHandler.setFormatter(self.__getOutputFormatter(isDebug))
-		self.addHandler(fileHandler)
+import logging
+import os
+import sys
+
+from modulitiz_micro.ModuloDate import ModuloDate
+from modulitiz_micro.files.ModuloFiles import ModuloFiles
+
+
+class ModuloLogging(logging.Logger):
+	CARTELLA_LOG="logs"
+	NOMEFILE_PREFIX="log"
+	NOMEFILE_EXT=".txt"
+	# dimensione massima del file di log in byte
+	MAX_FILE_SIZE=10*1024*1024
+	
+	def __init__(self,nomefileFullPath:str|None=None,cartellaBase:str|None=None,isDebug:bool=False):
+		super().__init__("modulitiz")
+		logFormatterConsole = self.__getOutputFormatter(False)
+		logLevel=logging.INFO if not isDebug else logging.DEBUG
+		# imposto livello
+		self.setLevel(logLevel)
+		# creo console logger
+		consoleHandler=logging.StreamHandler(sys.stdout)
+		consoleHandler.setLevel(logLevel)
+		consoleHandler.setFormatter(logFormatterConsole)
+		self.addHandler(consoleHandler)
+		# creo file logger
+		self.__addFileHandler(nomefileFullPath,cartellaBase,isDebug)
+	
+	def close(self):
+		self.handlers.clear()
+	
+	@staticmethod
+	def exceptionToString(eccezione)->str:
+		formatter=logging.Formatter()
+		lastEccezione=sys.exc_info()
+		try:
+			msg=formatter.formatException(eccezione)
+		except TypeError:
+			msg=formatter.formatException(lastEccezione)
+		return msg
+	
+	@staticmethod
+	def __getOutputFormatter(isDebug:bool)->logging.Formatter:
+		formato='%(asctime)s '+('[%(filename)s:%(lineno)s]\t' if isDebug is True else '')+'[%(levelname)s]\t%(message)s'
+		return logging.Formatter(formato)
+	
+	def __addFileHandler(self,nomefileFullPath:str|None,cartellaBase:str|None,isDebug:bool):
+		# controllo se loggare anche su file
+		if nomefileFullPath is None and cartellaBase is None:
+			return
+		# controllo che la cartella dei log esista
+		if cartellaBase is None:
+			cartellaBase=self.CARTELLA_LOG
+		else:
+			cartellaBase=ModuloFiles.pathJoin(cartellaBase,self.CARTELLA_LOG)
+		if not os.path.exists(cartellaBase):
+			os.makedirs(cartellaBase,exist_ok=True)
+		
+		# creo il nome del file
+		if nomefileFullPath is None:
+			nomefileFullPath=ModuloFiles.pathJoin(cartellaBase,self.NOMEFILE_PREFIX+self.NOMEFILE_EXT)
+		# se il file e' troppo grande ne creo uno nuovo
+		if ModuloFiles.getFileSize(nomefileFullPath)>=self.MAX_FILE_SIZE:
+			os.rename(nomefileFullPath,nomefileFullPath+"_"+ModuloDate.dateToString(None,ModuloDate.FORMATO_DATA_ORA_NOMEFILE))
+		# file handler
+		fileHandler=logging.FileHandler(nomefileFullPath)
+		fileHandler.setFormatter(self.__getOutputFormatter(isDebug))
+		self.addHandler(fileHandler)

modulitiz_micro/files/ModuloZip.py

@@ -1,42 +1,42 @@
-import os
-import zipfile
-
-from modulitiz_micro.ModuloStringhe import ModuloStringhe
-from modulitiz_micro.files.ModuloFiles import ModuloFiles
-
-
-class ModuloZip(object):
-	
-	@classmethod
-	def zip(cls,dirIn: str,fileOut: str,includeRootDir: bool):
-		fh=zipfile.ZipFile(fileOut,'w',zipfile.ZIP_DEFLATED)
-		if not os.path.isfile(dirIn):
-			cls.__fromFolder(fh,dirIn,includeRootDir)
-		else:
-			fh.write(dirIn)
-		fh.close()
-	
-	@staticmethod
-	def unzip(fileIn: str,dirOut: str|None = None):
-		if dirOut is None:
-			dirOut="./"
-		elif dirOut=="":
-			dirOut=fileIn.split("/")[-1].split(".")[0]
-		zipRef=zipfile.ZipFile(fileIn,'r')
-		zipRef.extractall(dirOut)
-		zipRef.close()
-	
-	@staticmethod
-	def __fromFolder(fh,dirIn: str,includeRootDir: bool):
-		pathOutRootRel=os.path.basename(dirIn) if includeRootDir else ""
-		for pathRel,pathAbs,cartelle,nomefiles in ModuloFiles.walk(dirIn,(),(),None,None):
-			# controllo se devo scrivere anche la cartella principale
-			if not ModuloStringhe.isEmpty(pathOutRootRel):
-				pathOutRel=ModuloFiles.pathJoin(pathOutRootRel,pathRel)
-				fh.write(pathAbs,pathOutRel)
-			else:
-				pathOutRel=pathRel
-			for nomefile in nomefiles:
-				percorsoFile=ModuloFiles.pathJoin(pathAbs,nomefile)
-				percorsoFileRel=ModuloFiles.pathJoin(pathOutRel,nomefile)
-				fh.write(percorsoFile,percorsoFileRel)
+import os
+import zipfile
+
+from modulitiz_micro.ModuloStringhe import ModuloStringhe
+from modulitiz_micro.files.ModuloFiles import ModuloFiles
+
+
+class ModuloZip(object):
+	
+	@classmethod
+	def zip(cls,dirIn: str,fileOut: str,includeRootDir: bool):
+		fh=zipfile.ZipFile(fileOut,'w',zipfile.ZIP_DEFLATED)
+		if not os.path.isfile(dirIn):
+			cls.__fromFolder(fh,dirIn,includeRootDir)
+		else:
+			fh.write(dirIn)
+		fh.close()
+	
+	@staticmethod
+	def unzip(fileIn: str,dirOut: str|None = None):
+		if dirOut is None:
+			dirOut="./"
+		elif dirOut=="":
+			dirOut=fileIn.split("/")[-1].split(".")[0]
+		zipRef=zipfile.ZipFile(fileIn,'r')
+		zipRef.extractall(dirOut)
+		zipRef.close()
+	
+	@staticmethod
+	def __fromFolder(fh,dirIn: str,includeRootDir: bool):
+		pathOutRootRel=os.path.basename(dirIn) if includeRootDir else ""
+		for pathRel,pathAbs,dirs,nomefiles in ModuloFiles.walk(dirIn,(),(),None,None):
+			# controllo se devo scrivere anche la cartella principale
+			if not ModuloStringhe.isEmpty(pathOutRootRel):
+				pathOutRel=ModuloFiles.pathJoin(pathOutRootRel,pathRel)
+				fh.write(pathAbs,pathOutRel)
+			else:
+				pathOutRel=pathRel
+			for nomefile in nomefiles:
+				percorsoFile=ModuloFiles.pathJoin(pathAbs,nomefile)
+				percorsoFileRel=ModuloFiles.pathJoin(pathOutRel,nomefile)
+				fh.write(percorsoFile,percorsoFileRel)

modulitiz_micro/files/cache/CacheBean.py

@@ -1,5 +1,5 @@
-class CacheBean(object):
-	def __init__(self,valore,dataLastUpdate):
-		self.valore=valore
-		self.dataLastUpdate=dataLastUpdate
-	
+class CacheBean(object):
+	def __init__(self,valore,dataLastUpdate):
+		self.valore=valore
+		self.dataLastUpdate=dataLastUpdate
+	

modulitiz_micro/files/cache/CacheRam.py

@@ -1,29 +1,29 @@
-from modulitiz_micro.ModuloDate import ModuloDate
-from modulitiz_micro.ModuloListe import ModuloListe
-from modulitiz_micro.files.cache.CacheBean import CacheBean
-
-
-class CacheRam(object):
-	def __init__(self):
-		self.__mappa={}
-	
-	def get(self,tipo: str,chiave: str,minsBeforeExpiry: int|None) -> CacheBean|None:
-		# controllo se esiste in ram
-		bean: CacheBean=ModuloListe.collectionSafeGet(self.__mappa,tipo,chiave)
-		if bean is None:
-			return None
-		# controllo se non e' scaduto
-		if minsBeforeExpiry is not None and ModuloDate.now()>ModuloDate.plusMinusMinutes(bean.dataLastUpdate,minsBeforeExpiry):
-			del self.__mappa[tipo][chiave]
-			return None
-		return bean
-	
-	def insertOrUpdate(self,tipo: str,chiave: str,valore):
-		if tipo not in self.__mappa:
-			self.__mappa[tipo]={}
-		if chiave not in self.__mappa[tipo]:
-			self.__mappa[tipo][chiave]={}
-		self.__mappa[tipo][chiave]=CacheBean(valore,ModuloDate.now())
-	
-	def clear(self):
-		self.__mappa.clear()
+from modulitiz_micro.ModuloDate import ModuloDate
+from modulitiz_micro.ModuloListe import ModuloListe
+from modulitiz_micro.files.cache.CacheBean import CacheBean
+
+
+class CacheRam(object):
+	def __init__(self):
+		self.__mappa={}
+	
+	def get(self,tipo: str,chiave: str,minsBeforeExpiry: int|None) -> CacheBean|None:
+		# controllo se esiste in ram
+		bean: CacheBean=ModuloListe.collectionSafeGet(self.__mappa,tipo,chiave)
+		if bean is None:
+			return None
+		# controllo se non e' scaduto
+		if minsBeforeExpiry is not None and ModuloDate.now()>ModuloDate.plusMinusMinutes(bean.dataLastUpdate,minsBeforeExpiry):
+			del self.__mappa[tipo][chiave]
+			return None
+		return bean
+	
+	def insertOrUpdate(self,tipo: str,chiave: str,valore):
+		if tipo not in self.__mappa:
+			self.__mappa[tipo]={}
+		if chiave not in self.__mappa[tipo]:
+			self.__mappa[tipo][chiave]={}
+		self.__mappa[tipo][chiave]=CacheBean(valore,ModuloDate.now())
+	
+	def clear(self):
+		self.__mappa.clear()