lalsuite 7.26.2.dev20251218__cp314-cp314t-manylinux_2_28_x86_64.whl

lalsuite-7.26.2.dev20251218.data/scripts/lalinference_pp_pipe

@@ -0,0 +1,229 @@
+#!python
+# End-to-end LALInference test pipeline
+# (C) 2014 John Veitch
+
+from __future__ import print_function
+
+import os
+import sys
+import uuid
+from optparse import OptionParser
+
+from configparser import ConfigParser
+
+from lal import pipeline
+
+from lalinference import lalinference_pipe_utils as pipe_utils
+from lalinference.lalinference_pipe_utils import mkdirs
+
+usage=""" %prog [options] config.ini
+Setup a DAG to run an end-to-end lalinference test:
+ 1) Generate samples from prior
+ 2) Analyse a set of injections drawn from the prior
+ 3) Run P vs P test on results
+"""
+
+parser=OptionParser(usage)
+parser.add_option("-r","--run-path",default='./',action="store",type="string",help="Directory to run pipeline in (default: $PWD)",metavar="RUNDIR")
+parser.add_option("-p","--daglog-path",default=None,action="store",type="string",help="Path to directory to contain DAG log file. SHOULD BE LOCAL TO SUBMIT NODE",metavar="LOGDIR")
+parser.add_option("-I","--injections",default=None,action="store",type="string",help="Path to injection file, will bypass the prior-sampling stage",metavar="injections.xml")
+parser.add_option('-N','--trials',action='store',type='int',metavar='NUM',help='Number of prior samples to analyse')
+
+
+(opts,args)=parser.parse_args()
+
+if len(args)==0:
+        parser.print_help()
+        sys.exit(1)
+
+inifile=args[0]
+
+# Set up the configuration for the sub-dags
+
+prior_cp=ConfigParser()
+prior_cp.optionxform = str
+try:
+  prior_cp.read_file(open(inifile))
+except AttributeError:
+  prior_cp.readfp(open(inifile))
+
+main_cp=ConfigParser()
+main_cp.optionxform = str
+try:
+  main_cp.read_file(open(inifile))
+except AttributeError:
+  main_cp.readfp(open(inifile))
+
+# Remove gps start and end time options
+for option in ['gps-start-time','gps-end-time']:
+  if main_cp.has_option('input',option):
+    main_cp.remove_option('input',option)
+
+rundir=os.path.abspath(opts.run_path)
+
+if opts.daglog_path is not None:
+  prior_cp.set('paths','daglogdir',os.path.join(os.path.abspath(opts.daglog_path),'prior'))
+  main_cp.set('paths','daglogdir',os.path.join(os.path.abspath(opts.daglog_path),'main'))
+  daglogdir=os.path.abspath(opts.daglog_path)
+else:
+  prior_cp.set('paths','daglogdir',os.path.join(os.path.abspath(opts.run_path),'prior'))
+  main_cp.set('paths','daglogdir',os.path.join(os.path.abspath(opts.run_path),'main'))
+  daglogdir=os.path.abspath(opts.run_path)
+
+webdir=main_cp.get('ppanalysis','webdir')
+priordir=os.path.join(rundir,'prior')
+maindir=os.path.join(rundir,'main')
+priorwebdir=os.path.join(webdir,'prior')
+mainwebdir=os.path.join(webdir,'injections')
+prior_cp.set('paths','basedir',priordir)
+main_cp.set('paths','basedir',maindir)
+prior_cp.set('paths','webdir',priorwebdir)
+main_cp.set('paths','webdir',mainwebdir)
+
+outerlogdir=os.path.join(daglogdir,'log')
+mkdirs(outerlogdir)
+mkdirs(priordir)
+mkdirs(maindir)
+mkdirs(priorwebdir)
+mkdirs(mainwebdir)
+
+# Add the prior options to the sub dag
+if prior_cp.get('analysis','engine')=='lalinferencenest':
+  prior_cp.set('engine','sampleprior',str(20*opts.trials)) # more samples drawn since not all will end up in posterior
+  prior_cp.set('engine','zeroLogLike','')
+  prior_cp.set('engine','nlive',str(20*opts.trials))
+elif prior_cp.get('analysis','engine')=='lalinferencemcmc':
+  prior_cp.set('engine','neff',str(max(opts.trials,1000))) # miminum of 1000 effective samples
+  prior_cp.set('engine','zeroLogLike','')
+elif prior_cp.get('analysis','engine')=='lalinferencebambi':
+  prior_cp.set('engine','zeroLogLike','')
+  prior_cp.set('engine','nlive',str(opts.trials))
+elif prior_cp.get('analysis','engine')=='lalinferencebambimpi':
+  prior_cp.set('engine','zeroLogLike','')
+  prior_cp.set('engine','nlive',str(opts.trials))
+
+# Remove marg options for prior sample generation
+for option in 'margphi','margtime','margtimephi':
+  if prior_cp.has_option('engine',option):
+        prior_cp.remove_option('engine',option)
+
+# Create a DAG to contain the other scripts
+outerdaglog=os.path.join(daglogdir,'lalinference_injection_test_'+str(uuid.uuid1())+'.log')
+outerdag=pipeline.CondorDAG(outerdaglog)
+outerdag.set_dag_file(os.path.join(rundir,'priortest'))
+
+# Run code with prior sampling
+trig_time=1085855789
+fake_event=pipe_utils.Event(trig_time=trig_time)
+tfpath=os.path.join(rundir,'time.txt')
+tfile=open(tfpath,'w')
+print('%i\n'%(trig_time), file=tfile)
+tfile.close()
+prior_cp.set('input','gps-time-file',tfpath)
+
+priordag=pipe_utils.LALInferencePipelineDAG(prior_cp)
+priordag.set_dag_file(os.path.join(priordir,'lalinference_priorsample'))
+priordagjob=pipeline.CondorDAGManJob(priordag.get_dag_file(),dir=priordir)
+priordagnode=pipeline.CondorDAGManNode(priordagjob)
+# Find the output file
+pagenode=filter(lambda n:isinstance(n,pipe_utils.ResultsPageNode), priordag.get_nodes())[0]
+priorfile=pagenode.get_pos_file()
+
+# Convert prior samples to injections
+convertsub=os.path.join(rundir,'samples2injections.sub')
+converterr=os.path.join(outerlogdir,'samples2injection-$(cluster)-$(process)-$(node).err')
+convertout=os.path.join(outerlogdir,'samples2injection-$(cluster)-$(process)-$(node).out')
+
+if opts.injections:
+        injfile=os.path.abspath(opts.injections)
+else:
+        injfile=os.path.join(rundir,'priorsamples.xml')
+approx=prior_cp.get('engine','approx')
+prior2injexe=prior_cp.get('condor','pos_to_sim_inspiral')
+prior2injjob=pipeline.CondorDAGJob('vanilla',prior2injexe)
+prior2injjob.set_sub_file(convertsub)
+prior2injjob.set_stderr_file(converterr)
+prior2injjob.set_stdout_file(convertout)
+prior2injjob.add_condor_cmd('getenv','True')
+if main_cp.has_option('condor','accounting_group'):
+  prior2injjob.add_condor_cmd('accounting_group',main_cp.get('condor','accounting_group'))
+prior2injnode=pipeline.CondorDAGNode(prior2injjob)
+prior2injnode.add_var_opt('output',injfile)
+prior2injnode.add_var_opt('num-of-injs',str(opts.trials))
+prior2injnode.add_var_opt('approx',approx)
+if prior_cp.has_option('engine','amporder'):
+  amporder=prior_cp.get('engine','amporder')
+else:
+  amporder='0'
+prior2injnode.add_var_opt('amporder',amporder)
+prior2injnode.add_var_arg(priorfile)
+prior2injnode.add_parent(priordagnode)
+
+# Create the pipeline based on the injections
+#main_cp.set('input','injection-file',injfile)
+main_cp.set('input','gps-start-time',str(trig_time-1000))
+main_cp.set('input','gps-end-time',str(trig_time+1000))
+maindag=pipe_utils.LALInferencePipelineDAG(main_cp)
+maindag.set_dag_file(os.path.join(maindir,'lalinference_pipeline'))
+maindagjob=pipeline.CondorDAGManJob(maindag.get_dag_file(),dir=maindir)
+maindagnode=pipeline.CondorDAGManNode(maindagjob)
+maindag.config.set('input','injection-file',injfile)
+for i in range(int(opts.trials)):
+  ev=pipe_utils.Event(trig_time=trig_time,event_id=i)
+  e=maindag.add_full_analysis(ev)
+
+outerdag.add_node(maindagnode)
+
+if not opts.injections:
+    outerdag.add_node(priordagnode)
+    outerdag.add_node(prior2injnode)
+    maindagnode.add_parent(prior2injnode)
+
+# Get a list of posterior samples files
+resultspagenodes=filter(lambda n: isinstance(n, pipe_utils.ResultsPageNode), maindag.get_nodes())
+posteriorfiles=[n.get_pos_file() for n in resultspagenodes]
+
+# Analyse results of injection runs to generate PP plot
+ppsub=os.path.join(rundir,'ppanalysis.sub')
+pperr=os.path.join(outerlogdir,'ppanalysis-$(cluster)-$(process)-$(node).err')
+ppout=os.path.join(outerlogdir,'ppanalysis-$(cluster)-$(process)-$(node).out')
+ppexe=prior_cp.get('condor','ppanalysis')
+ppjob=pipeline.CondorDAGJob('vanilla',ppexe)
+ppjob.set_sub_file(ppsub)
+ppjob.set_stderr_file(pperr)
+ppjob.set_stdout_file(ppout)
+ppjob.add_condor_cmd('getenv','True')
+if main_cp.has_option('condor','accounting_group'):
+  ppjob.add_condor_cmd('accounting_group',main_cp.get('condor','accounting_group'))
+
+ppnode=pipeline.CondorDAGNode(ppjob)
+ppnode.add_var_opt('injXML',injfile)
+if main_cp.has_option('ppanalysis','webdir'):
+  outdir=main_cp.get('ppanalysis','webdir')
+else:
+  outdir=os.path.join(rundir,'ppanalysis')
+
+mkdirs(outdir)
+ppnode.add_var_opt('outdir',outdir)
+for f in posteriorfiles:
+  ppnode.add_var_arg(f)
+
+ppnode.add_parent(maindagnode)
+outerdag.add_node(ppnode)
+
+outerdag.write_sub_files()
+outerdag.write_dag()
+outerdag.write_script()
+
+if not opts.injections:
+    priordag.write_sub_files()
+    priordag.write_dag()
+    priordag.write_script()
+
+maindag.write_sub_files()
+maindag.write_dag()
+maindag.write_script()
+
+# End of program
+print('Successfully created DAG file.')
+print('Now run condor_submit_dag %s\n'%(outerdag.get_dag_file()))

lalsuite-7.26.2.dev20251218.data/scripts/lalinference_review_test

@@ -0,0 +1,362 @@
+#!python
+import argparse
+import shutil
+import os
+import sys
+import subprocess
+import glob
+import lalinference
+
+from configparser import ConfigParser
+
+prefix=''
+try:
+    prefix=os.environ['LALINFERENCE_DATADIR']
+except KeyError:
+    prefix=''
+
+parser = argparse.ArgumentParser(description="Runs review tests of lalinference using lalinference_pipe_example.ini.")
+
+parser.add_argument('-i','--ini_file', type=str, nargs='?',
+                    default=os.path.join(prefix,'lalinference_pipe_example.ini'),
+                    help='lalinference_pipe ini file to process.')
+
+parser.add_argument('--bns-injection', type=str, nargs='?',
+                    default=False,
+                    const=os.path.join(prefix,'fiducialBNS.xml'),
+                    help='injection file for fiducial BNS analysis.')
+
+parser.add_argument('--gracedb', action='store_true',
+                    default=False,
+                    help='Runs the analysis for the GraceDB test event T169545.')
+
+parser.add_argument('--analytic-tests', action='store_true',
+                    default=False,
+                    help='Run on the unmodal and bimodial Gaussian and Rosenbrock test functions.')
+
+parser.add_argument('--analytic-csv-dir', type=str,
+                    default=prefix,
+                    help='Directory containing the CSVs describing the analytic tests.')
+
+parser.add_argument('--pptest', action='store_true',
+                    default=False,
+                    help='Runs a P-P analysis. Must specify a single engine.')
+
+parser.add_argument('--pp-approximant', action='store', type=str,
+                    default='IMRPhenomPv2pseudoFourPN,SEOBNRv4_ROMpseudoFourPN',
+                    help='Approximant(s) used for the P-P analysis.')
+
+parser.add_argument('--bbh-injection', type=str, nargs='?',
+                    default=False,
+                    const=os.path.join(prefix,'fiducialBBH.xml'),
+                    help='injection file for fiducial BBH analysis.')
+
+parser.add_argument('-e','--engine', type=str, nargs='?',
+                    default='lalinferencemcmc,lalinferencenest',
+                    help='lalinference engine to run with.')
+
+parser.add_argument('-o','--output', type=str, nargs='?',
+                    default=None,
+                    help='output directory.')
+
+parser.add_argument('--condor-submit', action='store_true',
+                    default=False,
+                    help='submits the test suite.')
+
+args = parser.parse_args()
+
+args.ini_file = os.path.abspath(args.ini_file)
+
+if 'UNCLEAN' in lalinference.InferenceVCSInfo.vcsId:
+    default_outputdir=os.getenv('HOME')+'/lalinference_testrun/'+lalinference.InferenceVCSInfo.vcsId+'_UNCLEAN/'+args.engine+'/'
+else:
+    default_outputdir=os.getenv('HOME')+'/lalinference_testrun/'+lalinference.InferenceVCSInfo.vcsId+'/'+args.engine.replace(',','_')+'/'
+
+if args.output == None:
+    web_outputdir=default_outputdir
+    args.output=os.path.abspath(default_outputdir)
+else:
+    web_outputdir=os.path.abspath(args.output)
+    args.output=os.path.abspath(args.output)
+
+os.makedirs(args.output)
+
+if args.bns_injection:
+    args.bns_injection=os.path.abspath(args.bns_injection)
+if args.bbh_injection:
+    args.bbh_injection=os.path.abspath(args.bbh_injection)
+
+analytic_csv_dir = os.path.abspath(args.analytic_csv_dir)
+if args.analytic_tests:
+    csvs = glob.glob(analytic_csv_dir+"/*csv")
+    for csv in csvs:
+        shutil.copy(csv,args.output+'/'+os.path.basename(csv))
+
+os.chdir(args.output)
+
+lalinf_prefix=''
+try:
+    lalinf_prefix=os.environ['LALINFERENCE_PREFIX']
+except KeyError:
+    print('LALINFERENCE_PREFIX variable not defined, could not find LALInference installation.')
+    sys.exit()
+
+def init_ini_file(file=args.ini_file):
+    cp=ConfigParser()
+    fp=open(file)
+    cp.optionxform = str
+    try:
+        cp.read_file(fp)
+    except AttributeError:
+        cp.readfp(fp)
+    fp.close()
+
+    cp.set('condor','lalsuite-install',lalinf_prefix)
+    cp.set('analysis','engine',args.engine)
+    cp.remove_option('analysis','nparallel')
+
+    return cp
+
+############################################################
+
+def set_fiducial_bns(cp):
+
+    cp.set('lalinference','fake-cache',"{'H1':'LALSimAdLIGO','L1':'LALSimAdLIGO','V1':'LALSimAdVirgo'}")
+    cp.set('analysis','dataseed','1234')
+    cp.set('engine','0noise','')
+
+    cp.set('paths','webdir',web_outputdir+'/fiducialBNS/webdir/')
+    cp.set('lalinference','flow',"{'H1':40,'L1':40,'V1':40}")
+    cp.set('engine','approx','SEOBNRv4_ROMpseudoFourPN')
+    cp.set('resultspage','deltaLogP','5')
+    cp.set('engine','comp-max','3.5')
+    cp.set('engine','comp-min','0.5')
+    cp.remove_option('engine','disable-spin')
+    cp.set('engine','a_spin1-max','0.1')
+    cp.set('engine','a_spin1-min','-0.1')
+    cp.set('engine','a_spin2-max','0.1')
+    cp.set('engine','a_spin2-min','-0.1')
+    cp.set('engine','alignedspin-zprior','')
+    cp.set('engine','distance-max','500')
+    cp.set('engine','neff','500')
+    cp.set('engine','nlive','512')
+
+    return cp
+
+if args.bns_injection:
+
+    os.makedirs(args.output+'/fiducialBNS/')
+    os.chdir(args.output+'/fiducialBNS/')
+
+    shutil.copy(args.bns_injection,args.output+'/fiducialBNS/')
+    BNS_ini_file=os.path.join(args.output,'fiducialBNS','BNS.ini')
+
+    cpBNS=set_fiducial_bns(init_ini_file())
+    with open(BNS_ini_file,'w') as cpfile:
+        cpBNS.write(cpfile)
+
+    lalinferenceargs = [ 'lalinference_pipe'
+    		     , '-I'
+    		     , args.bns_injection
+    		     , '-r'
+    		     , './run'
+    		     , '-p'
+    		     , './daglog'
+    		     , BNS_ini_file ]
+
+    if args.condor_submit:
+        lalinferenceargs.append('--condor-submit')
+
+    subprocess.call(lalinferenceargs)
+
+###################################################
+
+def set_GraceDB(cp):
+
+    cp.set('analysis','upload-to-gracedb','True')
+    cp.set('paths','webdir',web_outputdir+'/GraceDB/webdir/')
+
+    cp.set('datafind','types',"{'H1':'H1_HOFT_C00','L1':'L1_HOFT_C00','V1':'V1Online'}")
+    cp.set('data','channels',"{'H1':'H1:GDS-CALIB_STRAIN','L1':'L1:GDS-CALIB_STRAIN','V1':'V1:FAKE_h_16384Hz_4R'}")
+
+    cp.set('engine','distance-max','300')
+
+    return cp
+
+if args.gracedb:
+
+    os.makedirs(args.output+'/GraceDB/')
+    os.chdir(args.output+'/GraceDB/')
+
+    GDB_ini_file=os.path.join(args.output,'GraceDB','GDB.ini')
+
+    cpGDB=set_GraceDB(init_ini_file())
+    with open(GDB_ini_file,'w') as cpfile:
+        cpGDB.write(cpfile)
+
+    lalinferenceargs = [ 'lalinference_pipe'
+                         , '--gid'
+                         , 'T169545'
+                         , '-r'
+                         , './run'
+                         , '-p'
+                         , './daglog'
+                         , GDB_ini_file ]
+
+    if args.condor_submit:
+        lalinferenceargs.append('--condor-submit')
+
+    subprocess.call(lalinferenceargs)
+
+############################################################
+
+def set_fiducial_bbh(cp):
+
+    cp.set('lalinference','fake-cache',"{'H1':'LALSimAdLIGO','L1':'LALSimAdLIGO','V1':'LALSimAdVirgo'}")
+    cp.set('analysis','dataseed','1234')
+    cp.set('engine','0noise','')
+    cp.remove_option('engine','margphi')
+
+    cp.set('paths','webdir',web_outputdir+'/fiducialBBH/webdir/')
+    #cp.set('lalinference','flow',"{'H1':40,'L1':40,'V1':40}")
+    cp.set('engine','approx','IMRPhenomPv2pseudoFourPN')
+    cp.set('analysis','roq','True')
+    cp.remove_option('engine','disable-spin')
+    cp.set('resultspage','deltaLogP','6')
+    cp.set('engine','distance-max','1000')
+    cp.set('engine','inj-fref','100')
+
+    cp.set('engine','neff','500')
+    cp.set('engine','nlive','512')
+
+    return cp
+
+if args.bbh_injection:
+
+    os.makedirs(args.output+'/fiducialBBH/')
+    os.chdir(args.output+'/fiducialBBH/')
+
+    shutil.copy(args.bbh_injection,args.output+'/fiducialBBH/')
+    BBH_ini_file=os.path.join(args.output,'fiducialBBH','BBH.ini')
+
+    cpBBH=set_fiducial_bbh(init_ini_file())
+    with open(BBH_ini_file,'w') as cpfile:
+        cpBBH.write(cpfile)
+
+    lalinferenceargs = [ 'lalinference_pipe'
+                         , '-I'
+                         , args.bbh_injection
+                         , '-r'
+                         , './run'
+                         , '-p'
+                         , './daglog'
+                         , BBH_ini_file ]
+
+    if args.condor_submit:
+        lalinferenceargs.append('--condor-submit')
+
+    subprocess.call(lalinferenceargs)
+
+############################################################
+def set_analytic_test(cp, test_func):
+
+    cp.set('paths','webdir',web_outputdir+'/'+test_func+'/webdir/')
+    cp.set('lalinference','fake-cache',"{'H1':'LALSimAdLIGO','L1':'LALSimAdLIGO','V1':'LALSimAdVirgo'}")
+    cp.set('analysis','dataseed','1234')
+
+    cp.set('input','analyse-all-time','True')
+    cp.set('input','gps-start-time','0')
+    cp.set('input','gps-end-time','2')
+    cp.set('input','segment-overlap','0')
+    cp.set('input','psd-length','1')
+
+    cp.set('engine','seglen','1')
+    cp.set('engine','approx','SpinTaylorT4')
+    cp.set('engine',test_func,'')
+    cp.set('engine','neff','10000')
+    cp.set('engine','nlive','2048')
+
+    cp.set('resultspage','deltaLogP','7')
+    if test_func != "rosenbrockLikelihood":
+        csv = args.output+'/'+test_func+'_means.csv'
+        if os.path.isfile(csv):
+            cp.set('resultspage','meanVectors',csv)
+        csv = args.output+'/'+'test_correlation_matrix.csv'
+        if os.path.isfile(csv):
+            cp.set('resultspage','covarianceMatrix',csv)
+
+    return cp
+
+if args.analytic_tests:
+    test_funcs = ['correlatedGaussianLikelihood', 'bimodalGaussianLikelihood', 'rosenbrockLikelihood']
+    for test_func in test_funcs:
+        os.makedirs(args.output+'/' + test_func + '/')
+        os.chdir(args.output+'/' + test_func + '/')
+
+
+        analytic_ini_file=os.path.join(args.output,test_func,'analytic.ini')
+
+        cpanalytic=set_analytic_test(init_ini_file(), test_func)
+        with open(analytic_ini_file,'w') as cpfile:
+            cpanalytic.write(cpfile)
+
+        lalinferenceargs = [ 'lalinference_pipe'
+                             , '-r'
+                             , './run'
+                             , '-p'
+                             , './daglog'
+                             , analytic_ini_file ]
+
+        if args.condor_submit:
+            lalinferenceargs.append('--condor-submit')
+
+        subprocess.call(lalinferenceargs)
+
+############################################################
+
+def set_pptest(cp, engine, approximant):
+
+    cp.set('paths','webdir', os.path.join(web_outputdir, 'pptest', engine, approximant, 'webdir/'))
+    cp.set('ppanalysis','webdir', os.path.join(web_outputdir, 'PPcheck', engine, approximant + '/'))
+    cp.set('lalinference','fake-cache',"{'H1':'LALSimAdLIGO','L1':'LALSimAdLIGO','V1':'LALSimAdVirgo'}")
+    cp.set('analysis','dataseed','1234')
+    cp.set('analysis', 'engine', engine)
+
+    cp.remove_option('engine','margphi')
+    cp.set('engine','margtime','')
+    cp.set('engine','amporder','-1')
+    cp.set('engine','fref','0')
+    cp.set('engine','distance-max','2000')
+    cp.set('engine', 'approx', approximant)
+
+    cp.set('resultspage','deltaLogP','7')
+
+    return cp
+
+if args.pptest:
+
+    # The PP test needs a single engine to be specified
+    for engine in args.engine.split(','):
+        for approximant in args.pp_approximant.split(','):
+            os.makedirs(os.path.join(args.output, 'pptest', engine, approximant + '/'))
+            os.chdir(os.path.join(args.output, 'pptest', engine, approximant + '/'))
+
+            pptest_ini_file=os.path.join(args.output, 'pptest', engine, approximant, 'pptest.ini')
+
+            cppptest=set_pptest(init_ini_file(), engine=engine,
+                                approximant=approximant)
+            with open(pptest_ini_file,'w') as cpfile:
+                cppptest.write(cpfile)
+
+            lalinferenceargs = [ 'lalinference_pp_pipe'
+                                 , '-r'
+                                 , './run'
+                                 , '-N'
+                                 , '100'
+                                 , pptest_ini_file ]
+
+            subprocess.call(lalinferenceargs)
+
+            if args.condor_submit:
+                condor_submit_dag = ['condor_submit_dag', os.path.join(args.output, 'pptest', engine, approximant, 'run/priortest.dag')]
+                subprocess.call(condor_submit_dag)

lalsuite-7.26.2.dev20251218.data/scripts/lalinference_version

@@ -0,0 +1,6 @@
+#!python
+import os
+import sys
+from importlib.resources import files, as_file
+with as_file(files('lalapps') / 'bin' / 'lalinference_version') as path:
+    os.execv(path, sys.argv)