prstools 0.0.3__tar.gz

prstools-0.0.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Menno Witteveen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

prstools-0.0.3/MANIFEST.in

@@ -0,0 +1,5 @@
+include settings.ini
+include LICENSE
+include CONTRIBUTING.md
+include README.md
+recursive-exclude * __pycache__

prstools-0.0.3/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.1
+Name: prstools
+Version: 0.0.3
+Summary: Convenient and powerfull Polygenic Risk Score creation.
+Home-page: https://github.com/mennowitteveen/prstools
+Author: Menno Witteveen et al.
+Author-email: menno102@hotmail.com
+License: MIT License
+Keywords: PRS PGS polygenic genomics prediction genetics
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: tqdm
+Requires-Dist: h5py
+Requires-Dist: ipython
+Provides-Extra: dev
+Requires-Dist: nbdev; extra == "dev"
+Provides-Extra: full
+Requires-Dist: mjwt; extra == "full"
+Requires-Dist: pysnptools; extra == "full"
+Requires-Dist: seaborn; extra == "full"
+
+# prstools
+
+<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
+
+`prstools` is software to create Polygenic Risk Scores (PRS) directly
+from the commandline <br> (and optionally from inside python).
+
+It contains various tools to make PRS generation easier. Installation
+and running the demo example should not take more than 10 minutes.

prstools-0.0.3/README.md

@@ -0,0 +1,9 @@
+# prstools
+
+<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
+
+`prstools` is software to create Polygenic Risk Scores (PRS) directly
+from the commandline <br> (and optionally from inside python).
+
+It contains various tools to make PRS generation easier. Installation
+and running the demo example should not take more than 10 minutes.

prstools-0.0.3/prstools/__init__.py

@@ -0,0 +1,40 @@
+__version__ = "0.0.2"
+_date = "18-02-2025"
+# from . import *
+
+# from . import models
+# from . import loaders
+# from . import utils
+# from . import _cmd as cmd
+
+# import .models
+# from models import __
+# from . import models.L2Pred
+# 
+import importlib as _importlib  # Import takes around 6 microseconds
+
+# List of submodules to be included
+_submodules = [
+    '_cmd',
+    'loaders',
+    'models',
+    'utils'
+]
+
+__all__ = _submodules + [
+    # 'LowLevelCallable',
+    # 'test',
+    # 'show_config',
+    '__version__',
+]
+
+def __dir__():
+    return __all__
+
+def __getattr__(name):
+    if name in _submodules:
+        return _importlib.import_module(f'prstools.{name}')
+    try:
+        return globals()[name]
+    except KeyError:
+        raise AttributeError(f"Module 'prstools' has no attribute '{name}'")

prstools-0.0.3/prstools/_cmd.py

@@ -0,0 +1,352 @@
+import os, time, sys, argparse, json
+
+    
+def set_cpu_envvars(cpus=1):
+    if cpus != -1: # disabling.
+        #MKL_NUM_THREADS=1 NUMEXPR_NUM_THREADS=1 OMP_NUM_THREADS=1 OPENBLAS_NUM_THREADS=1
+        print(f'Setting environmental variables to control number of cpus used (={cpus}).')
+        n_cores = cpus # Correction, this does do something, although its quite opaque
+        os.environ['OPENBLAS_NUM_THREADS'] = str(n_cores)
+        os.environ['MKL_NUM_THREADS'] = str(n_cores)  # For Intel MKL
+        os.environ['OMP_NUM_THREADS'] = str(n_cores)
+        os.environ['NUMEXPR_NUM_THREADS'] = str(n_cores)  # For NumExpr
+#         os.environ['OMP_DYNAMIC'] = 'FALSE' 
+#         os.environ['OMP_THREAD_LIMIT'] = str(n_cores)
+#         os.environ['OMP_NESTED'] = 'FALSE'
+#         os.environ['OMP_PROC_BIND'] = 'TRUE'
+    else:
+        print('Skipping the setting of environmental variables')
+        
+        
+##################################################### BEST IF THIS IS ALREADY DONE BY THE TIME THIS CODE RUNS ############
+        
+## CLI mechanics functionality:
+def process_subparserkwgs(subparserkwg_lst):
+    from textwrap import dedent
+    for i, spkwg in enumerate(subparserkwg_lst):
+        if type(spkwg) is type({}): continue
+        elif 'PRSTCLI' in str(getattr(spkwg,'__bases__','')):
+            new_spkwg = spkwg._get_cli_spkwg()
+            subparserkwg_lst[i] = new_spkwg
+        elif 'BasePred' in str(getattr(spkwg,'__bases__','')):
+            from .utils import retrieve_pkwargs
+            doc = dedent(spkwg.__doc__)
+            new_spkwg = dict(
+                cmdname    = spkwg.__name__.lower(), #command name
+                clsname    = spkwg.__name__, #class name
+                description= doc,
+                help       = doc.split('\n')[0],
+                epilog     = spkwg._get_cli_epilog(),
+                module     = spkwg.__module__,
+                pkwargs    = retrieve_pkwargs(spkwg),
+                subtype    = 'BasePred'
+            )
+            subparserkwg_lst[i] = new_spkwg
+        else: 
+            print(str(getattr(spkwg,'__bases__','')))
+            raise NotImplementedError('Contact dev.') 
+    return subparserkwg_lst
+def retrieve_classmethod(*, clsname, methodname, modulename='prstools.models'):
+    #models = importlib.reload(models)
+    def pipefun(*args,**kwargs):
+        import importlib
+        cls = getattr(importlib.import_module(modulename), clsname)
+        return getattr(cls,methodname)(*args,**kwargs)
+    return pipefun
+def process_argkwargs(kwargs, setverbosetrue=False):
+    kwargs = kwargs.copy() 
+    kwargs['help'] = argparse.SUPPRESS if kwargs.get('help', None) is None else kwargs['help']
+    if kwargs.get('type',None) is bool:
+        if not kwargs['default']:
+            kwargs.pop('type')
+            kwargs['action']='store_true'
+            kwargs['default'] = argparse.SUPPRESS
+        if setverbosetrue:
+            raise NotImplementedError()
+    if 'default' in kwargs and kwargs['default'] == 'SUPPRESS':
+        kwargs['default'] = argparse.SUPPRESS
+    if (kwargs['help'] != argparse.SUPPRESS):
+        if not (kwargs.get('default', 'idontexist') in ['idontexist', argparse.SUPPRESS]):
+            kwargs['help'] += f" (default: {kwargs.pop('default')})"
+        if 'required' in kwargs:
+            if kwargs['required'] is True:
+                kwargs['help'] = kwargs['help'] + ' (required)'
+#                 kwargs['help'] = '* '+kwargs['help'] + format_bold(' (required)')
+    return kwargs
+def format_color(text, color_code): return f"\033[{color_code}m{text}\033[0m"
+def format_bold(text): return f"\033[1m{text}\033[0m"
+##################################################### BEST IF THIS IS ALREADY DONE BY THE TIME THIS CODE RUNS ############
+
+
+
+## Formatting functionality:
+class CustomArgumentParser(argparse.ArgumentParser):
+    
+        def format_usage(self):
+            usage = super().format_usage()
+            return self.usage_optionals_formattingx(usage)
+        def format_help(self):
+            string = super().format_help()
+            string = self.usage_optionals_formattingx(string)
+            return string.replace('usage:','\nUsage:\n')
+        
+        def usage_optionals_formattingx(self, string):
+#             print(string.find('\n'))
+#             loc = max(string.find('[-h]'), 0)
+#             print(loc*'-')
+            string = string.replace('] [','  ')
+#             string = string.replace('> [','>\n'+loc*'-'+'[')
+            return string
+class CustomFormatter(argparse.ArgumentDefaultsHelpFormatter,argparse.RawDescriptionHelpFormatter): #, argparse.RawDescriptionHelpFormatter):
+    def __init__(self, prog, indent_increment=1, max_help_position=60, width=None, minwidth=0):
+        if not width: 
+            import shutil # Width processing
+            width = shutil.get_terminal_size().columns-2
+            width = max(width, minwidth)
+        _excl_lst = ['self', 'kwg_dt','_excl_lst','CustomFormatter','__class__','minwidth', 'shutil']
+        kwg_dt = {key: item for key, item in locals().items() if not (key in _excl_lst)}
+        super(CustomFormatter, self).__init__(**kwg_dt) #prog, indent_increment=indent_increment, max_help_position=max_help_position, width=width)      
+
+    def _get_default_metavar_for_optional(self, action):
+        return '<'+action.dest+'>' #.upper()
+
+    def _format_action_invocation(self, action):
+        if not action.option_strings:
+            metavar, = self._metavar_formatter(action, action.dest)(1)
+            return metavar
+        else:
+            parts = []
+            if action.nargs == 0:
+                parts.extend(action.option_strings)
+            else:
+                default = '<'+action.dest+'>'#.upper()
+                args_string = self._format_args(action, default)
+                parts.extend(action.option_strings)
+                parts = parts[::-1]
+                parts[-1] += ' %s' % args_string
+#                 if parts[-1] in ['']
+#             if action.required: return '\b\b* '+', '.join(parts)
+            return ', '.join(parts)
+
+def parse_args(argv=None, description="Convenient and powerfull Polygenic Risk Score creation. \n\'prst\' is a commandline shorthand for \'prstools\'",
+               subparserkwg_lst=None, basecmd='prstools', return_spkwg=False, reload=False):
+    
+    # Prepare parsing params:
+    if argv is None: argv=sys.argv[1:]; basecmd=sys.argv[0]
+    #from prstools.models import L2Pred, PRSCS
+    #subparserkwg_lst = [L2Pred, PRSCS]
+    if subparserkwg_lst is None:
+        if reload: import importlib; from prstools import _parser_vars; importlib.reload(_parser_vars)
+        from prstools._parser_vars import subparserkwg_lst
+    else:
+        subparserkwg_lst=process_subparserkwgs(subparserkwg_lst)
+        # subparserkwg_lst contains the information to construct parsers
+        # This is generated from model code by the developer and saved
+
+    # Construct Parser:
+    parser = CustomArgumentParser(
+        description=description,
+        argument_default=argparse.SUPPRESS,
+        add_help=False,
+        formatter_class=CustomFormatter
+    )
+    general_group = parser.add_argument_group('General Options')
+    parser.add_argument('-h', '--help', action='help', default=argparse.SUPPRESS, help=argparse.SUPPRESS) # , help='Show help')
+
+    
+    if return_spkwg: return subparserkwg_lst
+    
+    def prscsx_linkfun(**kwg): from prstools.PRScsx.PRScsx import main; sys.argv = sys.argv[1:]; main()
+    def prscs_linkfun(**kwg): from prstools.PRScs.PRScs import main; sys.argv = sys.argv[1:]; main()        
+    xtr = dict(subtype='external')
+    ext_lst = [dict(cmdname='prscsx',help="PRS-CSx (original): A cross-population polygenic prediction method with continuous shrinkage "
+                    "(CS) priors trained with multiple GWAS summary statistics.",func=prscsx_linkfun, **xtr),
+               dict(cmdname='prscs',help="PRS-CS (original): A polygenic prediction method with continuous shrinkage (CS) priors trained with GWAS summary statistics.", func=prscs_linkfun, **xtr)]
+    subparserkwg_lst += ext_lst
+        
+    # Add Subparser structure:
+    subparser = parser.add_subparsers(title="Models & Utility Commands", dest="command", metavar='<command>'+' \b'*2, help="") #trick: +' \b'*0
+    extcmds = []; prc = process_argkwargs
+    for i, spkwg in enumerate(subparserkwg_lst):
+        if spkwg['subtype'] == 'BasePred':
+            # Create Model parser and add basic help:
+            model_parser = subparser.add_parser(spkwg['cmdname'], help=spkwg['help'],
+                                                description=spkwg['description'],
+                                                epilog=spkwg['epilog'],
+                                                formatter_class=CustomFormatter,
+                                                argument_default=argparse.SUPPRESS,
+                                                add_help=False)
+            
+            modelgeneral_group = model_parser.add_argument_group('General Options')
+            modelgeneral_group.add_argument('-h', '--help', action='help', help='Show this help message and exit.') #default=argparse.SUPPRESS
+            # WARNING!: there is still something wrong with the default of this --cpus cli argument, it does not seem to get pushed into the setting of the number of cores function.
+            modelgeneral_group.add_argument('--cpus', '-c', **prc(dict(metavar='<number-of-cpus>', default=-1, type=int, help='The number of cpus to use. This will generate environmental variables inside \
+                                    of the python session, which will control the number of used cores. Functionality can be turned-off completely, by setting it to -1.\
+                                    (devnote: for default=1 some things have to be modified) ')))
+            
+            # Add data related kwargs:
+            data_group = model_parser.add_argument_group('Data Arguments (first 5 required)')
+            data_group.add_argument("--ref","--ref_dir","-r", 
+                    **prc(dict(required=True, metavar='<dir/refcode>', 
+                        help="Path to the directory that contains the LD reference panel. You can download this reference data "
+                               f"manually with \'{basecmd} downloadref\'. Soon it will be possible to automatically download it on the fly.")))
+            data_group.add_argument("--target", "--bim_prefix", "-t", 
+                    **prc(dict(required=True, metavar='<bim-prefix>', 
+                        help="Specify the directory and prefix of the bim file for the target dataset.")))
+            data_group.add_argument("--sst","--sst_file","-s", **prc(dict(required=True, metavar='<file>', 
+                        help="The summary statistics file from which the model will be created. The file should contain columns: SNP, A1, A2, BETA or OR, P or SE information. "
+                              "At the moment, the file is assumed to be tab-seperated, if you like other formats please let devs know."
+                             f"Alternative column names can be specified with --columns (more info below). SNP column should contain rsid\'s. "
+                             f"See {format_color('https://tinyurl.com/sstxampl','34')} for an example.")))
+            data_group.add_argument("--out","--out_dir","-o", 
+                    **prc(dict(required=True, metavar='<dir+prefix>', 
+                        help="Output prefix for the results (variant weights). This should be a combination of the desired output dir and file prefix.")))
+            data_group.add_argument("--n_gwas","-n", 
+                    **prc(dict(required=False, type=int, metavar='<num>', default=None,
+                        help="Sample size of the GWAS. Not required if sumstat has a 'N' column.")))
+            data_group.add_argument("--chrom", #lambda x: x.split(',')
+                        type=str, metavar='<chroms>', default='all', 
+                        help="Optional: Select specific chromosome to work with. You can specify a specific chromosome as e.g. \"--chrom 3\". All chromosomes are used by default.")
+            data_group.add_argument("--colmap", #lambda x: x.split(',')
+                        type=str, metavar='<alternative_colnames>',
+                        help="Optional: Allows one to specify an alterative column name for columns SNP,A1,A2,BETA,OR,P,SE,N (in that order). "
+                                    "Forinstance \"--colmap rsid,a1,a2,beta_gwas,,pvalue,beta_standard_error,\" (OR & N are excluded in this example). "
+                                    "When the command is run a quick this_column -> that_column conversion table will be shown. "
+                                    "Additionaly prstools has many internal checks to make sure a good PRS will be generated! ")
+
+            # Add model-related arguments (hyper parameters and such):
+            modelargs_group = model_parser.add_argument_group('Model Arguments (all optional)')
+            for argname, item in spkwg['pkwargs'].items():
+#                 if argname == 'n_iter':ergerg
+                #cargs, ckwargs = process_pkwargs(item) << -- underconstruction, need 2 add verbose=True
+                modelargs_group.add_argument(*item['args'], **process_argkwargs(item['kwargs']))
+            # Below 'func' contains a delayed import of a classmethod that can run the full method from arg
+            # This means the import (which can be slow) will take place only when run, leading to big speedups 
+            # and a snappy cmdline tool, which is nice for users. In case the model is PRSCS2 it in effect says:
+            # ..  .set_defaults(func=PRSCS2.run_from_cli_params_thiswholenamecouldchange_imasocalledclassmethod, .. etc
+            func = retrieve_classmethod(clsname=spkwg['clsname'], methodname='from_cli_params_and_run')
+            model_parser.set_defaults(func=func, pkwargs=spkwg['pkwargs'], model_parser=model_parser)
+        elif spkwg['subtype'] == 'function':
+            funct_parser = subparser.add_parser(spkwg['cmdname'], help=spkwg['help'],
+                                                description=spkwg['description'],
+                                                formatter_class=CustomFormatter,
+                                                argument_default=argparse.SUPPRESS,
+                                                add_help=False)
+            general_group = funct_parser.add_argument_group('Options')
+            general_group.add_argument('-h', '--help', action='help', help='Show this help message and exit.')
+            for argname, item in spkwg['pkwargs'].items():
+                general_group.add_argument(*item['args'], **process_argkwargs(item['kwargs']))
+            func = globals()[spkwg['cmdname']]
+            funct_parser.set_defaults(func=func)
+        elif spkwg['subtype'] == 'external':
+            linked_parser = subparser.add_parser(spkwg['cmdname'], help=spkwg['help'], description='unneeded', add_help=False) #, description='descption prscx')
+            linked_parser.set_defaults(func=spkwg['func'])
+            extcmds+=[spkwg['cmdname']] 
+        elif spkwg['subtype'] == 'PRSTCLI':
+            subcmd_parser = subparser.add_parser(spkwg['cmdname'], help=spkwg['help'],
+                                    description=spkwg['description'],
+                                    epilog=spkwg['epilog'],
+                                    formatter_class=CustomFormatter,
+                                    argument_default=argparse.SUPPRESS,
+                                    add_help=False)
+            
+            # Add groups and respective arguments:
+            for grpname, grpkwg in spkwg['groups'].items():
+                cur_group = subcmd_parser.add_argument_group(grpkwg['grpheader'])
+                for argname, item in grpkwg['pkwargs'].items():
+                    cur_group.add_argument(*item['args'], **process_argkwargs(item['kwargs']))
+            
+            # Set func to be linked to all the args:
+            func = retrieve_classmethod(modulename=spkwg['modulename'], clsname=spkwg['clsname'], methodname='from_cli_params_and_run')
+            subcmd_parser.set_defaults(func=func) # Yes it needs to b
+        else:
+            raise Exception('Subparser subtype not recognized, Contact dev.')
+    
+    # Commence actual parsing:
+    if len(argv)<2: argv+=['-h']
+    knargs, _ = parser.parse_known_args(argv)
+    if knargs.command in extcmds:
+        return knargs
+    else:
+        args = parser.parse_args(argv)
+        return args
+# import json      
+def main(argv=None):
+
+    if argv is None: argv=sys.argv[1:]
+    args = parse_args(argv)
+    display_info = True if 'pkwargs' in args else False
+    from prstools import __version__, _date# as version, date
+    timestampfmt = "%a, %d %b %Y %H:%M:%S %z"
+    if display_info:
+        param_dt = vars(args)
+        topstr = '\n'.join([
+            f'PRSTOOLS v{__version__} ({_date})',
+            f'Running command: {args.command}',
+            f'Options in effect:'
+        ])
+        print(topstr)
+        for act in  args.model_parser._actions:
+            key = act.dest
+            if not key in param_dt: continue
+            item = param_dt[key]
+            fun = lambda: item is args.pkwargs[key]['kwargs'].get('default',None)
+            cond0 = fun() if key in args.pkwargs else False
+            if cond0 or key in ['func','pkwargs','command','model_parser']: continue
+            pitem = item if type(item) is not bool else ''
+            print('  --%s %s' % (key, pitem))
+        print()
+
+    args_dt = vars(args)
+    # Need to happen here because it needs to happen before numpy/scipy is imported:
+    if 'cpus' in args_dt: set_cpu_envvars(**{key:item for key, item in args_dt.items() if key=='cpus'})
+    # Initialize logs and grab certain parts:
+    from prstools.utils import get_prstlogs; import pandas as pd; import socket
+    start = pd.Timestamp.now(); hostname = socket.gethostname(); cwd=os.getcwd()
+    prstlogs = get_prstlogs()
+    prstlogs['__version__'] = __version__
+    prstlogs['times']['start'] = start
+    prstlogs['cwd']      = cwd
+    prstlogs['hostname'] = hostname
+    prstlogs['argv'] = argv
+    #prstlogs['args_dt'] = args_dt
+    if display_info:
+        envstr = '\n'.join([
+        f'Hostname:          {hostname}',
+        f'Working directory: {cwd}',
+        f'Start time:        {start.strftime(timestampfmt)}',
+        f'']) #Just empty line for spacing
+        print(envstr)
+    
+    # Run the actual task:
+    result = args.func(**args_dt)
+    
+    # Some post main-task things:
+    stop = pd.Timestamp.now(); prstlogs['times']['stop'] = stop; prstlogs.finish()
+    if display_info: print(f'End time: {stop.strftime(timestampfmt)}',)
+    # add return functionality later
+
+if '_isdevenv_prstools' in locals() or '--dev' in sys.argv:
+    
+    if 'In' in locals():
+        with open('../prstools/_cmd.py', 'w') as f: f.write(In[-1])
+        print('Written to:', f.name); 
+        
+    from prstools import models, utils; import importlib
+    importlib.reload(models); importlib.reload(utils)
+
+    try:
+        from prstools.models import XPRS, PRSCS2, SPRSCS, PredPRS, Dentist, SNPFilter
+        from prstools.utils import DownloadUtil, store_argparse_dicts , Combine
+        store_argparse_dicts([DownloadUtil, Combine,
+                              XPRS, PRSCS2, SPRSCS, PredPRS, Dentist, SNPFilter
+                              ])
+        print('Saved new argparse dict. (mind: dont forget the suppress mechanism, this is something in the argparse-dict processing)')
+    except Exception as e: 
+        print(e, 'Import issue.'); raise e
+
+    if 'In' in locals():
+        get_ipython().system('time python ../prstools/_cmd.py | tail -1 #l2pred # afster a  normal pip install, !time prst seems to have parity with this faster approach.')
+else:
+    if __name__ == '__main__':
+        main()