scilens 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

scilens/components/compare_2_files.py

@@ -1,22 +1,26 @@
 import os
 from scilens.run.task_context import TaskContext
+from scilens.readers.reader_interface import ReaderInterface
 from scilens.components.file_reader import FileReader
-from scilens.components.compare_errors import CompareErrors,SEVERITY_ERROR
+from scilens.components.compare_models import SEVERITY_ERROR
+from scilens.components.compare_errors import CompareErrors
 from scilens.components.compare_floats import CompareFloats
 class Compare2Files:
 	def __init__(A,context):A.context=context
 	def compare(B,path_test,path_ref):
-		Q='comparison_errors';P='comparison';M='reader';J='error';I='ref';H='test';E='path';A={H:{},I:{},P:None,Q:None};D={H:{E:path_test},I:{E:path_ref}}
-		for(K,F)in D.items():
-			if not F.get(E)or not os.path.exists(F[E]):A[J]=f"file {K} does not exist";return A
-		R=FileReader(B.context.working_dir,B.context.config.file_reader,B.context.config.readers,config_alternate_path=B.context.origin_working_dir)
-		for(K,F)in D.items():D[K][M]=R.read(F[E])
-		C=D[H][M];G=D[I][M]
-		if not C or not G:A['skipped']=True;return A
-		A[H]=C.info();A[I]=G.info()
-		if C.read_error:A[J]=C.read_error;return A
-		L=CompareErrors(B.context.config.compare.errors_limit,B.context.config.compare.ignore_warnings);N,S=C.compare(CompareFloats(L,B.context.config.compare.float_thresholds),G,param_is_ref=True);A[P]=S;A[Q]=L.get_data()
-		if N:A[J]=N;return A
-		C.close();G.close();O=len(L.errors[SEVERITY_ERROR])
-		if O>0:T=f"{O} comparison errors";A[J]=T
+		R='comparison_errors';Q='comparison';N='reader';L='error';K='ref';J='test';F='path';A={J:{},K:{},Q:None,R:None};D={J:{F:path_test},K:{F:path_ref}}
+		for(M,G)in D.items():
+			if not G.get(F)or not os.path.exists(G[F]):A[L]=f"file {M} does not exist";return A
+		S=FileReader(B.context.working_dir,B.context.config.file_reader,B.context.config.readers,config_alternate_path=B.context.origin_working_dir)
+		for(M,G)in D.items():D[M][N]=S.read(G[F])
+		C=D[J][N];H=D[K][N]
+		if not C or not H:A['skipped']=True;return A
+		A[J]=C.info();A[K]=H.info()
+		if C.read_error:A[L]=C.read_error;return A
+		I=CompareErrors(B.context.config.compare.errors_limit,B.context.config.compare.ignore_warnings);T=CompareFloats(I,B.context.config.compare.float_thresholds);C.compare(T,H,param_is_ref=True);E=I.root_group;O={'total_diffs':E.total_diffs}
+		if E.info:O.update(E.info)
+		A[Q]=O;A[R]=I.get_data()
+		if E.error:A[L]=E.error;return A
+		C.close();H.close();P=len(I.errors[SEVERITY_ERROR])
+		if P>0:U=f"{P} comparison errors";A[L]=U
 		return A

scilens/components/compare_errors.py

@@ -1,22 +1,23 @@
 _B=False
 _A=None
-from pydantic import BaseModel
-class CompareGroup(BaseModel):name:str;data:dict|_A
-class CompareErrFloats(BaseModel):is_relative:bool;value:float;test:float;reference:float
-class CompareErr(BaseModel):err:CompareErrFloats|_A;msg:int;group:int|_A=_A;info:dict|_A=_A
-SEVERITY_ERROR='error'
-SEVERITY_WARNING='warning'
+from dataclasses import asdict
+from.compare_models import SEVERITY_ERROR,SEVERITY_WARNING,COMPARE_GROUP_TYPE,CompareGroup,CompareFloatsErr,CompareErr,Compare2ValuesResults
 class CompareErrors:
-	def __init__(A,nb_max,ignore_warnings=_B):A.nb_max=nb_max;A.ignore_warnings=ignore_warnings;A.errors={SEVERITY_ERROR:[],SEVERITY_WARNING:[]};A.count=0;A.limit_reached=_B;A.messages=[];A.messages_map={};A.groups=[]
-	def add_group(A,name,data=_A):B=len(A.groups);A.groups.append(CompareGroup(name=name,data=data));return B
-	def add(A,severity,message,comp_err,group_idx=_A,info=_A):
-		D=severity;C=message
+	def __init__(A,nb_max,ignore_warnings=_B):A.nb_max=nb_max;A.ignore_warnings=ignore_warnings;A.errors={SEVERITY_ERROR:[],SEVERITY_WARNING:[]};A.count=0;A.limit_reached=_B;A.root_group=_A;A.messages=[];A._messages_map={};A.groups=[]
+	def add_group(A,type,name,parent=_A,data=_A):
+		B=parent
+		if not A.root_group and B:raise Exception('No root group defined')
+		id=len(A.groups);C=CompareGroup(id=id,type=type,name=name,parent=B,data=data)
+		if not B:A.root_group=C
+		A.groups.append(C);return id,C
+	def add(A,group,comp_res,info=_A):
+		F=group;C=comp_res;D=C.severity;E=C.message;G=C.comp_err
 		if A.ignore_warnings and D==SEVERITY_WARNING:return _B
-		A.count+=1;B=A.messages_map.get(C)
-		if B is _A:B=len(A.messages);A.messages.append(C);A.messages_map[C]=B
-		A.errors[D].append(CompareErr(err=comp_err,msg=B,group=group_idx,info=info))
+		A.count+=1;B=A._messages_map.get(E)
+		if B is _A:B=len(A.messages);A.messages.append(E);A._messages_map[E]=B
+		A.errors[D].append(CompareErr(err=G,msg=B,group=F.id,info=info));F.incr(D)
 		if A.count>=A.nb_max:A.limit_reached=True;return True
 	def get_data(B):
-		A={'messages':B.messages,'groups':[A.model_dump()for A in B.groups]}
-		for(C,D)in B.errors.items():A[C]=[A.model_dump()for A in D];A[C+'_nb']=len(A[C])
+		D=[{'id':A.id,'type':A.type,'name':A.name,'error':A.error,'total_diffs':A.total_diffs,'total_warnings':A.total_warnings,'total_errors':A.total_errors,'data':A.data,'info':A.info,'parent_id':A.parent.id if A.parent else _A}for A in B.groups];A={'messages':B.messages,'groups':D}
+		for(C,E)in B.errors.items():A[C]=[A.model_dump()for A in E];A[C+'_nb']=len(A[C])
 		return A

scilens/components/compare_floats.py

@@ -1,50 +1,72 @@
-_B='amplitude'
+_C='amplitude'
+_B=False
 _A=None
-from scilens.components.compare_errors import CompareErrors,SEVERITY_ERROR,SEVERITY_WARNING,CompareErrFloats
+from scilens.components.compare_models import SEVERITY_ERROR,SEVERITY_WARNING,CompareFloatsErr,Compare2ValuesResults
+from scilens.components.compare_errors import CompareErrors
 from scilens.config.models import CompareFloatThresholdsConfig
 try:from scilens_compare import vectors as CheckVectors
 except ModuleNotFoundError:pass
-def vector_get_amplitude(vector):min_val=min(vector);max_val=max(vector);return{'min':min_val,'max':max_val,_B:abs(max_val-min_val)}
+def vector_get_amplitude(vector):min_val=min(vector);max_val=max(vector);return{'min':min_val,'max':max_val,_C:abs(max_val-min_val)}
 class CompareFloats:
 	def __init__(self,compare_errors,config):self.compare_errors=compare_errors;self.thresholds=config
-	def compare_vectors(self,test_vector,reference_vector,group_idx=_A,info_vector=_A):
-		A='ignore';diffs_count=0;counts={SEVERITY_ERROR:0,SEVERITY_WARNING:0};err_limit_reached=False;amplitude_compare=_A
-		if self.thresholds.vectors and self.thresholds.vectors.ponderation_method=='amplitude_moderation':amplitude=vector_get_amplitude(test_vector)[_B];amplitude_compare=amplitude*self.thresholds.vectors.amplitude_moderation_multiplier;reduction_method=self.thresholds.vectors.reduction_method
+	def compare_2_values(self,test,reference):
+		thr=self.thresholds;sign=-1 if test-reference<0 else 1
+		if abs(test)>thr.relative_vs_absolute_min and reference!=0:
+			err=abs(test-reference)/abs(reference);comp_err=CompareFloatsErr(is_relative=True,value=sign*err,test=test,reference=reference)
+			if err<thr.relative_error_max:
+				if err>thr.relative_error_min:return Compare2ValuesResults(SEVERITY_WARNING,f"Rel. err. > {thr.relative_error_min} and < {thr.relative_error_max}",comp_err)
+			else:return Compare2ValuesResults(SEVERITY_ERROR,f"Rel. err. > {thr.relative_error_max}",comp_err)
+		else:
+			err=abs(test-reference);comp_err=CompareFloatsErr(is_relative=_B,value=sign*err,test=test,reference=reference)
+			if err<thr.absolute_error_max:
+				if err>thr.absolute_error_min:return Compare2ValuesResults(SEVERITY_WARNING,f"Abs. err. > {thr.absolute_error_min} and < {thr.absolute_error_max}",comp_err)
+			else:return Compare2ValuesResults(SEVERITY_ERROR,f"Abs. err. > {thr.absolute_error_max}",comp_err)
+	def compare_vectors(self,test_vector,reference_vector,group_id,info_vector=_A):
+		B='ignore';A='RIAE_trapezoid';group=self.compare_errors.groups[group_id]
+		if len(test_vector)!=len(reference_vector):raise Exception('Vectors have different lengths')
+		diffs_count=0;err_limit_reached=_B;ponderation_method=self.thresholds.vectors.ponderation_method
+		if ponderation_method=='RIAE':ponderation_method=A
+		amplitude_compare=_A
+		if self.thresholds.vectors and ponderation_method=='amplitude_moderation':amplitude=vector_get_amplitude(test_vector)[_C];amplitude_compare=amplitude*self.thresholds.vectors.amplitude_moderation_multiplier;reduction_method=self.thresholds.vectors.reduction_method
 		RIAE_force_severity=_A
-		if self.thresholds.vectors and self.thresholds.vectors.ponderation_method in['RIAE','RIAE_trapezoid','RIAE_midpoint']:
+		if self.thresholds.vectors and ponderation_method in[A,'RIAE_midpoint']:
 			RIAE_force_severity=self.thresholds.vectors.reduction_method
 			if'CheckVectors'not in globals():raise Exception('scilens_compare not found. Please install scilens-compare package with `pip install scilens-compare`.')
-			riae_error=CheckVectors.relative_integral_absolute_error_trapezoid(reference_vector,test_vector,range(len(test_vector)));riae_error=CheckVectors.relative_integral_absolute_error_midpoint(reference_vector,test_vector,range(len(test_vector)));print('riae_error');print(riae_error)
-			if riae_error<self.thresholds.vectors.riae_threshold:RIAE_force_severity=self.thresholds.vectors.reduction_method
-			else:0
+			riae_error=CheckVectors.relative_integral_absolute_error_trapezoid(reference_vector,test_vector,range(len(test_vector)))if ponderation_method==A else CheckVectors.relative_integral_absolute_error_midpoint(reference_vector,test_vector,range(len(test_vector)))
+			if riae_error>self.thresholds.vectors.riae_threshold:ee=CompareFloatsErr(is_relative=_B,value=riae_error);res_compare=Compare2ValuesResults(SEVERITY_ERROR,f"RIAE ({ponderation_method}) > {self.thresholds.vectors.riae_threshold}",ee);err_limit_reached=self.compare_errors.add(group,res_compare)
 		nb=len(test_vector)
 		for idx in range(nb):
 			diff=test_vector[idx]-reference_vector[idx]
 			if diff==0:continue
-			else:diffs_count+=1
+			else:diffs_count+=1;group.incr('diff')
 			if err_limit_reached:continue
-			if RIAE_force_severity==A:continue
+			if RIAE_force_severity==B:continue
 			if amplitude_compare is not _A and abs(diff)<amplitude_compare:
-				if reduction_method==A:continue
-				elif reduction_method=='soften':severity,message,comp_err=self.compare_2_values(test_vector[idx],reference_vector[idx]);severity=SEVERITY_WARNING
+				if reduction_method==B:continue
+				elif reduction_method=='soften':
+					res_compare=self.compare_2_values(test_vector[idx],reference_vector[idx])
+					if res_compare:res_compare.severity=SEVERITY_WARNING
 			else:
-				severity,message,comp_err=self.compare_2_values(test_vector[idx],reference_vector[idx])
-				if RIAE_force_severity:severity=SEVERITY_WARNING
-			if comp_err:
-				counts[severity]+=1;info={'index':idx}
+				res_compare=self.compare_2_values(test_vector[idx],reference_vector[idx])
+				if res_compare and RIAE_force_severity:res_compare.severity=SEVERITY_WARNING
+			if res_compare:
+				info={'index':idx}
 				if info_vector:info['info']=info_vector[idx]
-				err_limit_reached=self.compare_errors.add(severity,message,comp_err,group_idx=group_idx,info=info)
-		return err_limit_reached,diffs_count,counts
-	def compare_2_values(self,test,reference):
-		thr=self.thresholds;sign=-1 if test-reference<0 else 1
-		if abs(test)>thr.relative_vs_absolute_min and reference!=0:
-			err=abs(test-reference)/abs(reference);comp_err=CompareErrFloats(is_relative=True,value=sign*err,test=test,reference=reference)
-			if err<thr.relative_error_max:
-				if err>thr.relative_error_min:return SEVERITY_WARNING,f"Rel. err. > {thr.relative_error_min} and < {thr.relative_error_max}",comp_err
-			else:return SEVERITY_ERROR,f"Rel. err. > {thr.relative_error_max}",comp_err
-		else:
-			err=abs(test-reference);comp_err=CompareErrFloats(is_relative=False,value=sign*err,test=test,reference=reference)
-			if err<thr.absolute_error_max:
-				if err>thr.absolute_error_min:return SEVERITY_WARNING,f"Abs. err. > {thr.absolute_error_min} and < {thr.absolute_error_max}",comp_err
-			else:return SEVERITY_ERROR,f"Abs. err. > {thr.absolute_error_max}",comp_err
-		return _A,_A,_A
+				err_limit_reached=self.compare_errors.add(group,res_compare,info=info)
+		return err_limit_reached,diffs_count
+	def compare_matrices(self,test_mat,ref_mat,group_id,x_vector=_A,y_vector=_A):
+		group=self.compare_errors.groups[group_id];info={};diffs_count=0;err_limit_reached=_B;test_nb_lines=len(test_mat);test_nb_columns=len(test_mat[0])if test_nb_lines>0 else 0;ref_nb_lines=len(ref_mat);ref_nb_columns=len(ref_mat[0])if ref_nb_lines>0 else 0
+		if test_nb_lines!=ref_nb_lines or test_nb_columns!=ref_nb_columns:raise Exception('Matrices have different dimensions')
+		for i in range(test_nb_lines):
+			for j in range(test_nb_columns):
+				diff=test_mat[i][j]-ref_mat[i][j]
+				if diff==0:continue
+				else:diffs_count+=1
+				if err_limit_reached:continue
+				res_compare=self.compare_2_values(test_mat[i][j],ref_mat[i][j])
+				if res_compare:
+					info={'i':i+1,'j':j+1}
+					if x_vector:info['x']=x_vector[j]
+					if y_vector:info['y']=y_vector[i]
+					err_limit_reached=self.compare_errors.add(group,res_compare,info=info)
+		return err_limit_reached,diffs_count

scilens/components/compare_models.py

@@ -0,0 +1,20 @@
+_A=None
+from dataclasses import dataclass
+from typing import Literal,Optional
+from pydantic import BaseModel
+SEVERITY_ERROR='error'
+SEVERITY_WARNING='warning'
+@dataclass
+class CompareFloatsErr:is_relative:bool;value:float;test:float|_A=_A;reference:float|_A=_A
+@dataclass
+class Compare2ValuesResults:severity:str;message:str;comp_err:CompareFloatsErr|_A=_A
+class CompareErr(BaseModel):err:CompareFloatsErr|_A;msg:int;group:int|_A=_A;info:dict|_A=_A
+COMPARE_GROUP_TYPE=Literal['node','lines','vectors',' matrix']
+@dataclass
+class CompareGroup:
+	id:int;type:COMPARE_GROUP_TYPE;name:str;parent:Optional['CompareGroup']=_A;error:str|_A=_A;total_diffs:int=0;total_warnings:int=0;total_errors:int=0;data:dict|_A=_A;info:dict|_A=_A
+	def incr(A,type):
+		if type==SEVERITY_ERROR:A.total_errors+=1
+		elif type==SEVERITY_WARNING:A.total_warnings+=1
+		elif type=='diff':A.total_diffs+=1
+		if A.parent is not _A:A.parent.incr(type)

scilens/components/file_reader.py

@@ -3,6 +3,7 @@ import logging,importlib,os
 from scilens.config.models import FileReaderConfig
 from scilens.config.models.readers import ReadersConfig
 from scilens.readers.reader_manager import ReaderManager
+from scilens.readers.reader_interface import ReaderInterface
 from scilens.readers.exceptions import NoReaderFound
 class FileReader:
 	def __init__(A,absolute_working_dir,config,readers_config,config_alternate_path=_A):A.path=absolute_working_dir;A.config_alternate_path=config_alternate_path;A.reader_mgmr=ReaderManager();A.config=config;A.readers_config=readers_config

scilens/config/models/reader_format_csv.py

@@ -1,4 +1,5 @@
 _A=None
 from pydantic import BaseModel,Field
 from scilens.config.models.reader_format_cols_curve import ReaderColsCurveParserConfig
-class ReaderCsvConfig(BaseModel):ignore_columns:list[str]|_A=Field(default=_A,description='Liste des noms des colonnes à ignorer. (Valide seulement si la première ligne est les en-têtes)');delimiter:str|_A=Field(default=',',description='Délimiteur de colonnes.');quotechar:str|_A=Field(default='"',description='Délimiteur de texte.');curve_parser:ReaderColsCurveParserConfig|_A=Field(default=_A,description='Parseur de courbe à utiliser.')
+class ReaderCsvMatrixConfig(BaseModel):x_value_line:int|_A=Field(default=_A,description="Indique la ligne des valeurs x si applicable. Peut être la ligne d'en-tête (=1).");has_y:bool=Field(default=False,description='Indique si la première colonne est ma colonne des valeurs y.')
+class ReaderCsvConfig(BaseModel):delimiter:str|_A=Field(default=',',description='Délimiteur de colonnes.');quotechar:str|_A=Field(default='"',description='Délimiteur de texte.');has_header:bool|_A=Field(default=_A,description="Indique si la 1ère ligne est une ligne d'en-tête. Si non spécifié, il y aura une détection automatique.");is_matrix:bool=Field(default=False,description='Indique si le fichier est une matrice.');ignore_columns:list[str]|_A=Field(default=_A,description='Liste des noms des colonnes à ignorer. (Valide seulement si la première ligne est une ligne en-têtes et non matrice)');curve_parser:ReaderColsCurveParserConfig|_A=Field(default=_A,description='Parseur de courbe à utiliser.');matrix:ReaderCsvMatrixConfig|_A=Field(default=_A,description='Configuration de la matrice. (Valide seulement si `is_matrix` est vrai)')

scilens/readers/cols_dataset.py

@@ -3,7 +3,9 @@ _D='x_index'
 _C='csv_col_index'
 _B='curves'
 _A=None
+import logging
 from dataclasses import dataclass,field
+from scilens.components.compare_models import CompareGroup
 from scilens.components.compare_floats import CompareFloats
 from scilens.config.models.reader_format_cols_curve import ReaderCurveParserNameConfig
 @dataclass
@@ -23,23 +25,23 @@ def cols_dataset_get_curves_col_x(cols_dataset,col_x):
 	E[_D]=C;J=[B for(A,B)in enumerate(A.numeric_col_indexes)if A!=C];F=[];H=[]
 	for D in J:B=A.data[C];K=A.data[D];L={I:A.names[D],'short_title':A.names[D],'series':[[B[A],K[A]]for A in range(A.rows_count)],_C:D};F+=[L];M={I:A.names[D],'type':'simple','xaxis':A.names[C],'yaxis':A.names[D],_B:[len(F)-1]};H+=[M]
 	return{_B:F,_E:H},E
-def compare(compare_floats,reader_test,reader_ref,cols_curve):
-	Q='error';J=compare_floats;I='Errors limit reached';E=reader_ref;C=cols_curve;A=reader_test
-	if len(A.numeric_col_indexes)!=len(E.numeric_col_indexes):R=f"Number Float columns indexes are different: {len(A.numeric_col_indexes)} != {len(E.numeric_col_indexes)}";return R,_A
-	K=0;D=[''for A in range(A.cols_count)];L=_A;F=_A
-	if C and C.type==ReaderCurveParserNameConfig.COL_X:M=C.info[_D];L=A.data[M];F=A.names[M]
-	G=False
+def compare(group,compare_floats,reader_test,reader_ref,cols_curve):
+	L=compare_floats;K='Errors limit reached';G=reader_ref;E=group;C=cols_curve;A=reader_test;logging.debug(f"compare cols: {E.name}")
+	if len(A.numeric_col_indexes)!=len(G.numeric_col_indexes):E.error=f"Number Float columns indexes are different: {len(A.numeric_col_indexes)} != {len(G.numeric_col_indexes)}";return
+	D=[''for A in range(A.cols_count)];M=_A;H=_A
+	if C and C.type==ReaderCurveParserNameConfig.COL_X:N=C.info[_D];M=A.data[N];H=A.names[N]
+	I=False
 	for B in range(A.cols_count):
 		if B not in A.numeric_col_indexes:continue
-		if G:D[B]=I;continue
-		S=A.data[B];T=E.data[B];U=J.compare_errors.add_group(A.names[B],data={'info_prefix':F}if F else _A);V,W,N=J.compare_vectors(S,T,group_idx=U,info_vector=L);K+=W
-		if V:G=True;D[B]=I;continue
-		if N[Q]>0:D[B]=f"{N[Q]} comparison errors"
+		if I:D[B]=K;continue
+		Q=A.data[B];R=G.data[B];U,F=L.compare_errors.add_group('vectors',A.names[B],parent=E,data={'info_prefix':H}if H else _A);logging.debug(f"compare cols: {F.name}");S,V=L.compare_vectors(Q,R,group_id=F.id,info_vector=M)
+		if S:I=True;D[B]=K;continue
+		if F.total_errors>0:D[B]=f"{F.total_errors} comparison errors"
 	if C:
 		for O in C.curves[_E]:
 			P=0
-			for X in O[_B]:
-				H=C.curves[_B][X]
-				if D[H[_C]]:H['comparison_error']=D[H[_C]];P+=1
+			for T in O[_B]:
+				J=C.curves[_B][T]
+				if D[J[_C]]:J['comparison_error']=D[J[_C]];P+=1
 			O['comparison']={'curves_nb_with_error':P}
-	Y=I if G else _A;return Y,{'type':'vectors','total_diffs':K,'cols_has_error':D}
+	E.error=K if I else _A;E.info={'cols_has_error':D}

scilens/readers/mat_dataset.py

@@ -0,0 +1,22 @@
+_A=None
+import csv
+from collections.abc import Iterator
+from dataclasses import dataclass,field
+from scilens.components.compare_models import CompareGroup
+from scilens.components.compare_floats import CompareFloats
+@dataclass
+class MatDataset:nb_lines:int=0;nb_columns:int=0;data:list[list[float]]=field(default_factory=lambda:[]);x_values:list[float]|_A=_A;y_values:list[float]|_A=_A
+def from_reader(reader,x_value_line=_A,has_header=False,has_y=False):
+	E=has_y;D=x_value_line;B=reader;H=_A;I=[]if E else _A;A=[];F=0
+	if D:
+		J=1 if E else 0
+		for M in range(0,D):
+			K=next(B);F+=1
+			if F==D:H=[float(A)for A in K[J:]]
+	if F==0 and has_header:next(B)
+	if E:
+		for C in B:L=float(C[0]);G=[float(A)for A in C[1:]];I.append(L);A.append(G)
+	else:
+		for C in B:G=[float(A)for A in C];A.append(G)
+	return MatDataset(nb_lines=len(A),nb_columns=len(A[0])if len(A)>0 else 0,data=A,x_values=H,y_values=I)
+def compare(parent_group,compare_floats,test,ref,group_name=''):C=compare_floats;B=parent_group;A=test;F,D=C.compare_errors.add_group('matrix',group_name,parent=B);E,G=C.compare_matrices(A.data,ref.data,D.id,x_vector=A.x_values,y_vector=A.y_values);B.error='Errors limit reached'if E else _A

scilens/readers/reader_csv.py

@@ -1,8 +1,11 @@
+_A=None
 import logging,csv
 from scilens.readers.reader_interface import ReaderInterface
-from scilens.readers.cols_dataset import ColsDataset,ColsCurves,cols_dataset_get_curves_col_x,compare
-from scilens.config.models import ReaderCsvConfig
+from scilens.readers.cols_dataset import ColsDataset,ColsCurves,cols_dataset_get_curves_col_x,compare as cols_compare
+from scilens.readers.mat_dataset import MatDataset,from_reader as mat_from_reader,compare as mat_compare
+from scilens.config.models.reader_format_csv import ReaderCsvConfig,ReaderCsvMatrixConfig
 from scilens.config.models.reader_format_cols_curve import ReaderCurveParserNameConfig
+from scilens.components.compare_models import CompareGroup
 from scilens.components.compare_floats import CompareFloats
 def is_num(x):
 	try:return float(x)
@@ -11,30 +14,36 @@ def csv_row_detect_header(first_row):
 	A=first_row
 	if all(not A.isdigit()for A in A):return True,A
 	else:return False,[f"Column {A}"for(A,B)in enumerate(A)]
-def csv_row_detect_cols_num(row):return[A for(A,B)in enumerate(row)if is_num(B)!=None]
-def csv_detect(path,delimiter,quotechar):
-	with open(path,'r')as B:A=csv.reader(B,delimiter=delimiter,quotechar=quotechar);C=next(A);D,E=csv_row_detect_header(C);F=next(A);G=csv_row_detect_cols_num(F);return D,E,G
+def csv_row_detect_cols_num(row):return[A for(A,B)in enumerate(row)if is_num(B)!=_A]
+def csv_detect(path,delimiter,quotechar,encoding):
+	with open(path,'r',encoding=encoding)as B:A=csv.reader(B,delimiter=delimiter,quotechar=quotechar);C=next(A);D,E=csv_row_detect_header(C);F=next(A);G=csv_row_detect_cols_num(F);return D,E,G
 class ReaderCsv(ReaderInterface):
 	configuration_type_code='csv';category='datalines';extensions=['CSV']
 	def read(A,reader_options):
-		C=reader_options;A.reader_options=C;D,E,K=csv_detect(A.origin.path,A.reader_options.delimiter,A.reader_options.quotechar);A.has_header=D;A.cols=E;A.numeric_col_indexes=K
-		if C.ignore_columns:
-			if not D:raise Exception('Ignore columns is not supported without header.')
-			A.numeric_col_indexes=[B for B in A.numeric_col_indexes if A.cols[B]not in C.ignore_columns]
-		H=len(E);B=ColsDataset(cols_count=H,names=E,numeric_col_indexes=A.numeric_col_indexes,data=[[]for A in range(H)]);I=open(A.origin.path,'r',encoding=A.encoding);L=csv.reader(I,delimiter=A.reader_options.delimiter,quotechar=A.reader_options.quotechar);F=0
-		for M in L:
-			F+=1
-			if D and F==1:continue
-			for(J,G)in enumerate(M):
-				if J in B.numeric_col_indexes:G=float(G)
-				B.data[J].append(G)
-			B.origin_line_nb.append(F)
-		B.rows_count=len(B.origin_line_nb);I.close();A.cols_dataset=B;A.raw_lines_number=B.rows_count+(1 if D else 0);A.curves=None
-		if C.curve_parser:
-			if C.curve_parser.name==ReaderCurveParserNameConfig.COL_X:
-				A.curves,N=cols_dataset_get_curves_col_x(B,C.curve_parser.parameters.x)
-				if A.curves:A.cols_curve=ColsCurves(type=ReaderCurveParserNameConfig.COL_X,info=N,curves=A.curves)
-			elif C.curve_parser.name==ReaderCurveParserNameConfig.COLS_COUPLE:raise NotImplementedError('cols_couple not implemented')
-			else:raise Exception('Curve parser not supported.')
-	def compare(A,compare_floats,param_reader,param_is_ref=True):C=param_is_ref;B=param_reader;D=A.cols_dataset if C else B.cols_dataset;E=A.cols_dataset if not C else B.cols_dataset;F=A.cols_curve;return compare(compare_floats,D,E,F)
+		B=reader_options;A.reader_options=B;A.raw_lines_number=_A;A.curves=_A;D,E,M=csv_detect(A.origin.path,A.reader_options.delimiter,A.reader_options.quotechar,encoding=A.encoding);A.has_header=D;A.cols=E;A.numeric_col_indexes=M;H=open(A.origin.path,'r',encoding=A.encoding);I=csv.reader(H,delimiter=A.reader_options.delimiter,quotechar=A.reader_options.quotechar)
+		if B.is_matrix:J=B.matrix or ReaderCsvMatrixConfig();N=mat_from_reader(I,has_header=D,x_value_line=J.x_value_line,has_y=J.has_y);A.mat_dataset=N
+		else:
+			if B.ignore_columns:
+				if not D:raise Exception('Ignore columns is not supported without header.')
+				A.numeric_col_indexes=[C for C in A.numeric_col_indexes if A.cols[C]not in B.ignore_columns]
+			K=len(E);C=ColsDataset(cols_count=K,names=E,numeric_col_indexes=A.numeric_col_indexes,data=[[]for A in range(K)]);F=0
+			for O in I:
+				F+=1
+				if D and F==1:continue
+				for(L,G)in enumerate(O):
+					if L in C.numeric_col_indexes:G=float(G)
+					C.data[L].append(G)
+				C.origin_line_nb.append(F)
+			C.rows_count=len(C.origin_line_nb);A.cols_dataset=C;A.raw_lines_number=C.rows_count+(1 if D else 0)
+			if B.curve_parser:
+				if B.curve_parser.name==ReaderCurveParserNameConfig.COL_X:
+					A.curves,P=cols_dataset_get_curves_col_x(C,B.curve_parser.parameters.x)
+					if A.curves:A.cols_curve=ColsCurves(type=ReaderCurveParserNameConfig.COL_X,info=P,curves=A.curves)
+				elif B.curve_parser.name==ReaderCurveParserNameConfig.COLS_COUPLE:raise NotImplementedError('cols_couple not implemented')
+				else:raise Exception('Curve parser not supported.')
+		H.close()
+	def compare(A,compare_floats,param_reader,param_is_ref=True):
+		H='node';D=param_is_ref;C=param_reader;B=compare_floats;I=A.reader_options
+		if I.is_matrix:E=A.mat_dataset if D else C.mat_dataset;F=A.mat_dataset if not D else C.mat_dataset;J,G=B.compare_errors.add_group(H,'csv matrix');mat_compare(G,B,E,F)
+		else:E=A.cols_dataset if D else C.cols_dataset;F=A.cols_dataset if not D else C.cols_dataset;K=A.cols_curve if hasattr(A,'cols_curve')else _A;J,G=B.compare_errors.add_group(H,'csv cols');cols_compare(G,B,E,F,K)
 	def class_info(A):return{'cols':A.cols,'raw_lines_number':A.raw_lines_number,'curves':A.curves}

scilens/readers/reader_txt.py

@@ -7,7 +7,7 @@ _A=None
 from scilens.readers.reader_interface import ReaderInterface
 from scilens.readers.transform import string_2_floats
 from scilens.config.models import ReaderTxtConfig
-from scilens.components.compare_errors import SEVERITY_ERROR
+from scilens.components.compare_models import SEVERITY_ERROR,Compare2ValuesResults
 from scilens.components.compare_floats import CompareFloats
 class ReaderTxt(ReaderInterface):
 	configuration_type_code='txt';category='datalines';extensions=['TXT']
@@ -42,23 +42,22 @@ class ReaderTxt(ReaderInterface):
 			C,S=A.find_patterns_lines_nb(B.error_rule_patterns);A.read_data['error_rule_patterns']={'found':C,'data':S}
 			if C:A.read_error='String error pattern found'
 	def compare(I,compare_floats,param_reader,param_is_ref=_D):
-		K=param_is_ref;J=param_reader;D=compare_floats;A=I if K else J;B=I if not K else J;E=0;C=_C;Y=[]
-		if A.floats_lines_number!=B.floats_lines_number:T=f"Nb number lines 1: {A.floats_lines_number} 2: {B.floats_lines_number} different";return T,_A
-		L=A.floats_lines;U=B.floats_lines
-		for M in range(len(L)):
-			F=L[M];G=U[M];H=F[_F];N=G[_F];O={'line_nb_1':F[_B],'line_nb_2':G[_B],'line_1':A.get_raw_lines(F[_B]),'line_2':B.get_raw_lines(G[_B])}
-			if len(H)!=len(N):
-				if not C:E+=1;C=D.compare_errors.add(SEVERITY_ERROR,'Not same numbers number in the lines',_A,info=O)
+		U='diff';K=param_is_ref;J=param_reader;A=compare_floats;V,L=A.compare_errors.add_group('node','txt');V,B=A.compare_errors.add_group(_E,_E,parent=L);C=I if K else J;D=I if not K else J;E=_C
+		if C.floats_lines_number!=D.floats_lines_number:L.error=f"Nb number lines 1: {C.floats_lines_number} 2: {D.floats_lines_number} different"
+		M=C.floats_lines;W=D.floats_lines
+		for N in range(len(M)):
+			F=M[N];G=W[N];H=F[_F];O=G[_F];P={'line_nb_1':F[_B],'line_nb_2':G[_B],'line_1':C.get_raw_lines(F[_B]),'line_2':D.get_raw_lines(G[_B])}
+			if len(H)!=len(O):
+				if not E:B.incr(U);E=A.compare_errors.add(B,Compare2ValuesResults(SEVERITY_ERROR,'Not same numbers number in the lines'),info=P)
 				continue
-			for P in range(len(H)):
-				Q=H[P];R=N[P];V=Q-R
-				if V==0:continue
+			for Q in range(len(H)):
+				R=H[Q];S=O[Q];X=R-S
+				if X==0:continue
 				else:
-					E+=1
-					if not C:
-						W,X,S=D.compare_2_values(Q,R)
-						if S:C=D.compare_errors.add(W,X,S,info=O)
-		return _A,{'type':_E,'total_diffs':E}
+					B.incr(U)
+					if not E:
+						T=A.compare_2_values(R,S)
+						if T:E=A.compare_errors.add(B,T,info=P)
 	def find_patterns_lines_nb(D,patterns):
 		A=patterns;B=_C;map={A:[]for A in A}
 		for(E,F)in enumerate(D.raw_lines):

scilens/readers/reader_txt_fixed_cols.py

@@ -34,5 +34,5 @@ class ReaderTxtFixedCols(ReaderInterface):
 				if B.curves:B.cols_curve=ColsCurves(type=ReaderCurveParserNameConfig.COL_X,info=T,curves=B.curves)
 			elif A.curve_parser.name==ReaderCurveParserNameConfig.COLS_COUPLE:raise NotImplementedError('cols_couple not implemented')
 			else:raise Exception('Curve parser not supported.')
-	def compare(A,compare_floats,param_reader,param_is_ref=True):C=param_is_ref;B=param_reader;D=A.cols_dataset if C else B.cols_dataset;E=A.cols_dataset if not C else B.cols_dataset;F=A.cols_curve;return compare(compare_floats,D,E,F)
+	def compare(A,compare_floats,param_reader,param_is_ref=True):D=param_is_ref;C=param_reader;B=compare_floats;E=A.cols_dataset if D else C.cols_dataset;F=A.cols_dataset if not D else C.cols_dataset;G=A.cols_curve;I,H=B.compare_errors.add_group('node','txt cols');return compare(H,B,E,F,G)
 	def class_info(A):return{'cols':A.cols_dataset.names,'raw_lines_number':A.raw_lines_number,'curves':A.curves}

scilens/report/templates/compare_13_section_numbers.html

@@ -1,93 +1,12 @@
 {% if file.comparison_errors %}
-{% set errs = file.comparison_errors %}
-{% set c_type = file.comparison.type %}
-<table>
-  <tr>
-    <th class="p-2" colspan="6">Error</th>
-    <th class="p-2" colspan="99">Source</th>
-  </tr>
-  <tr>
-    <th class="p-2" rowspan="2">Severity</th>
-    <th class="p-2" rowspan="2">Message</th>
-    <th class="p-2" colspan="2">Value</th>
-    <th class="p-2" rowspan="2">Error</th>
-    <th class="p-2" rowspan="2">Visu</th>
+{% for group in file.comparison_errors.groups if group.type != 'node' %}
 
-    {% if c_type == "lines" %}
-    <th class="p-2" colspan="2">Line Number</th>
-    <th class="p-2" colspan="2">Line(s)</th>
-    {% endif %}
+{% if group.total_warnings or group.total_errors %}
 
-    {% if c_type == "vectors" %}
-    <th class="p-2" rowspan="2">Column</th>
-    <th class="p-2" rowspan="2">Index</th>
-    <th class="p-2" rowspan="2">Info</th>
-    {% endif %}
+<h4>{{ group.name }}</h4>
+{% include 'compare_13_section_numbers_table.html' with context %}
 
-  </tr>
-  <tr>
-    <th class="p-2 test-bg-50">Test</th>
-    <th class="p-2 refe-bg-50">Ref.</th>
-    
-    {% if c_type == "lines" %}
-    <th class="p-2 test-bg-50">Test</th>
-    <th class="p-2 refe-bg-50">Ref.</th>
-    <th class="p-2 test-bg-50">Test</th>
-    <th class="p-2 refe-bg-50">Ref.</th>
-    {% endif %}
-
-  </tr>
-
-
-  {% for error_type in [{"data_key": "error", "class": "ERROR"}, {"data_key": "warning", "class": "WARNING"}] %}
-  {% for item in errs[error_type.data_key] %}
-  <tr>
-
-    <td class="{{error_type.class}}">{{error_type.class}}</td>
-    <td>{{ errs.messages[item.msg] }}</td>
-
-    <!-- COMPARISON -->
-
-    <td class="number test-bg-20">{{ item.err.test }}</td>
-    <td class="number refe-bg-20">{{ item.err.reference }}</td>
-    <td class="number">
-      {% if item.err.is_relative %}
-        {{ '%0.2f' % (item.err.value*100)|float}}%
-      {% else %}
-        {{ item.err.value }}
-      {% endif %}
-    </td>
-    <td>
-      {% if item.err.test and item.err.reference %}
-      <div style="width:200px;height:20px">
-        <div class="test-bg-80" style="width:{{100*(item.err.test|abs)/([(item.err.test|abs), (item.err.reference|abs)]|max)}}%;height:10px"></div>
-        <div class="refe-bg-80" style="width:{{100*(item.err.reference|abs)/([(item.err.test|abs), (item.err.reference|abs)]|max)}}%; height:10px"></div>
-      </div>
-      {% endif %}      
-    </td>
-
-
-    {% if c_type == "vectors" %}
-    {% set group = errs.groups[item.group] %}
-    <td>{{ group.name }}</td>
-    <td>{{ item.info.index }}</td>
-    <td>
-      {% if group.data %}
-      {{ group.data.info_prefix + ": " + item.info.info|string }}
-      {% endif %}
-    </td>
-    {% endif %}
-
-    {% if c_type == "lines" %}
-    <td class="test-bg-20 number">{{ item.info.line_nb_1 }}</td>
-    <td class="refe-bg-20 number">{{ item.info.line_nb_2 }}</td>
-    <td class="test-bg-20"><pre>{{ item.info.line_1 }}</pre></td>
-    <td class="refe-bg-20"><pre>{{ item.info.line_2 }}</pre></td>
-    {% endif %}
+{% endif %}
 
-  </tr>
-  {% endfor %}
-  {% endfor %}
-  
-</table>
+{% endfor %}
 {% endif %}

scilens/report/templates/compare_13_section_numbers_table.html

@@ -0,0 +1,99 @@
+{% set comp_errs = file.comparison_errors %}
+<table>
+  <!-- HEADERS -->
+  <tr>
+    <th class="p-2" colspan="6">Error</th>
+    <th class="p-2" colspan="99">Source</th>
+  </tr>
+  <tr>
+    <th class="p-2" rowspan="2">Severity</th>
+    <th class="p-2" rowspan="2">Message</th>
+    <th class="p-2" colspan="2">Value</th>
+    <th class="p-2" rowspan="2">Error</th>
+    <th class="p-2" rowspan="2">Visu</th>
+    {% if group.type == "lines" %}
+    <th class="p-2" colspan="2">Line Number</th>
+    <th class="p-2" colspan="2">Line(s)</th>
+    {% endif %}
+    {% if group.type == "vectors" %}
+    <th class="p-2" rowspan="2">Column</th>
+    <th class="p-2" rowspan="2">Index</th>
+    <th class="p-2" rowspan="2">Info</th>
+    {% endif %}
+    {% if group.type == "matrix" %}
+    <th class="p-2" rowspan="2">i</th>
+    <th class="p-2" rowspan="2">j</th>
+    <th class="p-2" rowspan="2">x</th>
+    <th class="p-2" rowspan="2">y</th>
+    {% endif %}
+  </tr>
+  <tr>
+    <th class="p-2 test-bg-50">Test</th>
+    <th class="p-2 refe-bg-50">Ref.</th>
+    {% if group.type == "lines" %}
+    <th class="p-2 test-bg-50">Test</th>
+    <th class="p-2 refe-bg-50">Ref.</th>
+    <th class="p-2 test-bg-50">Test</th>
+    <th class="p-2 refe-bg-50">Ref.</th>
+    {% endif %}
+  </tr>
+  <!-- BODY -->
+  {% for error_type in [{"data_key": "error", "class": "ERROR"}, {"data_key": "warning", "class": "WARNING"}] %}
+  {% for item in comp_errs[error_type.data_key] if item.group == group.id %}
+  <tr>
+
+    <td class="{{error_type.class}}">{{error_type.class}}</td>
+    <td>{{ comp_errs.messages[item.msg] }}</td>
+
+    <!-- COMPARISON -->
+
+    <td class="number test-bg-20">{{ item.err.test }}</td>
+    <td class="number refe-bg-20">{{ item.err.reference }}</td>
+    <td class="number">
+      {% if item.err.is_relative %}
+        {{ '%0.2f' % (item.err.value*100)|float}}%
+      {% else %}
+        {{ item.err.value }}
+      {% endif %}
+    </td>
+    <td>
+      {% if item.err.test and item.err.reference %}
+      <div style="width:200px;height:20px">
+        <div class="test-bg-80" style="width:{{100*(item.err.test|abs)/([(item.err.test|abs), (item.err.reference|abs)]|max)}}%;height:10px"></div>
+        <div class="refe-bg-80" style="width:{{100*(item.err.reference|abs)/([(item.err.test|abs), (item.err.reference|abs)]|max)}}%; height:10px"></div>
+      </div>
+      {% endif %}      
+    </td>
+
+
+    {% if group.type == "vectors" %}
+    {% set group = comp_errs.groups[item.group] %}
+    <td>{{ group.name }}</td>
+    <td>{{ item.info.index }}</td>
+    <td>
+      {% if group.data %}
+      {{ group.data.info_prefix + ": " + item.info.info|string }}
+      {% endif %}
+    </td>
+    {% endif %}
+
+    {% if group.type == "lines" %}
+    <td class="test-bg-20 number">{{ item.info.line_nb_1 }}</td>
+    <td class="refe-bg-20 number">{{ item.info.line_nb_2 }}</td>
+    <td class="test-bg-20"><pre>{{ item.info.line_1 }}</pre></td>
+    <td class="refe-bg-20"><pre>{{ item.info.line_2 }}</pre></td>
+    {% endif %}
+
+    {% if group.type == "matrix" %}
+    <td class="number">{{ item.info.i }}</td>
+    <td class="number">{{ item.info.j }}</td>
+    <td class="number">{{ item.info.x }}</td>
+    <td class="number">{{ item.info.y }}</td>
+    {% endif %}
+
+  </tr>
+  {% endfor %}
+  {% endfor %}
+
+</table>
+

{scilens-0.2.1.dist-info → scilens-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: scilens
-Version: 0.2.1
+Version: 0.3.0
 Summary: A CesGensLaB framework for data collecting and deep analysis
 Home-page: https://scilens.dev
 License: Proprietary

{scilens-0.2.1.dist-info → scilens-0.3.0.dist-info}/RECORD

@@ -8,12 +8,13 @@ scilens/cli/info.py,sha256=xE7q9epjrCQRL6Agi3nhKsG6Mr3B8HSUFMti-epMoXA,1929
 scilens/cli/main.py,sha256=LljcS0s2E35y4YZpV01GhMhMK9HyRRHYmxc_q_kSurI,6004
 scilens/components/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 scilens/components/analyse_folder.py,sha256=yqc-dscKaHLZJCYeXGak2v0c3F2aeX0E11AFPfya6r0,208
-scilens/components/compare_2_files.py,sha256=oQ5p9JwB1r_HhfCb29mv1kkkrUd0EdrVug9T-1fQshY,1286
-scilens/components/compare_errors.py,sha256=_n9uWwLVZyPn99mwsAF8WBfcYppVQCsMwj0xuOrlhkU,1241
-scilens/components/compare_floats.py,sha256=UGUJF-WEZJSCpHZUAvVhkWY-mWiQZ8RqYnkTjFdRp1Y,3617
+scilens/components/compare_2_files.py,sha256=U4xumE28ijFbnrTPH8FgRyR_b5f04jOjaCmegJvCvSE,1483
+scilens/components/compare_errors.py,sha256=Kw_zpVmA3Fb7yVDXog2poLaTsV_K81eLqv-z-b73Nlw,1495
+scilens/components/compare_floats.py,sha256=GF4kKvkSKqCLLrx-BnmGi7yWTEBkYZjlCim7B9NBWxc,5028
 scilens/components/compare_folders.py,sha256=LZ1AuYxLVHMNbtXWXQrdms4vZgOQthvDy-8NFD_EFjc,2617
+scilens/components/compare_models.py,sha256=SCPd747h_nd4ewZsqLB6CFr27v6q99NELJb-gpkdj0o,918
 scilens/components/executor.py,sha256=8ZZq9wwoiMr7ys9LXv1pEg5Zc06QatT9PGIigMsDAB8,3620
-scilens/components/file_reader.py,sha256=2xvBoiJSb0KUihLzRK_o-DdGSRqEBu0-QwT1i9CCWRM,1346
+scilens/components/file_reader.py,sha256=7SbKCqb4Co_pqAKX3wweYhqAcVkU7BDlT903sLd76Kc,1407
 scilens/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 scilens/config/cli_run_options.py,sha256=Ls7yK5QDUPFbk73nbjGuPvuRbBRYw4Miag5ISpu3prg,281
 scilens/config/env_var.py,sha256=NqNBoIfngJEXaGEm7jGqre5pmkJ9eUjiWzbDrTVfi2c,292
@@ -26,7 +27,7 @@ scilens/config/models/execute.py,sha256=pFY-gZuBvLbcjTEcoNhPPO7FMFmKa6_TU5IXyKaf
 scilens/config/models/execute_and_compare.py,sha256=TWL6yXGvQSaaV6nhHqWLvtr3v396APIoDNt0U1TbMro,582
 scilens/config/models/file_reader.py,sha256=c18vKhVcBX4ufpbnCBJyVyAsQtlxpwx0lGVuf1i8EGA,1176
 scilens/config/models/reader_format_cols_curve.py,sha256=eKLvifq1xuN8sPds9ijfru3vgMZ3Odv5tGfeiK4Sfk4,1860
-scilens/config/models/reader_format_csv.py,sha256=XWZTr6s0PPfcOMRrsNeOZGtExC1uyXb67A158MMWzC4,577
+scilens/config/models/reader_format_csv.py,sha256=cxvkVbBF5DtrbRCIppjDUC2EIkb-GIe9qou3TGrihxU,1265
 scilens/config/models/reader_format_netcdf.py,sha256=nbfTB3avO0DidbNa1dCZGFZmmQvzTYhpe6mqfAanaOA,1025
 scilens/config/models/reader_format_txt.py,sha256=eHg90gwEI_VpqwqEjMRhwlS8dHcl5G4ow-37HjQq_zY,1168
 scilens/config/models/reader_format_txt_fixed_cols.py,sha256=xHD1_JOoRZow8lSNaDSYFeNckojctkT4C61mbBcjeKg,1079
@@ -46,15 +47,14 @@ scilens/processors/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 scilens/processors/models/results.py,sha256=KoWxh13Zgi7PuPql8hkf4VjCis42ZxAuzIgJxBWVaX8,119
 scilens/processors/processor_interface.py,sha256=jzMp1529JXnMGTJijVy6b_1zmARAMNv70f2lgys7vn4,452
 scilens/readers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-scilens/readers/cols_dataset.py,sha256=suEttRHfj9UhHndchAKazLD2z_YY9dFEVLjlodRJS44,2363
+scilens/readers/cols_dataset.py,sha256=JIfPBzQZml6VlykbrMcCanR12eEnjY1A-ECgXs8wtZ4,2527
 scilens/readers/exceptions.py,sha256=JzmxcjnR5sH-IOWVeCC5A1bSwxv-jCAtIJvDjzx1CTI,32
-scilens/readers/reader_com_txt_lines.py,sha256=zsCumTD0sv06OQNvRKPMuv94De_6KGMvN904-E1Uqeg,91
-scilens/readers/reader_csv copy.py,sha256=eFWQvMt4Ot7KgUIDsed1QymMbPblgboUclvQj6viVGs,4069
-scilens/readers/reader_csv.py,sha256=oLbA4wU6rlzL1cIrW-AzWifP-RvmG3yHKWQQqITYQ1U,2732
+scilens/readers/mat_dataset.py,sha256=vUEjAK6nuY7miLJvjSkiHAU64KaNa1VCx7EhGPazp-U,1190
+scilens/readers/reader_csv.py,sha256=aPd2IxFiUXYmH_EpNZkCHV1oMWctZW7YSPwC8q75SIo,3490
 scilens/readers/reader_interface.py,sha256=nnttHL7wt4MOXpi-SBkk8DYxVWscOPG8JFl_z12mIAo,922
 scilens/readers/reader_manager.py,sha256=DFinxIk3IIIcB6JxybGcv-mXt3jhXgCwUtzR0TqhB2Q,2684
-scilens/readers/reader_txt.py,sha256=xeiQNrWSr-jRnb0KoYya8Y_gdjT-0L_iXS4TW_bfqQc,3774
-scilens/readers/reader_txt_fixed_cols.py,sha256=KuZd62_cmV9vHRlar2K-acFVVLf28bAqRSbpRRNjblI,2258
+scilens/readers/reader_txt.py,sha256=WPsFunEA_idzAKkD3UJQbLnaOzG2U03P3gY4gphuIw0,3868
+scilens/readers/reader_txt_fixed_cols.py,sha256=vIA6e38_3nkFeCT835eSyCufCXQNGav8Iy7VgHlT_EE,2314
 scilens/readers/transform.py,sha256=kppfgPkXymF0qtquFivuosLVfF66L9bE-wGx-3bMHv8,307
 scilens/report/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 scilens/report/assets/logo.svg,sha256=W-1OVqcvdBjf-1AHHcV6WciIUqBoVFUh52Tc3o_jqtA,4519
@@ -68,7 +68,8 @@ scilens/report/templates/body_99_footer.html,sha256=8cWebeWfZwZ-9bYAMZkZj8rbCWq3
 scilens/report/templates/compare_11_summary.html,sha256=4rxBlOxTcn59ztYtqDbi6SRQXlaz30HkVl7dJpzCmZE,3776
 scilens/report/templates/compare_12_sections.html,sha256=HWsfCmfdleyRK6IHJeMEheenOuyA0mLzOZ-0qLcuzJU,5952
 scilens/report/templates/compare_13_section_numbers copy.html,sha256=0PWK_I2kNX3LjPLkkY4eSYIeB7YFkA28nk-PPLDhnaY,1753
-scilens/report/templates/compare_13_section_numbers.html,sha256=JjD20F6X2RjzJIgAAF431JOdmUyNNOHJOufdH21iUsM,2820
+scilens/report/templates/compare_13_section_numbers.html,sha256=FpIYAVXRiWf2zrJtjy2fWPdit_RNbHP2zQLQYScIrtY,291
+scilens/report/templates/compare_13_section_numbers_table.html,sha256=sJy6ZYtjl80vM1b3oqZSXawZWp7KNIwLI_wCnvBwYPE,3270
 scilens/report/templates/index.html,sha256=mNTu-CAzEJ2rhz81cHAdmT_KcQeOQ3b_FSC73NPEi0U,3670
 scilens/report/templates/js_chartlibs_echarts.js,sha256=6YicVhTNIBmmBpV31XCVN5oBeiD0t29JIosJZRUv01M,907
 scilens/report/templates/js_chartlibs_plotly.js,sha256=uVAOKUB5XE33-r04phR-LlRkFoaHEIXyQ3jXT5r97Rc,1521
@@ -96,7 +97,7 @@ scilens/utils/template.py,sha256=9dlXX3nmfzDRUwzPJOkoxk15UXivZ2SW-McdCwokFa4,443
 scilens/utils/time_tracker.py,sha256=DdVBoMpVLXrX0qZZXyLm4g38EwDVLlRcBqcpNex1mYY,545
 scilens/utils/vectors.py,sha256=4N2BZSC5n3HgZqPujDGF5NdjVmSL1rOHb_qw4OoABQY,103
 scilens/utils/web.py,sha256=E4T8Fra65u9g_BpcFANPk4ORvsYavAeiSgWA3vRca2E,804
-scilens-0.2.1.dist-info/METADATA,sha256=QYXvNkOg3U3JDqKslGVMo1OCq3bCM6yT7eCzAS4onX4,1367
-scilens-0.2.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-scilens-0.2.1.dist-info/entry_points.txt,sha256=DaKGgxUEUv34GJAoXtta6ecL37ercejep9sCSSRQK2s,48
-scilens-0.2.1.dist-info/RECORD,,
+scilens-0.3.0.dist-info/METADATA,sha256=zvMTkfew0QXwM9EzvFc4bu1oeo4XZCAo1GonbGZ4LtI,1367
+scilens-0.3.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+scilens-0.3.0.dist-info/entry_points.txt,sha256=DaKGgxUEUv34GJAoXtta6ecL37ercejep9sCSSRQK2s,48
+scilens-0.3.0.dist-info/RECORD,,

scilens/readers/reader_com_txt_lines.py

@@ -1,2 +0,0 @@
-class ReaderComTxtLines:
-	def __init__(A,raw_lines):A.raw_lines=raw_lines;A.ignore_lines=[]

scilens/readers/reader_csv copy.py

@@ -1,74 +0,0 @@
-_E='charts'
-_D='x_index'
-_C='csv_col_index'
-_B='curves'
-_A=None
-import logging,csv
-from scilens.readers.reader_interface import ReaderInterface
-from scilens.config.models import ReaderCsvConfig
-from scilens.config.models.reader_format_cols_curve import ReaderCurveParserNameConfig
-from scilens.components.compare_floats import CompareFloats
-def is_num(x):
-	try:return float(x)
-	except ValueError:return
-def csv_row_detect_header(first_row):
-	A=first_row
-	if all(not A.isdigit()for A in A):return True,A
-	else:return False,[f"Column {A}"for(A,B)in enumerate(A)]
-def csv_row_detect_cols_num(row):return[A for(A,B)in enumerate(row)if is_num(B)!=_A]
-def csv_detect(path,delimiter,quotechar):
-	with open(path,'r')as B:A=csv.reader(B,delimiter=delimiter,quotechar=quotechar);C=next(A);D,E=csv_row_detect_header(C);F=next(A);G=csv_row_detect_cols_num(F);return D,E,G
-class ReaderCsv(ReaderInterface):
-	category='datalines';extensions=['CSV']
-	def read(A,reader_options):
-		B=reader_options;A.reader_options=B;C,G,H=csv_detect(A.origin.path,A.reader_options.delimiter,A.reader_options.quotechar);A.has_header=C;A.cols=G;A.numeric_col_indexes=H
-		if B.ignore_columns:
-			if not C:raise Exception('Ignore columns is not supported without header.')
-			A.numeric_col_indexes=[C for C in A.numeric_col_indexes if A.cols[C]not in B.ignore_columns]
-		E=open(A.origin.path,'r',encoding=A.encoding);I=csv.reader(E,delimiter=A.reader_options.delimiter,quotechar=A.reader_options.quotechar);D=[]
-		for J in I:D+=[J]
-		if C:D.pop(0)
-		E.close();A.data_rows=D;A.raw_lines_number=len(A.data_rows)+(1 if C else 0);A.curves=_A
-		if B.curve_parser:
-			if B.curve_parser.name==ReaderCurveParserNameConfig.COL_X:
-				A.curves,K=A._get_curves_col_x(B.curve_parser.parameters.x)
-				if A.curves:A.curves_parser_type=B.curve_parser.name;A.curves_info=K
-			elif B.curve_parser.name==ReaderCurveParserNameConfig.COLS_COUPLE:raise NotImplementedError('cols_couple not implemented')
-			else:raise Exception('Curve parser not supported.')
-		A.cols_data=[_A]*len(A.cols)
-		for F in A.numeric_col_indexes:A.cols_data[F]=[float(A[F])for A in D]
-	def compare(A,compare_floats,param_reader,param_is_ref=True):
-		U='error';M=param_is_ref;L=param_reader;K=compare_floats;J='Errors limit reached';C=A if M else L;E=A if not M else L
-		if len(C.numeric_col_indexes)!=len(E.numeric_col_indexes):V=f"Number Float columns indexes are different: {len(C.numeric_col_indexes)} != {len(E.numeric_col_indexes)}";return V,_A
-		N=0;D=[''for A in C.cols];O=_A;F=_A
-		if A.curves and A.curves_parser_type==ReaderCurveParserNameConfig.COL_X:P=A.curves_info[_D];O=C.cols_data[P];F=A.cols[P]
-		G=False
-		for B in range(len(C.cols_data)):
-			if C.cols_data[B]==_A:continue
-			logging.debug(f"Comparing {A.cols[B]}")
-			if G:D[B]=J;continue
-			W=C.cols_data[B];X=E.cols_data[B];Y=K.compare_errors.add_group(A.cols[B],data={'info_prefix':F}if F else _A);Q,R,H=K.compare_vectors(W,X,group_idx=Y,info_vector=O);N+=R;logging.debug(f"limit_reached, diffs_count, counts: {Q}, {R}, {H}")
-			if Q:G=True;D[B]=J;continue
-			if H[U]>0:D[B]=f"{H[U]} comparison errors"
-		if A.curves:
-			for S in A.curves[_E]:
-				T=0
-				for Z in S[_B]:
-					I=A.curves[_B][Z]
-					if D[I[_C]]:I['comparison_error']=D[I[_C]];T+=1
-				S['comparison']={'curves_nb_with_error':T}
-		a=J if G else _A;return a,{'type':'vectors','total_diffs':N,'cols_has_error':D}
-	def class_info(A):return{'cols':A.cols,'raw_lines_number':A.raw_lines_number,_B:A.curves}
-	def _get_curves_col_x(E,col_x):
-		J='title';A=col_x;F={};B=E.cols
-		if isinstance(A,int):
-			C=A-1
-			if C<0 or C>=len(B):raise Exception('curve parser col_x: col_index is out of range.')
-		if isinstance(A,str):A=[A]
-		if isinstance(A,list):
-			H=[B for(B,C)in enumerate(B)if C in A]
-			if len(H)==0:return _A,F
-			C=H[0]
-		F[_D]=C;K=[B for(A,B)in enumerate(E.numeric_col_indexes)if A!=C];G=[];I=[]
-		for D in K:L={J:B[D],'short_title':B[D],'series':[[float(A[C]),float(A[D])]for A in E.data_rows],_C:D};G+=[L];M={J:B[D],'type':'simple','xaxis':B[C],'yaxis':B[D],_B:[len(G)-1]};I+=[M]
-		return{_B:G,_E:I},F