cutehap 1.0.0__tar.gz

cutehap-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 JiangTao
+
+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.

cutehap-1.0.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: cutehap
+Version: 1.0.0
+Summary: Haplotype-resolved genomic structural variation detection with cuteHap
+Home-page: https://github.com/Meltpinkg/cuteHap
+Author: Shuqi Cao
+Author-email: sqcao@stu.hit.edu.cn
+License: MIT
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: scipy
+Requires-Dist: pysam
+Requires-Dist: Biopython
+Requires-Dist: Cigar
+Requires-Dist: numpy
+Requires-Dist: Cython
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+# cuteHap
+
+A haplotype-resolved SV detector in phased long read sequencing data.
+
+---
+### Installation
+We recommand the installation via conda or pip:
+```
+    The installation via conda and pypi is now in construction.
+```
+Alternatively, installing from source with:
+```
+    git clone https://github.com/Meltpinkg/cuteHap.git
+    cd cuteHap
+    CFLAGS="-std=c99" python setup.py install
+```
+
+---	
+### Introduction
+cuteHap detects germline or mosaic structural variations (SVs) through phased long reads sequencing alignments. 
+
+---
+### Dependence
+	
+	1. python3
+ 	2. scipy
+	2. pysam
+	3. Biopython
+	4. cigar
+	5. numpy
+	6. Cython
+
+---
+### Quick Start
+```
+cuteHap <phased.bam> <reference.fa> <output.vcf> <workdir>
+```
+
+---
+### Changelog
+    cuteHap (v1.0.0)
+    1. the initial version of cuteHap
+
+---
+### Contact
+For advising, bug reporting and requiring help, please post on [Github Issue](https://github.com/Meltpinkg/cuteHap/issues) or contact sqcao@stu.hit.edu.cn.

cutehap-1.0.0/README.md

@@ -0,0 +1,46 @@
+# cuteHap
+
+A haplotype-resolved SV detector in phased long read sequencing data.
+
+---
+### Installation
+We recommand the installation via conda or pip:
+```
+    The installation via conda and pypi is now in construction.
+```
+Alternatively, installing from source with:
+```
+    git clone https://github.com/Meltpinkg/cuteHap.git
+    cd cuteHap
+    CFLAGS="-std=c99" python setup.py install
+```
+
+---	
+### Introduction
+cuteHap detects germline or mosaic structural variations (SVs) through phased long reads sequencing alignments. 
+
+---
+### Dependence
+	
+	1. python3
+ 	2. scipy
+	2. pysam
+	3. Biopython
+	4. cigar
+	5. numpy
+	6. Cython
+
+---
+### Quick Start
+```
+cuteHap <phased.bam> <reference.fa> <output.vcf> <workdir>
+```
+
+---
+### Changelog
+    cuteHap (v1.0.0)
+    1. the initial version of cuteHap
+
+---
+### Contact
+For advising, bug reporting and requiring help, please post on [Github Issue](https://github.com/Meltpinkg/cuteHap/issues) or contact sqcao@stu.hit.edu.cn.

cutehap-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cutehap-1.0.0/setup.py

@@ -0,0 +1,29 @@
+# coding=utf-8
+
+from setuptools import setup, find_packages
+from Cython.Build import cythonize
+
+with open('README.md') as f:
+    readme = f.read()
+
+cython_extensions = cythonize("src/cuteHap/*.pyx")
+
+setup(
+    name = "cutehap",
+    version = "1.0.0",
+    description = "Haplotype-resolved genomic structural variation detection with cuteHap",
+    author = "Shuqi Cao",
+    author_email = "sqcao@stu.hit.edu.cn",
+    url = "https://github.com/Meltpinkg/cuteHap",
+    license = "MIT",
+    packages = find_packages("src"),
+    package_dir = {"": "src"},
+    data_files = [("", ["LICENSE"])],
+    scripts=['src/cuteHap/cuteHap'],
+    # long_description = LONG_DESCRIPTION,
+    long_description = readme,
+    long_description_content_type = 'text/markdown',
+    zip_safe = False,
+    install_requires = ['scipy', 'pysam', 'Biopython', 'Cigar', 'numpy', 'Cython'],
+    ext_modules=cython_extensions
+)

cutehap-1.0.0/src/cuteHap/CommandRunner.py

@@ -0,0 +1,151 @@
+from string import Template
+import tempfile
+import subprocess, signal, logging, os, stat, sys
+
+class Alarm(Exception):
+    pass
+
+def alarm_handler(signum, frame):
+    raise Alarm
+    
+def setupLogging(debug=False):
+    logLevel = logging.DEBUG if debug else logging.INFO
+    logFormat = "%(asctime)s [%(levelname)s] %(message)s"
+    logging.basicConfig( stream=sys.stderr, level=logLevel, format=logFormat )
+    logging.info("Running %s" % " ".join(sys.argv))
+
+def exe(cmd, timeout=-1):
+    """
+    Executes a command through the shell.
+    timeout in minutes! so 1440 mean is 24 hours.
+    -1 means never
+    """
+    proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, \
+                            stderr=subprocess.STDOUT, close_fds=True,\
+                            preexec_fn=os.setsid)
+    signal.signal(signal.SIGALRM, alarm_handler)
+    if timeout > 0:
+        signal.alarm(int(timeout*60))  
+    try:
+        stdoutVal, stderrVal =  proc.communicate()
+        signal.alarm(0)  # reset the alarm
+    except Alarm:
+        logging.error(("Command was taking too long. "
+                       "Automatic Timeout Initiated after %d" % (timeout)))
+        os.killpg(proc.pid, signal.SIGTERM)
+        proc.kill()
+        return 214,None,None
+    
+    retCode = proc.returncode
+    return retCode,stdoutVal,stderrVal
+
+class Command():
+    def __init__(self, cmd, jobname, stdout, stderr):
+        self.cmd = cmd
+        self.jobname = jobname
+        self.stdout = stdout
+        self.stderr = stderr
+    
+    def asDict(self):
+        return {"CMD":self.cmd, "JOBNAME":self.jobname, \
+                "STDOUT":self.stdout, "STDERR":self.stderr}
+    
+class CommandRunner():
+    """
+    Uses a command template to run stuff. This is helpful for cluster commands
+    and chunking several commands together
+    """
+    def __init__(self, template=None, njobs=0):
+        """
+        template: a string that will become the template for submitting to your cluster:
+            #you can also go ahead and specify a string.Template
+            default is to not submit to your cluster
+            ${CMD} > ${STDOUT} 2> ${STDERR}
+        njobs: (0)
+            for clumping commands together and submitting them in a script
+        """
+        if template is None:
+            template = "${CMD} > ${STDOUT} 2> ${STDERR}"
+            self.runType = "Running"
+        else:
+            self.runType = "Submitting"
+        self.template = Template(template)
+        self.njobs = njobs
+    
+    def __call__(self, cmds, wDir = None, id = None):
+        """
+        Executes Commands - can either be a list or a single Command
+        wDir is the working directory where chunk scripts will be written
+        if id is None a random identifier will be applied when chunking
+        """
+        if wDir is None:
+            wDir = "./"
+        
+        if type(cmds) != list:
+            cmd = self.buildCommand(cmds)
+            return exe(cmd)
+        
+        if self.njobs == 0:
+            outRet = []
+            for c in cmds:
+                outRet.append(exe(self.buildCommand(c)))
+            return outRet
+        
+        if id is None:
+            id = tempfile.mkstemp(dir=wDir)[1]
+        
+        outputRet =[]
+        for chunk, commands in enumerate( partition(cmds, self.njobs) ):
+            outScript = open(os.path.join(wDir, "%s_chunk%d.sh" % (id, chunk)),'w')
+            outScript.write("#!/bin/bash\n\n")
+            for c in commands:
+                outScript.write(c.cmd+"\n")
+            outScript.close()
+            #Add executeable 
+            existing_permissions = stat.S_IMODE(os.stat(outScript.name).st_mode)
+            if not os.access(outScript.name, os.X_OK):
+                new_permissions = existing_permissions | stat.S_IXUSR
+                os.chmod(outScript.name, new_permissions)
+                
+            submit = Command(outScript.name, \
+                            id + "_chunk%d" % chunk, \
+                            os.path.join(wDir, id + ("_chunk%d.out" % chunk)), \
+                            os.path.join(wDir, id + ("_chunk%d.err" % chunk)))
+            cmd = self.buildCommand(submit)
+            outputRet.append(exe(cmd))
+            
+        return outputRet
+        
+    def checkTemplate(self):
+        """
+        Checks that my template works okay
+        """
+        temp.update({"CMD":"test", \
+                     "STDOUT":"testo", \
+                     "STDERR":"teste", \
+                     "JOBNAME":"testn"})
+        try:
+            w = self.template.substitute(temp)
+        except KeyError:
+            logging.error("Your submission template is invalid ")
+            sys.exit(1)
+
+    def buildCommand(self, cmdSetup):
+        """
+        substitutes a template with a Command
+        """
+        return self.template.substitute(cmdSetup.asDict())
+
+def partition(n,m):
+    """
+    Helper function. splits list n into m partitions
+    """
+    p = map(lambda x: list(), range(m))
+    index = 0
+    for item in n:
+        p[index].append(item)
+        if index < m-1:
+            index += 1
+        else:
+            index = 0
+    return filter(lambda x: len(x)>0, p)