studpy 0.1.0__py3-none-any.whl

studpy/__init__.py

@@ -0,0 +1,2 @@
+from.study import Study
+__all__=['Study']

studpy/batch/__init__.py

@@ -0,0 +1,3 @@
+from.batch_exec_cmd_iter import BatchExecCmdIter
+from.validated_batch import ValidatedBatchExecCmdIter
+__all__=['BatchExecCmdIter','ValidatedBatchExecCmdIter']

studpy/batch/batch_exec_cmd_iter.py

@@ -0,0 +1,32 @@
+import asyncio
+from abc import ABC,abstractmethod
+from studpy.utils.logger_print import LoggerPrint
+class BatchExecCmdIter(ABC):
+	logger=LoggerPrint();out_err_keywords:list[str]|None=None
+	@abstractmethod
+	def get_nb_runs(self):...
+	@abstractmethod
+	def cmd_callable(self,index_run):...
+	def pre_callable(A,index_run):0
+	def post_callable(A,index_run,returncode,stdout,stderr):0
+	def end_callable(A,nb_errors):0
+	def exec(A,max_parallel_jobs=5):
+		B=A.get_nb_runs();A.exec_nb_runs=B
+		if A.logger:A.logger.info(f"[{A.__class__.__name__}] START — {B} runs")
+		asyncio.run(A._main_batch(nb_runs=B,max_parallel_jobs=max_parallel_jobs))
+	async def _main_batch(A,nb_runs,max_parallel_jobs):
+		C=asyncio.Semaphore(max_parallel_jobs);D=[A._run_cmd(C,B)for B in range(nb_runs)];E=await asyncio.gather(*D);B=sum(1 for A in E if A);A.end_callable(B)
+		if A.logger:A.logger.info(f"[{A.__class__.__name__}] END — {B} errors / {A.exec_nb_runs} runs")
+		A.exec_nb_errors=B
+	async def _run_cmd(A,sem,index_run):
+		B=index_run;I=A.cmd_callable(B)
+		async with sem:
+			A.pre_callable(B)
+			if A.logger:A.logger.info(f"[{A.__class__.__name__}] RUN {B+1}/{A.exec_nb_runs}")
+			F=await asyncio.create_subprocess_shell(I,stdout=asyncio.subprocess.PIPE,stderr=asyncio.subprocess.PIPE);J,K=await F.communicate();C=F.returncode;G=J.decode().strip();H=K.decode().strip();D=None
+			if C!=0:D=f"return code {C} != 0"
+			elif A.out_err_keywords:
+				L=G.lower();M=H.lower()
+				for E in A.out_err_keywords:
+					if E.lower()in L or E.lower()in M:D=f"keyword '{E}' found in stdout/stderr";break
+			N=A.post_callable(B,C,G,H);return D or N

studpy/batch/validated_batch.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+import shutil
+from abc import abstractmethod
+from pathlib import Path
+from.batch_exec_cmd_iter import BatchExecCmdIter
+class ValidatedBatchExecCmdIter(BatchExecCmdIter):
+	def __init__(A):A.failed_runs=[];A.success_runs=[]
+	@abstractmethod
+	def expected_output_path(self,index_run):...
+	def cleanup_path(A,index_run):0
+	def post_failure(E,index_run,returncode,stdout,stderr,reasons):
+		B=reasons;A=index_run;print(f"  [FAIL] run {A}  {' | '.join(B)}");C=stdout+stderr
+		if C.strip():
+			for D in C.strip().splitlines()[:15]:print(f"    │ {D}")
+		return f"run {A} failed: {', '.join(B)}"
+	def post_callable(B,index_run,returncode,stdout,stderr):
+		A=index_run;C=B.expected_output_path(A);E=C.exists()and C.stat().st_size>0
+		if not E:
+			F=[f"missing/empty output: {C.name}"];D=B.cleanup_path(A)
+			if D and D.exists():shutil.rmtree(D)
+			B.failed_runs.append(A);return B.post_failure(A,returncode,stdout,stderr,F)
+		print(f"  [OK]  run {A}  → {C.name}");B.success_runs.append(A)
+	def end_callable(A,nb_errors):
+		B=A.get_nb_runs();C=len(A.failed_runs)/B if B>0 else 0;print(f"\n  {len(A.success_runs)} OK, {len(A.failed_runs)} failed ({C*100:.1f}%)")
+		if A.failed_runs:print(f"  Failed indices: {A.failed_runs}")

studpy/params/__init__.py

@@ -0,0 +1,5 @@
+from.configs import GaussianConfig,LHSConfig,LinearConfig,ListConfig,RandomIntConfig,TableConfig
+from.latin_hypercube_sampling import LatinHypercubeSampling
+from.param import Param
+from.specs import ParamsSpecs
+__all__=['ParamsSpecs','Param','GaussianConfig','LinearConfig','ListConfig','LHSConfig','RandomIntConfig','TableConfig','LatinHypercubeSampling']

studpy/params/configs.py

@@ -0,0 +1,35 @@
+_D='linear'
+_C='gaussian'
+_B='random_int'
+_A=None
+from typing import Any,Literal
+import numpy as np
+from pandas import DataFrame
+from pydantic import BaseModel,model_validator
+class LHSConfig(BaseModel):type:Literal['lhs']='lhs';lhs_reference:str;low:float;high:float
+class TableConfig(BaseModel):type:Literal['table']='table';table_reference:str;col:str
+class RandomIntConfig(BaseModel):
+	type:Literal[_B]=_B;low:int;high:int;size:int
+	def get_size(A):return A.size
+	def get_dataframe(A,col_name='value'):B=np.random.randint(A.low,A.high+1,size=A.size);return DataFrame(B,columns=[col_name])
+class GaussianConfig(BaseModel):
+	type:Literal[_C]=_C;mean:float;std:float;size:int;low:float|_A=_A;high:float|_A=_A;seed:int|_A=_A
+	def get_size(A):return A.size
+	def get_value(A,index):return .0
+class ListConfig(BaseModel):
+	type:Literal['list']='list';values:list[Any]
+	def get_size(A):return len(A.values)
+	def get_value(A,index):return A.values[index]
+class LinearConfig(BaseModel):
+	type:Literal[_D]=_D;size:int|_A=_A;low:float;high:float;step_value:float|_A=_A
+	@model_validator(mode='before')
+	@classmethod
+	def resolve_missing_field(cls,values):
+		G='step_value';F='size';A=values;B=A.get(F);D=A.get('low');E=A.get('high');C=A.get(G)
+		if B is _A and C is _A:raise ValueError("'size' or 'step_value' should be defined")
+		if B is not _A and C is not _A:raise ValueError("only 'size' or 'step_value' should be defined")
+		if C is _A:A[G]=(E-D)/(B-1)
+		if B is _A:A[F]=round((E-D)/C)+1
+		return A
+	def get_size(A):return A.size
+	def get_dataframe(A,col_name='value'):B=np.arange(A.low,A.high+A.step_value,A.step_value)[:A.size];return DataFrame(B,columns=[col_name])

studpy/params/latin_hypercube_sampling.py

@@ -0,0 +1,17 @@
+import random
+from pandas import DataFrame
+from.configs import LHSConfig
+from.param import Param
+class LatinHypercubeSampling:
+	def __init__(A,n_samples,random_seed=42):A.n_samples=n_samples;A.random_seed=random_seed
+	def build_cases(D,parameters,col_names):
+		E=parameters;B=D.n_samples;F=random.Random(D.random_seed);G={}
+		for A in E:H=list(range(B));F.shuffle(H);G[A.target]=H
+		I=[]
+		for K in range(B):
+			J={}
+			for A in E:
+				if not isinstance(A.config,LHSConfig):raise Exception('parameter should be LHSConfig')
+				C=A.config;L=G[A.target][K];M=(L+F.random())/B;N=col_names[A.target];J[N]=round(C.low+M*(C.high-C.low),6)
+			I.append(J)
+		return DataFrame(I)

studpy/params/param.py

@@ -0,0 +1,4 @@
+from typing import Annotated
+from pydantic import BaseModel,Field
+from.configs import GaussianConfig,LHSConfig,LinearConfig,ListConfig,RandomIntConfig,TableConfig
+class Param(BaseModel):target:str;config:Annotated[GaussianConfig|LinearConfig|ListConfig|LHSConfig|RandomIntConfig|TableConfig,Field(discriminator='type')];name:str|None=None

studpy/params/specs.py

@@ -0,0 +1,18 @@
+_D='other'
+_C=None
+_B='table'
+_A='lhs'
+import math
+from pandas import DataFrame
+from.latin_hypercube_sampling import LatinHypercubeSampling
+from.param import Param
+NONAME_PREFIX='Col '
+class ParamsSpecs:
+	def __init__(A,parameters,tables=_C,lhs=_C):A.parameters=parameters;A.tables=tables;A.lhs=lhs;A._params_by_category={_B:[A for A in A.parameters if A.config.type==_B],_A:[A for A in A.parameters if A.config.type==_A],_D:[A for A in A.parameters if A.config.type not in[_B,_A]]};A._references={_B:list(set([A.config.table_reference for A in A._params_by_category[_B]])),_A:list(set([A.config.lhs_reference for A in A._params_by_category[_A]]))}
+	def cases_count(A):return math.prod([A.tables[B].shape[0]for B in A._references[_B]]+[A.lhs[B].n_samples for B in A._references[_A]]+[A.config.get_size()for A in A._params_by_category[_D]])
+	def params_targets_names(A):return{A.target:A.name or f"{NONAME_PREFIX}{B}"for(B,A)in enumerate(A.parameters)}
+	def build_cases(B):
+		G='cross';D=B.params_targets_names();A=_C
+		for E in B._references[_A]:H=[A for A in B._params_by_category[_A]if A.config.lhs_reference==E];C=B.lhs[E].build_cases(H,D);A=C if A is _C else A.merge(C,how=G)
+		for F in B._params_by_category[_D]:C=F.config.get_dataframe(D[F.target]);A=C if A is _C else A.merge(C,how=G)
+		return A

studpy/study.py

@@ -0,0 +1,9 @@
+from pathlib import Path
+from.params import ParamsSpecs
+from.targets import TargetsOneFile
+class Study:
+	def __init__(A,specs,targets):B=specs;A.specs=B;A.cases=B.build_cases();A.targets=targets
+	def cases_count(A):return len(A.cases)
+	def cases_save(A,p):A.cases.to_csv(p,index=False)
+	def case_targets_values(A,case_index):B=A.cases.iloc[case_index].to_dict();C=A.specs.params_targets_names();return{A:B[C]for(A,C)in C.items()}
+	def case_build_inputs(A,case_index):B=case_index;C=A.case_targets_values(B);A.targets.build(case_index=B,case_targets_values=C)

studpy/targets/__init__.py

@@ -0,0 +1,2 @@
+from.one_file import TargetsOneFile
+__all__=['TargetsOneFile']

studpy/targets/one_file.py

@@ -0,0 +1,16 @@
+import json,shutil
+from pathlib import Path
+from typing import Any
+from.utils import dict_set_nested
+class TargetsOneFile:
+	def __init__(A,output_folder,template_file,subfoldername=None):A.output_folder=output_folder;A.template_file=template_file;A.subfoldername=subfoldername
+	def build(A,case_index,case_targets_values):
+		D=A.template_file.name;C=A.output_folder/f"{case_index}";C.mkdir()
+		if A.subfoldername:(C/A.subfoldername).mkdir();B=C/A.subfoldername/D
+		else:B=C/D
+		shutil.copy(A.template_file,B);F=B.suffix.lower()
+		if F=='.json':
+			E=json.loads(B.read_text())
+			for(G,H)in case_targets_values.items():dict_set_nested(E,G,H)
+			I=json.dumps(E);B.write_text(I)
+		else:raise Exception('template type not known')

studpy/targets/utils.py

@@ -0,0 +1,5 @@
+from typing import Any
+def dict_set_nested(data,dict_path,value):
+	A=data;B=dict_path.split('.')
+	for C in B[:-1]:A=A.setdefault(C,{})
+	A[B[-1]]=value

studpy/utils/logger_print.py

@@ -0,0 +1,6 @@
+from typing import Any
+class LoggerPrint:
+	def info(A,msg):print(f"[INFO] {msg}")
+	def error(A,msg):print(f"[ERROR] {msg}")
+	def warning(A,msg):print(f"[WARNING] {msg}")
+	def debug(A,msg):print(f"[DEBUG] {msg}")

studpy-0.1.0.dist-info/METADATA

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: studpy
+Version: 0.1.0
+Summary: A collection of useful functionalities for scientific studies.
+Author-email: PinkSalmon <dev@pinksalmon.cloud>
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Requires-Dist: pandas
+Requires-Dist: pydantic
+Provides-Extra: dev
+Requires-Dist: mypy>=1.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocstrings-python; extra == 'docs'
+Requires-Dist: zensical; extra == 'docs'

studpy-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+studpy/__init__.py,sha256=YBs_bmmbPMsmLqtDHqNvqqI2Z2JdghQOhMtfCc76dt8,41
+studpy/study.py,sha256=NsLsLS8M_7RPk4GU526phkrhJYuF8itDmdML4dYtbFE,558
+studpy/batch/__init__.py,sha256=N2tl5q3lPuNLPQskrLZWEPDLlvkM8VvEV5Wcj8e-B0U,159
+studpy/batch/batch_exec_cmd_iter.py,sha256=Pd28LcHZ1q0pb2Vx7ISgE2Ao7q5Qs5ml0zn5a9tAMEw,1613
+studpy/batch/validated_batch.py,sha256=etMHSeikOIwp-2UqC_bt0CKEZ45HT7AcTsu7o11ej-Q,1251
+studpy/params/__init__.py,sha256=xi70KbcvDWpKJMUFE8TSk-1QG3ODms-DEPQmEOhn-18,356
+studpy/params/configs.py,sha256=2OItCi6SdNhaMrPdAk4qF-gfYPih3CMlUq7oKHfc32k,1666
+studpy/params/latin_hypercube_sampling.py,sha256=1QqZ8IgIYW2O0uhoTxf_11B61mnujkXLb64AS0p6Q4Q,669
+studpy/params/param.py,sha256=63PtPXQQx6LHvcGL7Y8uCLltcpJrfgRa91qjjubwbbs,338
+studpy/params/specs.py,sha256=XaoABLufpTiAFYIJtzwCaFYa-G9wMeTzeUWdx7Eacn4,1302
+studpy/targets/__init__.py,sha256=s-SxrZIIhJp4b0NxPQmhVWWTxSUeNO4HCpg8GS0pcII,62
+studpy/targets/one_file.py,sha256=_gXd7wIoF6x7dsvIXHE5oZo6Tw3EnlANZENr-6Z0HxY,725
+studpy/targets/utils.py,sha256=7w3zEfu7hQZZFq1zHy7gfhysbCl0on_w1l3A9R_eXMs,150
+studpy/utils/logger_print.py,sha256=9LNtL61ind3P54i-c2vgi2oh-xHLR4pUOXCkV6MISag,211
+studpy-0.1.0.dist-info/METADATA,sha256=495Yx-87_EO1HSdRPM_S78wKX70LlAd7Wmp1yyAk5_A,747
+studpy-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+studpy-0.1.0.dist-info/RECORD,,

studpy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any