Upload folder using huggingface_hub (part 4)

.gitattributes

@@ -45,3 +45,14 @@ model/comp_surface/tools/transfer/APBS-3.4.1.Linux/share/apbs/tools/bin/similari
 model/comp_surface/tools/transfer/APBS-3.4.1.Linux/share/apbs/tools/bin/smooth filter=lfs diff=lfs merge=lfs -text
 model/comp_surface/tools/transfer/APBS-3.4.1.Linux/share/apbs/tools/bin/value filter=lfs diff=lfs merge=lfs -text
 model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/doc/images/flowchart.png filter=lfs diff=lfs merge=lfs -text
+model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/libcrypto.so.1.0.0 filter=lfs diff=lfs merge=lfs -text
+model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/libexpat.so.1 filter=lfs diff=lfs merge=lfs -text
+model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/libncursesw.so.5 filter=lfs diff=lfs merge=lfs -text
+model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/libpython2.7.so.1.0 filter=lfs diff=lfs merge=lfs -text
+model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/libreadline.so.6 filter=lfs diff=lfs merge=lfs -text
+model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/libssl.so.1.0.0 filter=lfs diff=lfs merge=lfs -text
+model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/libstdc++.so.6 filter=lfs diff=lfs merge=lfs -text
+model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/libtinfo.so.5 filter=lfs diff=lfs merge=lfs -text
+model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/libz.so.1 filter=lfs diff=lfs merge=lfs -text
+model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/pdb2pqr filter=lfs diff=lfs merge=lfs -text
+model/figs/docking.gif filter=lfs diff=lfs merge=lfs -text

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/extensions/README

@@ -0,0 +1,3 @@
+Please see the programmer's guide (doc/programmerguide.html) for a discussion on how to add your own functionality to PDB2PQR.
+
+Additionally, the "template" file is a template for interfacing with PDB2PQR.

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/extensions/__init__.py

@@ -0,0 +1,117 @@
+"""
+    Extentions for PDB2PQR Suite
+
+    This module provides various utilities for the PDB2PQR suite to be
+    imported into other Python scripts.
+    
+    ----------------------------
+   
+    PDB2PQR -- An automated pipeline for the setup, execution, and analysis of
+    Poisson-Boltzmann electrostatics calculations
+
+    Copyright (c) 2002-2011, Jens Erik Nielsen, University College Dublin; 
+    Nathan A. Baker, Battelle Memorial Institute, Developed at the Pacific 
+    Northwest National Laboratory, operated by Battelle Memorial Institute, 
+    Pacific Northwest Division for the U.S. Department Energy.; 
+    Paul Czodrowski & Gerhard Klebe, University of Marburg.
+
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without modification, 
+    are permitted provided that the following conditions are met:
+
+        * Redistributions of source code must retain the above copyright notice, 
+          this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above copyright notice, 
+          this list of conditions and the following disclaimer in the documentation 
+          and/or other materials provided with the distribution.
+        * Neither the names of University College Dublin, Battelle Memorial Institute,
+          Pacific Northwest National Laboratory, US Department of Energy, or University
+          of Marburg nor the names of its contributors may be used to endorse or promote
+          products derived from this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
+    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
+    IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
+    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
+    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
+    OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+    OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    ----------------------------
+"""
+
+import pkgutil
+
+from optparse import OptionGroup, OptionConflictError, Option
+
+_extList = [name for _, name, _ in pkgutil.iter_modules(__path__)]
+
+extDict = {}
+
+for extName in _extList:
+    extDict[extName] = __import__(extName,globals(),locals(),[], -1)
+    
+def setupExtensionsOptions(parser):
+    """
+    Takes an instance of an OptionParser 
+    and adds the options for all extensions
+    
+    If an extension adds it's own options, those
+    options are put in their own group.
+    """
+    
+    if len(extDict) == 0:
+        return None
+    
+    firstGroup = OptionGroup(parser,"Extension options")
+    groups = [firstGroup]
+    
+    for extName, extModule in extDict.items():
+        helpArg = {}
+        if hasattr(extModule, 'usage'):
+            helpArg['help'] = extModule.usage()
+            
+        extOption = Option('--' + extName, action='append_const', 
+                             const = extName, dest = 'active_extensions', **helpArg )
+        
+        try:
+            if hasattr(extModule, 'addExtensionOptions'):
+                group = OptionGroup(parser, extName.capitalize() + " extension options")
+                group.add_option(extOption)
+                
+                extModule.addExtensionOptions(group)
+                
+                if len(group.option_list) == 1:
+                    opt = group.option_list[0]
+                    group.remove_option(opt.get_opt_string())
+                    firstGroup.add_option(opt)
+                else:
+                    groups.append(group)   
+                
+            else:
+                firstGroup.add_option(extOption)
+                
+        except OptionConflictError, value:
+            print 'Error adding command line options for extension ' + extName + ' ' + '(' + str(value) + ')'
+            
+    
+    for group in groups:
+        parser.add_option_group(group)
+    
+    return groups
+
+class extOutputHelper(object):
+    """
+    Simple class that makes writing to both file and output simple.
+    """
+    def __init__(self, routines, outfile):
+        self.routines = routines
+        self.outfile = outfile
+
+    def write(self, s):
+        self.routines.write(s)
+        self.outfile.write(s)

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/extensions/chi.py

@@ -0,0 +1,70 @@
+"""
+    Chi extension
+
+    Print the backbone chi angle for each residue in the structure.
+    Chi angle is determined by the coordinates of the N, CA, CB (if
+    available), and CG/OG/SG atoms (if available).
+
+    Author:  Todd Dolinsky
+"""
+
+__date__ = "17 February 2006"
+__author__ = "Todd Dolinsky"
+
+from src.utilities import getDihedral
+
+def usage():
+    return 'Print the per-residue backbone chi angle to {output-path}.chi'
+
+def run_extension(routines, outroot, options):
+    """
+        Print the list of psi angles
+
+        Parameters
+            routines:  A link to the routines object
+            outroot:   The root of the output name
+            options:   options object 
+    """
+
+    outname = outroot + ".chi"
+    outfile = open(outname, "w")
+
+    routines.write("\nPrinting chi angles for each residue...\n")
+    routines.write("Residue     chi\n")
+    routines.write("----------------\n")
+    
+    # Initialize some variables
+
+    protein = routines.protein
+
+    for residue in protein.getResidues():
+        if residue.hasAtom("N"): 
+            ncoords = residue.getAtom("N").getCoords()
+        else: 
+            continue
+
+        if residue.hasAtom("CA"):
+            cacoords = residue.getAtom("CA").getCoords()
+        else: 
+            continue
+
+        if residue.hasAtom("CB"): 
+            cbcoords = residue.getAtom("CB").getCoords()
+        else: 
+            continue
+
+        if residue.hasAtom("CG"): 
+            gcoords = residue.getAtom("CG").getCoords()
+        elif residue.hasAtom("OG"): 
+            gcoords = residue.getAtom("OG").getCoords()
+        elif residue.hasAtom("SG"): 
+            gcoords = residue.getAtom("SG").getCoords()
+        else: 
+            continue
+
+        chi = getDihedral(ncoords, cacoords, cbcoords, gcoords)
+        routines.write("%s\t%.4f\n" % (residue, chi))
+        outfile.write("%s\t%.4f\n" % (residue, chi))
+        
+    routines.write("\n")
+    outfile.close()

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/extensions/contact.py

@@ -0,0 +1,80 @@
+"""
+    Contact extension
+
+    Find all hydrogen bonds as determined by the DISTANCE cutoff below.
+    Uses PDB2PQR to determine donors and acceptors, and displays
+    all available bonds to stdout in a WHATIF-like format.
+
+    Author:  Julie C. Mitchell
+"""
+
+__date__ = "April 2007"
+__author__ = "Julie C. Mitchell"
+
+from src.utilities import distance
+from src.routines import Cells
+
+DIST_CUTOFF = 3.5         # max distance  
+
+def usage():
+    return 'Print a list of contacts to {output-path}.con\n'
+
+def run_extension(routines, outroot, options):
+    """
+        Print a list of contacts.
+
+        Parameters
+            routines:  A link to the routines object
+            outroot:   The root of the output name
+            options:   options object 
+    """
+    outname = outroot + ".con"
+    outfile = open(outname, "w")
+
+    # Initialize - set nearby cells, donors/acceptors
+    
+    cellsize = int(DIST_CUTOFF + 1.0 + 1.0) 
+    protein = routines.protein
+    routines.setDonorsAndAcceptors()
+    routines.cells = Cells(cellsize)
+    routines.cells.assignCells(protein)
+
+    for thisatom in protein.getAtoms():
+        # Grab the list of thisatoms
+        if not thisatom.hdonor: 
+            continue
+        thisatomhs = []
+        for bond in thisatom.bonds:
+            if bond.isHydrogen(): 
+                thisatomhs.append(bond)
+        if thisatomhs == []: 
+            continue
+
+        # For each thisatom, grab all thatatomeptors
+            
+        count = 0
+        closeatoms = routines.cells.getNearCells(thisatom)
+        for thatatom in closeatoms:
+            if (thisatom.residue == thatatom.residue): 
+                continue  # comment this out to include interresidue contacts
+            if (thatatom.isHydrogen()): 
+                continue
+            thisdist = distance(thisatom.getCoords(), thatatom.getCoords())
+            if (thisdist <= DIST_CUTOFF): 
+                count = count+1
+                thisBstring='S'
+                thatBstring='S'
+                hscore= 0.0
+                if (thisatom.hdonor & thatatom.hacceptor): 
+                    hscore = 1.0
+                if (thisatom.hacceptor & thatatom.hdonor): 
+                    hscore = 1.0
+                if (thisatom.isBackbone()): 
+                    thisBstring='B'
+                if (thatatom.isBackbone()): 
+                    thatBstring='B'
+                outfile.write("%4d %4d %-4s (%4d  ) %s     %-4s<>%4d %-4s (%4d  ) %s     %-4s D=%6.2f  H-ene=%6.2f  Sym=  (%s-%s)\n" % \
+                  (count, thisatom.residue.resSeq,thisatom.residue.name,thisatom.residue.resSeq, thisatom.residue.chainID,thisatom.name,thatatom.residue.resSeq,thatatom.residue.name,thatatom.residue.resSeq, thatatom.residue.chainID,thatatom.name, thisdist, hscore, thisBstring, thatBstring)) 
+
+    routines.write("\n")
+    outfile.close()

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/extensions/hbond.py

@@ -0,0 +1,161 @@
+"""
+    Hbond extension
+
+    Find all hydrogen bonds as determined by the cutoffs specified.
+    Uses PDB2PQR to determine donors and acceptors, and displays
+    all available bonds to file. 
+    
+    The original bonding parameters were an angle of 20.0, 
+    distance of 3.30, and using the old method for calculating 
+    distance.
+    
+    The original parameters for WHAT-IF output was an angle of
+    90.0, distance of 3.30, and using the old method for 
+    calculating distance. 
+
+    Authors:  Todd Dolinsky, Michael J Bradley, Julie Mitchell, and Kyle Monson
+"""
+
+__date__ = "17 February 2006"
+__author__ = "Todd Dolinsky, Michael J Bradley, Julie Mitchell, and Kyle Monson"
+# NOTE: This extension edited and updated on 05 August 2008 by Michael J Bradley
+# and again on 17 October by Kyle Monson.
+
+# NOTE: The current defaults for hbonds used below were utilized in the following study:
+#Bradley MJ, Chivers PT, Baker NA. Molecular dynamics simulation of the 
+#Escherichia coli NikR protein: Equilibrium conformational fluctuations reveal 
+#inter-domain allosteric communication pathways. Journal of Molecular Biology, 378, 
+#1155-1173, 2008.  http://dx.doi.org/10.1016/j.jmb.2008.03.010
+
+from src.utilities import distance, getAngle
+from src.routines import Cells
+from math import cos
+import extensions
+
+ANGLE_CUTOFF = 30.0       # A - D - H(D) angle
+DIST_CUTOFF = 3.4         # D to A distance
+
+def addExtensionOptions(extensionGroup):
+    """
+        Add options to set output type, angle cutoff, distance cutoff, and distance calculating method.
+    """
+    extensionGroup.add_option('--whatif', dest='whatif', action='store_true', default=False,
+                              help='Change hbond output to WHAT-IF format.')
+    
+    extensionGroup.add_option('--angle_cutoff', dest='angle_cutoff',  type="float", action='store', default=ANGLE_CUTOFF,
+                              help='Angle cutoff to use when creating hbond data (default %s)' % ANGLE_CUTOFF)
+    
+    extensionGroup.add_option('--distance_cutoff', dest='distance_cutoff',  type="float", action='store', default=DIST_CUTOFF,
+                              help='Distance cutoff to use when creating hbond data (default %s)' % DIST_CUTOFF)
+    
+    extensionGroup.add_option('--old_distance_method', dest='old_distance_method', action='store_true', default=False,
+                              help='Use distance from donor hydrogen to acceptor to calculate distance used with --distance_cutoff.')
+
+def usage():
+    return 'Print a list of hydrogen bonds to {output-path}.hbond'
+
+#TODO: replace this with a ''.format() call.
+def _residueString(residue, name):
+    return '%4d %-4s (%4d  ) %s     %-4s' % \
+        (residue.resSeq, residue.name, residue.resSeq, residue.chainID, name)
+
+def create_hbond_output(routines, outfile, whatif=False, 
+                                           angleCutoff=ANGLE_CUTOFF, 
+                                           distanceCutoff=DIST_CUTOFF, 
+                                           oldDistanceMethod=False):
+
+    routines.write("Printing hydrogen bond list...\n")
+    
+    output = extensions.extOutputHelper(routines, outfile)
+    
+    cellsize = int(distanceCutoff + 1.0 + 1.0) 
+    protein = routines.protein
+    routines.setDonorsAndAcceptors()
+    routines.cells = Cells(cellsize)
+    routines.cells.assignCells(protein)
+
+    for donor in protein.getAtoms():
+
+        # Grab the list of donors
+        if not donor.hdonor: 
+            continue
+        donorhs = []
+        for bond in donor.bonds:
+            if bond.isHydrogen(): 
+                donorhs.append(bond)
+        if donorhs == []: 
+            continue
+
+        # For each donor, grab all acceptors
+        closeatoms = routines.cells.getNearCells(donor)
+        for acc in closeatoms:
+            if not acc.hacceptor: 
+                continue
+            if donor.residue == acc.residue: 
+                continue
+            
+            #TODO: do we need to do this for plain hbond stuff?
+            if whatif and (donor.residue.chainID == acc.residue.chainID): 
+                continue
+            
+            # Do new style distance check
+            if not oldDistanceMethod:
+                dist = distance(donor.getCoords(), acc.getCoords())
+                if dist > distanceCutoff:
+                    continue
+            
+            for donorh in donorhs:
+
+                # Do old style distance check       
+                if oldDistanceMethod:
+                    dist = distance(donorh.getCoords(), acc.getCoords())
+                    if dist > distanceCutoff: 
+                        continue
+                    
+                # Do angle check
+                angle = getAngle(acc.getCoords(), donor.getCoords(), donorh.getCoords())
+                if angle > angleCutoff: 
+                    continue
+                
+                if whatif:
+                    if (donor.tempFactor > 60.0): 
+                        continue
+                    if (acc.tempFactor > 60.0): 
+                        continue
+                    
+                    thisBstring='B' if donor.isBackbone() else 'S'
+                    thatBstring='B' if acc.isBackbone() else 'S'
+
+                    score= (1.7/dist) * cos(angle * 3.142 / 180.0)
+                    output.write(_residueString(donor.residue, donor.name))
+                    output.write('-> ')
+                    output.write(_residueString(acc.residue, acc.name))
+                    output.write('Sym=   1 Val= %6.3lf  DA=%6.2f  DHA=%6.2f (%s-%s)\n' % 
+                                 (score, dist, angle, thisBstring, thatBstring))
+#                    outfile.write("%4d %-4s (%4d  ) %s     %-4s-> %4d %-4s (%4d  ) %s     %-4sSym=   1 Val= %6.3lf  DA=%6.2f  DHA=%6.2f (%s-%s)\n" % \
+#                      (donor.residue.resSeq,donor.residue.name,donor.residue.resSeq, donor.residue.chainID,donor.name,acc.residue.resSeq,acc.residue.name,acc.residue.resSeq, acc.residue.chainID,acc.name, score, dist, angle, thisBstring, thatBstring)) 
+
+                else:
+                    s = "Donor: %s %s\tAcceptor: %s %s\tdist: %.2f\tAngle: %.2f\n" % \
+                        (donor.residue, donor.name, acc.residue, acc.name, dist, angle)
+                    output.write(s) 
+                    
+    routines.write("\n")
+
+def run_extension(routines, outroot, options):
+    """
+        Print a list of hydrogen bonds.
+
+        Parameters
+            routines:  A link to the routines object
+            outroot:   The root of the output name
+            options:   options object 
+    """
+    
+    outname = outroot + ".hbond"
+    with open(outname, "w") as outfile:
+        create_hbond_output(routines, outfile, whatif=options.whatif, 
+                                               angleCutoff=options.angle_cutoff,
+                                               distanceCutoff=options.distance_cutoff,
+                                               oldDistanceMethod=options.old_distance_method)
+

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/extensions/newresinter.py

@@ -0,0 +1,354 @@
+"""
+    Resinter extension
+
+    Print interaction energy between each residue pair in the protein. 
+"""
+
+__date__ = "21 October 2011"
+__authors__ = "Kyle Monson and Emile Hogan"
+
+import extensions
+from src.hydrogens import Optimize
+#itertools FTW!
+from itertools import product, permutations, izip, count
+from src.hydrogens import hydrogenRoutines
+
+#Here are the Ri -> [Ri0, Ri1] maps:
+#ARG -> [{AR0}, {ARG}]
+#ASP -> [{ASP}, {ASH}]
+#GLU -> [{GLU}, {GLH}]
+#CYS -> [{CYM}, {CYS}]
+#LYS -> [{LYN}, {LYS}]
+#TYR -> [{TYM}, {TYR}]
+#CTERM -> [{CTERM}, {NEUTRAL-CTERM}]
+#NTERM -> [{NEUTRAL-NTERM}, {NTERM}]
+#HIS -> [{HSD, HSE}, {HIS}]
+#HIP -> [{HID, HIE}, {HIP}]
+#HSP -> [{HSD, HSE}, {HSP}]
+
+_titrationSets = ((('AR0',), 'ARG'),
+                  (('ASH',), 'ASP'),
+                  (('CYX',), 'CYS'),
+                  (('GLU',), 'GLH'),
+                  (('HSD', 'HSE'), 'HSP'),
+                  (('HID', 'HIE'), 'HIP'),
+                  (('LYN',), 'LYS'),
+                  (('TYM',), 'TYR'),
+                  (('CTERM',), 'NEUTRAL-CTERM'),
+                  (('NEUTRAL-NTERM',), 'NTERM'))
+
+_titrationSetsMap = {}
+
+for tsSet in _titrationSets:
+    for ts in tsSet[0]:
+        _titrationSetsMap[ts] = tsSet
+        
+    _titrationSetsMap[tsSet[1]] = tsSet
+    
+#loose ends.
+_titrationSetsMap['HIS'] = _titrationSetsMap['HSD']
+_titrationSetsMap['CYM'] = _titrationSetsMap['CYS']
+        
+def usage():
+    """
+    Returns usage text for newresinter.
+    """
+    txt = 'Print interaction energy between each residue pair in the protein to {output-path}.newresinter.'
+    return txt
+
+def run_extension(routines, outroot, options):
+    outname = outroot + ".newresinter"
+    with open(outname, "w") as outfile:
+        processor = ResInter(routines, outfile, options)
+        processor.generate_all()
+        processor.write_resinter_output()
+
+class ResInter(object):
+    def __init__(self, routines, outfile, options):
+        self.pairEnergyResults = {}
+        self.combinationCount = 0
+        self.totalCombinations = 0
+        self.options = options
+        self.output = extensions.extOutputHelper(routines, outfile)
+        self.routines = routines
+
+    def save_interation_energy(self, first, second):
+        energy = get_residue_interaction_energy(first, second)
+        pairText = str(first) + ' ' + str(second)
+        if pairText in self.pairEnergyResults:            
+            txt = '#%s re-tested!!! LOLWAT?\n' % pairText
+            self.output.write(txt)             
+        else:
+            self.pairEnergyResults[pairText] = energy
+                    
+
+    def save_all_residue_interaction_energies(self):
+        """
+        Writes out the residue interaction energy for each possible
+        residue pair in the protein.
+        """
+        residuepairs = permutations(self.routines.protein.getResidues(), 2)
+        
+        for pair in residuepairs:
+            self.save_interation_energy(pair[0], pair[1])
+            
+    def save_one_with_all_interaction_energies(self, i):
+        """
+        Writes out the residue interaction energy for each possible
+        residue pair in the protein.
+        """
+        residues = list(self.routines.protein.getResidues())
+        target = residues[i]
+        del residues[i]        
+        
+        for residue in residues:
+            self.save_interation_energy(target, residue)
+            self.save_interation_energy(residue, target)
+            
+    def save_pair_interaction_energies(self, i, j):
+        """
+        Writes out the residue interaction energy for each possible
+        residue pair in the protein.
+        """
+        residues = list(self.routines.protein.getResidues())
+
+        self.save_interation_energy(residues[i], residues[j])
+        self.save_interation_energy(residues[j], residues[i])
+            
+    def create_all_protonated(self):
+        residueSet = get_residue_titration_set_protonated(self.routines.protein.getResidues())
+        self.process_residue_set(residueSet, 
+                                clean = self.options.clean,
+                                neutraln = self.options.neutraln,
+                                neutralc = self.options.neutralc,
+                                ligand = self.options.ligand,
+                                assign_only = self.options.assign_only,
+                                chain = self.options.chain,
+                                debump = self.options.debump,
+                                opt = self.options.opt)
+        
+        self.save_all_residue_interaction_energies()
+        
+    def create_all_single_unprotonated(self):
+        combinations = residue_set_single_unprotonated_combinations(self.routines.protein.getResidues())
+        for residueSet, i in combinations:
+            self.process_residue_set(residueSet, 
+                                     clean = self.options.clean,
+                                     neutraln = self.options.neutraln,
+                                     neutralc = self.options.neutralc,
+                                     ligand = self.options.ligand,
+                                     assign_only = self.options.assign_only,
+                                     chain = self.options.chain,
+                                     debump = self.options.debump,
+                                     opt = self.options.opt)
+        
+            self.save_one_with_all_interaction_energies(i)
+            
+    def create_all_pair_unprotonated(self):
+        combinations = residue_set_pair_unprotonated_combinations(self.routines.protein.getResidues())
+        for residueSet, i, j in combinations:
+            self.process_residue_set(residueSet, 
+                                     clean = self.options.clean,
+                                     neutraln = self.options.neutraln,
+                                     neutralc = self.options.neutralc,
+                                     ligand = self.options.ligand,
+                                     assign_only = self.options.assign_only,
+                                     chain = self.options.chain,
+                                     debump = self.options.debump,
+                                     opt = self.options.opt)
+        
+            self.save_pair_interaction_energies(i, j)
+            
+    def count_combinations(self):
+        n = 0 # total iterable residues
+        k = 0 # total iterable residues with two possible choices.
+        
+        allProtonated = get_residue_titration_set_protonated(self.routines.protein.getResidues())
+        
+        for name in allProtonated:
+            if name in _titrationSetsMap:
+                n += 1
+                
+                if len(_titrationSetsMap[name][0]) == 2:
+                    k += 1
+        
+        self.totalCombinations = (((n+k)**2)+(n-k)+2)/2
+            
+    def generate_all(self):
+        """
+        For every titration state combination of residue output the 
+        interaction energy for all possible residue pairs. 
+        """
+        self.routines.write("Printing residue interaction energies...\n")
+        
+        self.count_combinations()
+        
+        #Phase 1: Everything protonated
+        self.create_all_protonated()
+        
+        #Phase 2: Single unprotonated paired with everything else.
+        self.create_all_single_unprotonated()
+        
+        #Phase 2: Pair unprotonated paired with each other.
+        self.create_all_pair_unprotonated()
+
+    def write_resinter_output(self):
+        """
+        Output the interaction energy between each possible residue pair.
+        """
+        for resultKey in sorted(self.pairEnergyResults.iterkeys()):
+            self.output.write(resultKey + ' ' + str(self.pairEnergyResults[resultKey]) + '\n')
+        
+        self.routines.write(str(self.combinationCount)+' residue combinations tried\n')
+                
+    def process_residue_set(self, residueSet,  
+                            clean = False,
+                            neutraln = False,
+                            neutralc = False,
+                            ligand = None,
+                            assign_only = False,
+                            chain = False,
+                            debump = True,
+                            opt = True):
+        
+        self.combinationCount += 1
+        
+        txt = "Running combination {0} of {1}\n".format(self.combinationCount, self.totalCombinations)
+        self.routines.write(txt)
+        
+        self.routines.write(str(residueSet)+'\n')
+        
+        self.routines.removeHydrogens()
+        
+        for newResidueName, oldResidue, index in izip(residueSet, self.routines.protein.getResidues(), count()):
+            if newResidueName is None:
+                continue
+            
+            chain = self.routines.protein.chainmap[oldResidue.chainID]
+            chainIndex = chain.residues.index(oldResidue)
+            residueAtoms = oldResidue.atoms
+            
+            #Create the replacement residue
+            newResidue = self.routines.protein.createResidue(residueAtoms, newResidueName)
+            
+            #Make sure our names are cleaned up for output.
+            newResidue.renameResidue(newResidueName)
+            
+            #Drop it in
+            self.routines.protein.residues[index] = newResidue
+            chain.residues[chainIndex] = newResidue
+        
+        #Run the meaty bits of PDB2PQR  
+        self.routines.setTermini(neutraln, neutralc)
+        self.routines.updateBonds()
+        
+        if not clean and not assign_only:
+            self.routines.updateSSbridges()
+    
+            if debump:
+                self.routines.debumpProtein()
+                
+            self.routines.addHydrogens()
+    
+            hydRoutines = hydrogenRoutines(self.routines)
+    
+            if debump:
+                self.routines.debumpProtein()  
+    
+            if opt:
+                hydRoutines.setOptimizeableHydrogens()
+                hydRoutines.initializeFullOptimization()
+                hydRoutines.optimizeHydrogens()
+            else:
+                hydRoutines.initializeWaterOptimization()
+                hydRoutines.optimizeHydrogens()
+    
+            # Special for GLH/ASH, since both conformations were added
+            hydRoutines.cleanup()
+                    
+        
+def get_residue_titration_set_protonated(residues):
+    """
+    Returns residue set when everything is protonated.
+    """
+    result = []
+    for residue in residues:
+        residueTest = _titrationSetsMap.get(residue.name)
+        if residueTest:
+            residueTest = residueTest[1]
+        else:
+            residueTest = residue.name
+        result.append(residueTest)
+        
+    return result
+
+def residue_set_single_unprotonated_combinations(residues):
+    """
+    Yields pair (residue set, residue index) for 
+    every "single unprotonated" combination.
+    residue set - set for process_residue_set
+    residue index - index of residue that was left unprotonated
+    """    
+    protonatedNames = get_residue_titration_set_protonated(residues)
+    
+    for name, i in izip(protonatedNames, count()):
+        if not name in _titrationSetsMap:
+            continue
+        
+        tStateSet = _titrationSetsMap[name][0]
+        
+        for tState in tStateSet:
+            result = list(protonatedNames)
+            result[i] = tState
+            yield result, i
+            
+def residue_set_pair_unprotonated_combinations(residues):
+    """
+    Yields pair (residue set, 1rst residue index, 2nd residue index) for 
+    every "single unprotonated" combination.
+    residue set - set for process_residue_set
+    1rst residue index - index of 1rst residue that was left unprotonated
+    2nd residue index - index of 2nd residue that was left unprotonated
+    """    
+    protonatedNames = get_residue_titration_set_protonated(residues)
+    
+    for i in xrange(0,len(protonatedNames)):
+        firstName = protonatedNames[i]
+        if not firstName in _titrationSetsMap:
+            continue
+        firstStateSet = _titrationSetsMap[firstName][0]
+        for j in xrange(0,i):
+            secondName = protonatedNames[j]
+            if not secondName in _titrationSetsMap:
+                continue            
+            
+            secondStateSet = _titrationSetsMap[secondName][0]
+            
+            for firstState in firstStateSet:
+                for secondState in secondStateSet:
+                    result = list(protonatedNames)
+                    result[i] = firstState
+                    result[j] = secondState
+                    yield result, i, j
+
+
+def get_residue_interaction_energy(residue1, residue2):
+    """
+    Returns to total energy of every atom pair between the two residues.
+    
+    Uses Optimize.getPairEnergy and it's donor/accepter model 
+    to determine energy.
+    
+    residue1 - "donor" residue
+    residue2 - "acceptor" residue
+    
+    THE RESULTS OF THIS FUNCTION ARE NOT SYMMETRIC. Swapping 
+    residue1 and residue2 will not always produce the same result.
+    """
+    energy = 0.0
+    for pair in product(residue1.getAtoms(), residue2.getAtoms()):
+        energy += Optimize.getPairEnergy(pair[0], pair[1])
+        
+    return energy
+    
+

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/extensions/rama.py

@@ -0,0 +1,102 @@
+"""
+    Ramachandran extension
+
+    Print both the phi and psi angles to standard out.  See the individual
+    functions for more info.
+
+    Author:  Mike Bradley and Todd Dolinsky
+"""
+
+__date__ = "17 February 2006"
+__author__ = "Mike Bradley, Todd Dolinsky"
+  
+from src.utilities import getDihedral
+import extensions
+
+def addExtensionOptions(extensionGroup):
+    """
+        Add options to set output type.
+    """
+    extensionGroup.parser.set_defaults(rama_output='rama')
+    extensionGroup.add_option('--phi_only', dest='rama_output', action='store_const', const = 'phi',
+                              help='Only include phi angles in output. '+
+                                   'Rename output file {output-path}.phi')
+    
+    extensionGroup.add_option('--psi_only', dest='rama_output', action='store_const', const = 'psi',
+                              help='Only include psi angles in output. '+
+                                   'Rename output file {output-path}.psi')
+
+
+def usage():
+    return 'Print the per-residue phi and psi angles to {output-path}.rama for Ramachandran plots'
+
+def create_rama_output(routines, outfile, outputtype='rama'):
+
+    routines.write("\nPrinting %s angles for each residue...\n" % (outputtype if outputtype != 'rama' else 'phi and psi'))
+    verboseHeader = "Residue        %s\n"  % (outputtype.capitalize() if outputtype != 'rama' else 'Phi          Psi')
+    routines.write(verboseHeader)
+    routines.write('-' * len(verboseHeader) + '\n')
+    
+    output = extensions.extOutputHelper(routines, outfile)
+
+    # Initialize some variables
+
+    protein = routines.protein
+
+    for residue in protein.getResidues():
+        if residue.hasAtom("N"): 
+            ncoords = residue.getAtom("N").getCoords()
+        else: 
+            continue
+
+        if residue.hasAtom("CA"): 
+            cacoords = residue.getAtom("CA").getCoords()
+        else: 
+            continue
+
+        if residue.hasAtom("C"): 
+            ccoords = residue.getAtom("C").getCoords()
+        else: 
+            continue
+
+        try:
+            if residue.peptideN != None:
+                pepncoords = residue.peptideN.getCoords()
+            else: 
+                continue
+
+            if residue.peptideC != None:
+                pepccoords = residue.peptideC.getCoords()
+            else: 
+                continue
+        except AttributeError: # Non amino acids
+            continue
+
+        output.write(str(residue))
+        
+        if outputtype in ('rama', 'phi'):
+            phi = getDihedral(pepccoords, ncoords, cacoords, ccoords)
+            output.write("\t%.4f" % phi)
+            
+        if outputtype in ('rama', 'psi'):
+            psi = getDihedral(ncoords, cacoords, ccoords, pepncoords)
+            output.write("\t%.4f" % psi)
+            
+        output.write('\n')
+
+    routines.write("\n")
+    
+def run_extension(routines, outroot, options):
+    """
+        Print the list of phi and psi angles for use in a Ramachandran plot.
+
+        Parameters
+            routines:  A link to the routines object
+            outroot:   The root of the output name
+            options:   options object 
+    """
+    outputType = options.rama_output
+    outname = outroot + '.' + outputType
+    with open(outname, "w") as outfile:
+        create_rama_output(routines, outfile, outputtype=outputType)
+    

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/extensions/resinter.py

@@ -0,0 +1,343 @@
+"""
+    Resinter extension
+
+    Print interaction energy between each residue pair in the protein. 
+"""
+
+__date__ = "21 October 2011"
+__authors__ = "Kyle Monson and Emile Hogan"
+
+import extensions
+from src.hydrogens import Optimize
+#itertools FTW!
+from itertools import product, permutations, izip, count
+from collections import defaultdict
+from src.hydrogens import hydrogenRoutines
+
+_titrationSets = (('ARG','AR0'),
+                  ('ASP', 'ASH'),
+                  ('CYS', 'CYX'),
+                  ('GLU', 'GLH'),
+                  ('HSD', 'HSE', 'HSP'),
+                  ('HID', 'HIE', 'HIP'),
+                  ('LYN', 'LYS'),
+                  ('TYR', 'TYM'),
+                  ('NEUTRAL-CTERM', 'CTERM'),
+                  ('NEUTRAL-NTERM', 'NTERM'))
+
+_titrationSetsMap = defaultdict(tuple)
+
+for tsSet in _titrationSets:
+    for ts in tsSet:
+        _titrationSetsMap[ts] = tsSet
+        
+#loose ends.
+_titrationSetsMap['HIS'] = _titrationSetsMap['HSD']
+_titrationSetsMap['CYM'] = _titrationSetsMap['CYS']
+
+_pairEnergyResults = {}
+#If the residue pair energy for a specific pair changes less than this ignore it.
+PAIR_ENERGY_EPSILON = 1.0e-14
+
+def addExtensionOptions(extensionGroup):
+    """
+        Add options.
+    """
+    extensionGroup.add_option('--residue_combinations', 
+                              dest='residue_combinations', 
+                              action='store_true', 
+                              default=False,
+                              help=
+'''Remap residues to different titration states and rerun resinter appending output.
+Consider only the minimum number of whole protein titration combinations needed to
+test each possible pairing of residue titration states. Normally used with
+--noopt. If a protein titration state combination results in a pair of residue being 
+re-tested in the same individual titration states a warning will be generated if the 
+re-tested result is different. This warning should not be possible if used with --noopt.''') 
+    
+    extensionGroup.add_option('--all_residue_combinations', 
+                              dest='all_residue_combinations', 
+                              action='store_true', 
+                              default=False,
+                              help=
+'''Remap residues to ALL possible titration state combinations and rerun resinter appending output.
+Results with --noopt should be the same as --residue_combinations. Runs considerably slower than
+--residue_combinations and generates the same type of warnings. 
+Use without --noopt to discover how hydrogen optimization affects residue 
+interaction energies via the warnings in the output.''') 
+
+def usage():
+    """
+    Returns usage text for resinter.
+    """
+    txt = 'Print interaction energy between each residue pair in the protein to {output-path}.resinter.'
+    return txt
+
+def _combinations(sublist, remainder):
+    """
+    combinations function helper
+    
+    sublist - first list in list of lists for combinations
+    remainder - list of remaining lists
+    """
+    if remainder and sublist:
+        for item in sublist:
+            for result in _combinations(remainder[0], remainder[1:]):
+                yield [item] + result
+        return
+    elif sublist:
+        for item in sublist:
+            yield [item]
+        return
+    elif remainder:
+        for result in _combinations(remainder[0], remainder[1:]):
+            yield [None] + result
+        return
+            
+    yield [None]
+
+def combinations(initialList):
+    """
+    Wrapper for main combinations function. 
+    
+    Iterates over each possible combination of single items 
+    from each sub-list. For example:
+    
+    combinations([[1,2],[3,4]] -> [1,3], [1,4], [2,3], [2,4] in that order.     
+    
+    
+    initialList - list of lists to derive combinations from.
+    """
+    if not initialList:
+        return
+    for result in _combinations(initialList[0], initialList[1:]):
+        yield result
+
+
+def pairwiseCombinations(initialList):
+    """
+    Creates the minimum set of combinations that will make available 
+    every possible pair available.
+    """
+    r = [len(x) for x in initialList]
+    m = min(r)
+    M = max(r)
+    n = len(initialList)
+    
+    R = set()
+    
+    for i in range(m):
+        t = [initialList[x][i] for x in range(n)]
+        R.add(tuple(t))
+        
+    for i in range(m,M):
+        t = [initialList[x][min(r[x]-1,i)] for x in range(n)]
+        R.add(tuple(t))
+        
+    for i in range(m):
+        for j in range(n):
+            for k in range(i+1,r[j]):
+                prejth = [initialList[x][i] for x in range(j)]
+
+                jth = initialList[j][k]
+                
+                postjth = [initialList[x][i] for x in range(j+1, n)]
+                
+                t = prejth + [jth] + postjth
+                R.add(tuple(t))
+    
+    for i in range(m,M):
+        for j in range(n):
+            if r[i] < i:
+                continue
+            for k in range(i+1,r[j]):
+                prejth = [initialList[x][min(r[x]-1,i)] for x in range(j)]
+
+                jth = initialList[j][k]
+                
+                postjth = [initialList[x][min(r[x]-1,i)] for x in range(j+1, n)]
+                
+                t = prejth + [jth] + postjth
+                R.add(tuple(t))
+                
+    return R
+    
+def get_residue_interaction_energy(residue1, residue2):
+    """
+    Returns to total energy of every atom pair between the two residues.
+    
+    Uses Optimize.getPairEnergy and it's donor/accepter model 
+    to determine energy.
+    
+    residue1 - "donor" residue
+    residue2 - "acceptor" residue
+    
+    THE RESULTS OF THIS FUNCTION ARE NOT SYMMETRIC. Swapping 
+    residue1 and residue2 will not always produce the same result.
+    """
+    energy = 0.0
+    for pair in product(residue1.getAtoms(), residue2.getAtoms()):
+        energy += Optimize.getPairEnergy(pair[0], pair[1])
+        
+    return energy
+
+def save_residue_interaction_energies(residues, output):
+    """
+    Writes out the residue interaction energy for each possible
+    residue pair in the protein.
+    """
+    residuepairs = permutations(residues, 2)
+    
+    for pair in residuepairs:
+        energy = get_residue_interaction_energy(pair[0], pair[1])
+        pairText = str(pair[0]) + ' ' + str(pair[1])
+        if pairText in _pairEnergyResults:
+            
+            oldEnergy = _pairEnergyResults[pairText]
+            energyDiff = oldEnergy - energy
+            if abs(energyDiff) > PAIR_ENERGY_EPSILON:
+                txt = '#%s re-tested' % pairText
+                txt += ' with a difference of %s' % repr(energyDiff)
+                if (energy != 0):
+                    txt += ' and a reference of %s' % repr(energyDiff/energy)
+                else:
+                    txt += ' and the previous energy was 0'
+                txt += '\n'
+
+                output.write(txt)
+                 
+            continue
+        
+        _pairEnergyResults[pairText] = energy
+                    
+        
+def get_residue_titration_sets(residues):
+    """
+    Returns all possible titration states for each residue as a list of lists.
+    """
+    result = []
+    for residue in residues:
+        result.append(_titrationSetsMap.get(residue.name, (residue.name,)))
+        
+    return result
+
+def process_residue_set(residueSet, routines, output, clean = False,
+                                                      neutraln = False,
+                                                      neutralc = False,
+                                                      ligand = None,
+                                                      assign_only = False,
+                                                      chain = False,
+                                                      debump = True,
+                                                      opt = True):
+    routines.write(str(residueSet)+'\n')
+    
+    routines.removeHydrogens()
+    
+    for newResidueName, oldResidue, index in izip(residueSet, routines.protein.getResidues(), count()):
+        if newResidueName is None:
+            continue
+        
+        chain = routines.protein.chainmap[oldResidue.chainID]
+        chainIndex = chain.residues.index(oldResidue)
+        residueAtoms = oldResidue.atoms
+        
+        #Create the replacement residue
+        newResidue = routines.protein.createResidue(residueAtoms, newResidueName)
+        
+        #Make sure our names are cleaned up for output.
+        newResidue.renameResidue(newResidueName)
+        
+        #Drop it in
+        routines.protein.residues[index] = newResidue
+        chain.residues[chainIndex] = newResidue
+    
+    #Run the meaty bits of PDB2PQR  
+    routines.setTermini(neutraln, neutralc)
+    routines.updateBonds()
+    
+    if not clean and not assign_only:
+        routines.updateSSbridges()
+
+        if debump:
+            routines.debumpProtein()
+            
+        routines.addHydrogens()
+
+        hydRoutines = hydrogenRoutines(routines)
+
+        if debump:
+            routines.debumpProtein()  
+
+        if opt:
+            hydRoutines.setOptimizeableHydrogens()
+            hydRoutines.initializeFullOptimization()
+            hydRoutines.optimizeHydrogens()
+        else:
+            hydRoutines.initializeWaterOptimization()
+            hydRoutines.optimizeHydrogens()
+
+        # Special for GLH/ASH, since both conformations were added
+        hydRoutines.cleanup()
+        
+    save_residue_interaction_energies(routines.protein.getResidues(), output)        
+        
+
+def write_all_residue_interaction_energies_combinations(routines, output, options, all_residue_combinations=False):
+    """
+    For every titration state combination of residue output the 
+    interaction energy for all possible residue pairs. 
+    """
+    residueNamesList = get_residue_titration_sets(routines.protein.getResidues())
+    
+    routines.write("Testing the following combinations\n")
+    namelist = [r.name for r in routines.protein.getResidues()]
+    combinationsData = izip(namelist, residueNamesList)
+    for thing in combinationsData:
+        routines.write(str(thing)+'\n')
+        
+    if all_residue_combinations:
+        combinationGenerator = combinations(residueNamesList)
+    else:
+        combinationGenerator = pairwiseCombinations(residueNamesList)
+        
+    count = 0
+    for residueSet in combinationGenerator:
+        count += 1
+        process_residue_set(residueSet, routines, output, 
+                            clean = options.clean,
+                            neutraln = options.neutraln,
+                            neutralc = options.neutralc,
+                            ligand = options.ligand,
+                            assign_only = options.assign_only,
+                            chain = options.chain,
+                            debump = options.debump,
+                            opt = options.opt)
+        
+    for resultKey in sorted(_pairEnergyResults.iterkeys()):
+        output.write(resultKey + ' ' + str(_pairEnergyResults[resultKey]) + '\n')
+    
+    routines.write(str(count)+' residue combinations tried\n')
+
+def create_resinter_output(routines, outfile, options, 
+                           residue_combinations=False,
+                           all_residue_combinations=False):
+    """
+    Output the interaction energy between each possible residue pair.
+    """
+    routines.write("Printing residue interaction energies...\n")
+    
+    output = extensions.extOutputHelper(routines, outfile)
+    
+    if residue_combinations or all_residue_combinations:
+        write_all_residue_interaction_energies_combinations(routines, output, options, 
+                                                            all_residue_combinations=all_residue_combinations)
+    else:
+        save_residue_interaction_energies(routines.protein.getResidues(), output)
+    
+
+def run_extension(routines, outroot, options):
+    outname = outroot + ".resinter"
+    with open(outname, "w") as outfile:
+        create_resinter_output(routines, outfile, options, 
+                               residue_combinations=options.residue_combinations,
+                               all_residue_combinations=options.all_residue_combinations)

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/extensions/salt.py

@@ -0,0 +1,83 @@
+"""
+    Saltbridge extension
+
+    Find all salt bridges as determined by the cutoff distance below.
+    Uses PDB2PQR to determine atom identities and distances, and write
+    out all located salt bridges to stdout.
+    
+    NOTE:  A bond may be labeled BOTH hbond and salt-bridge if you use both
+           options in one pdb2pqr run.  Look out for double counting.
+
+    NOTE:  This extension currently does not support salt bridges with chain termini.
+
+    Author:  Mike Bradley (heavily copied from Todd Dolinsky's hbond extension)
+"""
+
+__date__ = "25 August 2006"
+__author__ = "Mike Bradley"
+
+from src.utilities import distance
+from src.routines import Cells
+
+DIST_CUTOFF = 4.0         # maximum cation to anion atom distance in angstroms
+
+def usage():
+    return 'Print a list of salt bridges to {output-path}.salt'
+
+def run_extension(routines, outroot, options):
+    """
+        Print a list of salt bridges.
+
+        Parameters
+            routines:  A link to the routines object
+            outroot:   The root of the output name
+            options:   options object 
+    """
+    outname = outroot + ".salt"
+    outfile = open(outname, "w")
+
+    routines.write("Printing salt bridge list...\n")
+
+    # Define the potential salt bridge atoms here (the current lists are for the AMBER
+    # forcefield and are not necessarily exhaustive).
+    posresList = ["LYS","ARG","HIP"]
+    negresList = ["GLU","ASP","CYM"]
+    posatomList = ["NE","NH1","NH2","NZ","ND1","NE2",]
+    negatomList = ["SG","OE1","OE2","OD1","OD2"]
+
+    # Initialize - set nearby cells
+    # The cell size adds one for the salt bridge distance, and rounds up
+    
+    cellsize = int(DIST_CUTOFF + 1.0 + 1.0) 
+    protein = routines.protein
+    routines.cells = Cells(cellsize)
+    routines.cells.assignCells(protein)
+
+    # Loop over all the atoms
+    for cation in protein.getAtoms():
+        # check that we've found a cation
+        if cation.residue.name == "NMET":
+            print "YES NMET"
+        if cation.residue.name not in posresList: 
+            continue
+        elif cation.name not in posatomList: 
+                continue
+        # For each cation, grab all potential anions in nearby cells
+        closeatoms = routines.cells.getNearCells(cation)
+        for anion in closeatoms:
+            if cation.residue.name == anion.residue.name: 
+                continue
+            if anion.residue.name not in negresList: 
+                continue
+            elif anion.name not in negatomList: 
+                    continue
+            # Do distance check
+            dist = distance(cation.getCoords(), anion.getCoords())
+            if dist > DIST_CUTOFF: 
+                continue
+            #routines.write("Cation: %s %s\tAnion: %s %s\tsaltdist: %.2f\n" % \
+            #          (cation.residue, cation.name, anion.residue, anion.name, dist)) 
+            outfile.write("Cation: %s %s\tAnion: %s %s\tsaltdist: %.2f\n" % \
+                      (cation.residue, cation.name, anion.residue, anion.name, dist))
+    #routines.write("\n")
+    outfile.close()

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/extensions/summary.py

@@ -0,0 +1,35 @@
+"""
+    Summary extension
+
+    Print protein summary file. 
+    Currently prints a list of all residue in protein.
+"""
+
+__date__ = "21 October 2011"
+__author__ = "Kyle Monson"
+
+import extensions
+
+def usage():
+    """
+    Returns usage text for summary.
+    """
+    return 'Print protein summary information to {output-path}.summary.'
+
+def create_summary_output(routines, outfile):
+    """
+    Output the interaction energy between each possible residue pair.
+    """
+    routines.write("Printing protein summary...\n")
+    
+    output = extensions.extOutputHelper(routines, outfile)
+    
+    output.write(routines.protein.getSummary() + '\n')
+    
+    for residue in routines.protein.getResidues():
+        output.write(str(residue)+'\n')
+
+def run_extension(routines, outroot, options):
+    outname = outroot + ".summary"
+    with open(outname, "w") as outfile:
+        create_summary_output(routines, outfile)

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/extensions/template

@@ -0,0 +1,84 @@
+"""
+    Extensions Template
+
+    A template for creating new post-processing scripts.  Please see the
+    PDB2PQR Programmer Guide for more information.
+
+    Author:  Todd Dolinsky
+"""
+
+__date__ = "17 February 2006" # Date
+__author__ = "Todd Dolinsky"  # Author
+
+from src.utilities import *   # Functions from utilities.py
+from src.routines import *    # Functions from routines.py
+
+def usage():
+    """
+        A small function that will be added to the overall PDB2PQR
+        usage.  Note that the root of the file name (in this case template.py)
+        becomes the command line option.
+        
+        ex. chi.py will add the --chi command line option.
+
+        Returns a string describing the usage for this function.
+        This will be used for help text for command line option for this function.
+        Defining this function is optional.
+    """
+    str = "Put usage here"
+    return str
+    
+def addExtensionOptions(extensionGroup):
+	"""
+		Add options specific to this extension to the option parser.
+		This function is optional.
+		
+		extensionGroup: A link to the OptionParser group object for extension
+						options. See the Python OptionParser documentation.
+						
+						Option names must not conflict with other option names.
+	"""
+	extensionGroup.add_option('--Ni', dest='Ni', action='store_true', default=False,
+							  help='Include N atoms in template output')
+	extensionGroup.add_option('--Ox', dest='Ox', action='store_true', default=False,
+							  help='Include O atoms in template output')
+
+def run_extension(routines, outroot, options):
+    """
+        The main function.  This will be called after all other PDB2PQR
+        activity has been completed.  There are two useful parameters
+        that must be passed into the function.
+        This functions is required.
+
+        Parameters
+            routines:  A link to the routines object  The routines object
+                       contains both protein (routines.protein) and links
+                       to the majority of functions necessary to use the
+                       PDB2PQR API.
+            outroot:   A string containing the root of the output name.  If 
+                       you want to return information to stdout this can be
+                       ignored (although it must still be present) - otherwise
+                       this can be used to output the desired data to a file.
+                       The root contains whatever the desired PQR file name is
+                       before the period, so "out.pqr" will have "out", and 
+                       "example" will just return "example".  For other
+                       extension scripts we have appended the function name
+                       to the outroot.
+            options:   A options parser like class containing additional options
+                       created for this extension by the optional addExtensionOptions
+                       function.
+    """
+
+    outname = outroot + ".template"
+    file = open(outname, "w")
+
+    protein = routines.protein
+
+    # For example, let's write all the CA atoms in the protein to the file
+
+    for atom in protein.getAtoms():
+        if atom.name == "CA":  file.write(atom)
+
+    file.close()
+
+

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/include/python2.7/pyconfig.h

@@ -0,0 +1,79 @@
+#if defined(__linux__)
+# if defined(__x86_64__) && defined(__LP64__)
+#  include <x86_64-linux-gnu/python2.7/pyconfig.h>
+# elif defined(__x86_64__) && defined(__ILP32__)
+#  include <x86_64-linux-gnux32/python2.7/pyconfig.h>
+# elif defined(__i386__)
+#  include <i386-linux-gnu/python2.7/pyconfig.h>
+# elif defined(__aarch64__) && defined(__AARCH64EL__)
+#  include <aarch64-linux-gnu/python2.7/pyconfig.h>
+# elif defined(__alpha__)
+#  include <alpha-linux-gnu/python2.7/pyconfig.h>
+# elif defined(__ARM_EABI__) && defined(__ARM_PCS_VFP)
+#  include <arm-linux-gnueabihf/python2.7/pyconfig.h>
+# elif defined(__ARM_EABI__) && !defined(__ARM_PCS_VFP)
+#  include <arm-linux-gnueabi/python2.7/pyconfig.h>
+# elif defined(__hppa__)
+#  include <hppa-linux-gnu/python2.7/pyconfig.h>
+# elif defined(__ia64__)
+#  include <ia64-linux-gnu/python2.7/pyconfig.h>
+# elif defined(__m68k__) && !defined(__mcoldfire__)
+#  include <m68k-linux-gnu/python2.7/pyconfig.h>
+# elif defined(__mips_hard_float) && defined(_MIPSEL)
+#  if _MIPS_SIM == _ABIO32
+#   include <mipsel-linux-gnu/python2.7/pyconfig.h>
+#  elif _MIPS_SIM == _ABIN32
+#   include <mips64el-linux-gnuabin32/python2.7/pyconfig.h>
+#  elif _MIPS_SIM == _ABI64
+#   include <mips64el-linux-gnuabi64/python2.7/pyconfig.h>
+#  else
+#   error unknown multiarch location for pyconfig.h
+#  endif
+# elif defined(__mips_hard_float)
+#  if _MIPS_SIM == _ABIO32
+#   include <mips-linux-gnu/python2.7/pyconfig.h>
+#  elif _MIPS_SIM == _ABIN32
+#   include <mips64-linux-gnuabin32/python2.7/pyconfig.h>
+#  elif _MIPS_SIM == _ABI64
+#   include <mips64-linux-gnuabi64/python2.7/pyconfig.h>
+#  else
+#   error unknown multiarch location for pyconfig.h
+#  endif
+# elif defined(__or1k__)
+#  include <or1k-linux-gnu/python2.7/pyconfig.h>
+# elif defined(__powerpc__) && defined(__SPE__)
+#  include <powerpc-linux-gnuspe/python2.7/pyconfig.h>
+# elif defined(__powerpc64__)
+#  if defined(__LITTLE_ENDIAN__)
+#    include <powerpc64le-linux-gnu/python2.7/pyconfig.h>
+#  else
+#    include <powerpc64-linux-gnu/python2.7/pyconfig.h>
+#  endif
+# elif defined(__powerpc__)
+#  include <powerpc-linux-gnu/python2.7/pyconfig.h>
+# elif defined(__s390x__)
+#  include <s390x-linux-gnu/python2.7/pyconfig.h>
+# elif defined(__s390__)
+#  include <s390-linux-gnu/python2.7/pyconfig.h>
+# elif defined(__sh__) && defined(__LITTLE_ENDIAN__)
+#  include <sh4-linux-gnu/python2.7/pyconfig.h>
+# elif defined(__sparc__) && defined(__arch64__)
+#  include <sparc64-linux-gnu/python2.7/pyconfig.h>
+# elif defined(__sparc__)
+#  include <sparc-linux-gnu/python2.7/pyconfig.h>
+# else
+#   error unknown multiarch location for pyconfig.h
+# endif
+#elif defined(__FreeBSD_kernel__)
+# if defined(__LP64__)
+#  include <x86_64-kfreebsd-gnu/python2.7/pyconfig.h>
+# elif defined(__i386__)
+#  include <i386-kfreebsd-gnu/python2.7/pyconfig.h>
+# else
+#   error unknown multiarch location for pyconfig.h
+# endif
+#elif defined(__gnu_hurd__)
+# include <i386-gnu/python2.7/pyconfig.h>
+#else
+# error unknown multiarch location for pyconfig.h
+#endif

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib/python2.7/config-x86_64-linux-gnu/Makefile

@@ -0,0 +1,1499 @@
+# Generated automatically from Makefile.pre by makesetup.
+# Top-level Makefile for Python
+#
+# As distributed, this file is called Makefile.pre.in; it is processed
+# into the real Makefile by running the script ./configure, which
+# replaces things like @spam@ with values appropriate for your system.
+# This means that if you edit Makefile, your changes get lost the next
+# time you run the configure script.  Ideally, you can do:
+#
+#	./configure
+#	make
+#	make test
+#	make install
+#
+# If you have a previous version of Python installed that you don't
+# want to overwrite, you can use "make altinstall" instead of "make
+# install".  Refer to the "Installing" section in the README file for
+# additional details.
+#
+# See also the section "Build instructions" in the README file.
+
+# === Variables set by makesetup ===
+
+MODOBJS=          Modules/threadmodule.o  Modules/signalmodule.o  Modules/arraymodule.o  Modules/cmathmodule.o  Modules/mathmodule.o Modules/_math.o  Modules/_struct.o  Modules/timemodule.o  Modules/operator.o  Modules/_randommodule.o  Modules/_collectionsmodule.o  Modules/_heapqmodule.o  Modules/itertoolsmodule.o  Modules/stropmodule.o  Modules/_functoolsmodule.o  Modules/_bisectmodule.o  Modules/unicodedata.o  Modules/_localemodule.o  Modules/bufferedio.o Modules/bytesio.o Modules/fileio.o Modules/iobase.o Modules/_iomodule.o Modules/stringio.o Modules/textio.o  Modules/fcntlmodule.o  Modules/spwdmodule.o  Modules/grpmodule.o  Modules/selectmodule.o  Modules/socketmodule.o Modules/timemodule.o  Modules/md5module.o Modules/md5.o  Modules/shamodule.o  Modules/sha256module.o  Modules/sha512module.o  Modules/syslogmodule.o  Modules/binascii.o  Modules/cStringIO.o  Modules/cPickle.o  Modules/zlibmodule.o  Modules/posixmodule.o  Modules/errnomodule.o  Modules/pwdmodule.o  Modules/_sre.o  Modules/_codecsmodule.o  Modules/_weakref.o  Modules/zipimport.o  Modules/symtablemodule.o  Modules/xxsubtype.o
+MODLIBS=        $(LOCALMODLIBS) $(BASEMODLIBS)
+
+# === Variables set by configure
+VERSION=	2.7
+srcdir=		..
+VPATH=		..
+abs_srcdir=	/build/buildd/python2.7-2.7.6/build-shared/..
+abs_builddir=	/build/buildd/python2.7-2.7.6/build-shared
+build=		x86_64-unknown-linux-gnu
+host=		x86_64-unknown-linux-gnu
+
+CC=		x86_64-linux-gnu-gcc -pthread
+CXX=		c++ -pthread
+MAINCC=		$(CC)
+LINKCC=		$(PURIFY) $(MAINCC)
+AR=		ar
+RANLIB=		ranlib
+SVNVERSION=	echo Unversioned directory
+HGVERSION=	
+HGTAG=		
+HGBRANCH=	
+
+GNULD=          yes
+
+# Shell used by make (some versions default to the login shell, which is bad)
+SHELL=		/bin/sh
+
+# Use this to make a link between python$(VERSION) and python in $(BINDIR)
+LN=		ln
+
+# Portable install script (configure doesn't always guess right)
+INSTALL=	/usr/bin/install -c
+INSTALL_PROGRAM=${INSTALL}
+INSTALL_SCRIPT= ${INSTALL}
+INSTALL_DATA=	${INSTALL} -m 644
+# Shared libraries must be installed with executable mode on some systems;
+# rather than figuring out exactly which, we always give them executable mode.
+# Also, making them read-only seems to be a good idea...
+INSTALL_SHARED= ${INSTALL} -m 555
+
+MKDIR_P=	/bin/mkdir -p
+
+MAKESETUP=      $(srcdir)/Modules/makesetup
+
+# Compiler options
+OPT=		-DNDEBUG -g -fwrapv -O2 -Wall -Wstrict-prototypes
+BASECFLAGS=	 -fno-strict-aliasing
+CONFIGURE_CFLAGS=	-D_FORTIFY_SOURCE=2 -g -fstack-protector --param=ssp-buffer-size=4 -Wformat -Werror=format-security 
+CONFIGURE_CPPFLAGS=	
+CONFIGURE_LDFLAGS=	-Wl,-Bsymbolic-functions -Wl,-z,relro
+# Avoid assigning CFLAGS, LDFLAGS, etc. so users can use them on the
+# command line to append to these values without stomping the pre-set
+# values.
+PY_CFLAGS=	$(BASECFLAGS) $(OPT) $(CONFIGURE_CFLAGS) $(CFLAGS) $(EXTRA_CFLAGS)
+# Both CPPFLAGS and LDFLAGS need to contain the shell's value for setup.py to
+# be able to build extension modules using the directories specified in the
+# environment variables
+PY_CPPFLAGS=	-I. -IInclude -I$(srcdir)/Include $(CONFIGURE_CPPFLAGS) $(CPPFLAGS)
+PY_LDFLAGS=	$(CONFIGURE_LDFLAGS) $(LDFLAGS)
+LDLAST=		
+SGI_ABI=	
+CCSHARED=	-fPIC
+LINKFORSHARED=	-Xlinker -export-dynamic -Wl,-O1 -Wl,-Bsymbolic-functions
+ARFLAGS=	rc
+# Extra C flags added for building the interpreter object files.
+CFLAGSFORSHARED=$(CCSHARED)
+# C flags used for building the interpreter object files
+PY_CORE_CFLAGS=	$(PY_CFLAGS) $(PY_CPPFLAGS) $(CFLAGSFORSHARED) -DPy_BUILD_CORE
+
+
+# Machine-dependent subdirectories
+MACHDEP=	linux2
+
+# Multiarch directory (may be empty)
+MULTIARCH=	x86_64-linux-gnu
+
+# Multiarch directory (may be empty)
+MULTIARCH=	x86_64-linux-gnu
+
+# Install prefix for architecture-independent files
+prefix=		/usr
+
+# Install prefix for architecture-dependent files
+exec_prefix=	${prefix}
+
+# Install prefix for data files
+datarootdir=    ${prefix}/share
+
+# Expanded directories
+BINDIR=		${exec_prefix}/bin
+LIBDIR=		${exec_prefix}/lib
+MANDIR=		${datarootdir}/man
+INCLUDEDIR=	${prefix}/include
+CONFINCLUDEDIR=	$(exec_prefix)/include
+SCRIPTDIR=	$(prefix)/lib
+
+# Detailed destination directories
+BINLIBDEST=	$(LIBDIR)/python$(VERSION)
+LIBDEST=	$(SCRIPTDIR)/python$(VERSION)
+INCLUDEPY=	$(INCLUDEDIR)/python$(VERSION)$(DEBUG_EXT)
+CONFINCLUDEPY=	$(CONFINCLUDEDIR)/python$(VERSION)$(DEBUG_EXT)
+LIBP=		$(LIBDIR)/python$(VERSION)
+
+# Symbols used for using shared libraries
+SO=		.so
+LDSHARED=	$(CC) -shared -Wl,-O1 -Wl,-Bsymbolic-functions $(PY_LDFLAGS)
+BLDSHARED=	$(CC) -shared -Wl,-O1 -Wl,-Bsymbolic-functions $(PY_LDFLAGS) $(PY_CFLAGS)
+LDCXXSHARED=	$(CXX) -shared -Wl,-O1 -Wl,-Bsymbolic-functions
+DESTSHARED=	$(BINLIBDEST)/lib-dynload
+
+# Executable suffix (.exe on Windows and Mac OS X)
+EXE=		
+BUILDEXE=	
+
+DEBUG_EXT=	
+
+# Short name and location for Mac OS X Python framework
+UNIVERSALSDK=
+PYTHONFRAMEWORK=	
+PYTHONFRAMEWORKDIR=	no-framework
+PYTHONFRAMEWORKPREFIX=	
+PYTHONFRAMEWORKINSTALLDIR= 
+# Deployment target selected during configure, to be checked
+# by distutils. The export statement is needed to ensure that the
+# deployment target is active during build.
+MACOSX_DEPLOYMENT_TARGET=
+#export MACOSX_DEPLOYMENT_TARGET
+
+# Options to enable prebinding (for fast startup prior to Mac OS X 10.3)
+OTHER_LIBTOOL_OPT=
+
+# Environment to run shared python without installed libraries
+RUNSHARED=
+
+# Modes for directories, executables and data files created by the
+# install process.  Default to user-only-writable for all file types.
+DIRMODE=	755
+EXEMODE=	755
+FILEMODE=	644
+
+# configure script arguments
+CONFIG_ARGS=	 '--enable-shared' '--prefix=/usr' '--enable-ipv6' '--enable-unicode=ucs4' '--with-dbmliborder=bdb:gdbm' '--with-system-expat' '--with-system-ffi' '--with-fpectl' 'CC=x86_64-linux-gnu-gcc' 'CFLAGS=-D_FORTIFY_SOURCE=2 -g -fstack-protector --param=ssp-buffer-size=4 -Wformat -Werror=format-security ' 'LDFLAGS=-Wl,-Bsymbolic-functions -Wl,-z,relro'
+
+
+# Subdirectories with code
+SRCDIRS= 	Parser Grammar Objects Python Modules Mac
+
+# Other subdirectories
+SUBDIRSTOO=	Include Lib Misc Demo
+
+# Files and directories to be distributed
+CONFIGFILES=	configure configure.ac acconfig.h pyconfig.h.in Makefile.pre.in
+DISTFILES=	README ChangeLog $(CONFIGFILES)
+DISTDIRS=	$(SUBDIRS) $(SUBDIRSTOO) Ext-dummy
+DIST=		$(DISTFILES) $(DISTDIRS)
+
+
+LIBRARY=	libpython$(VERSION)$(DEBUG_EXT).a
+LDLIBRARY=      libpython$(VERSION)$(DEBUG_EXT).so
+BLDLIBRARY=     -lpython$(VERSION)$(DEBUG_EXT)
+DLLLIBRARY=	
+LDLIBRARYDIR=   
+INSTSONAME=	libpython$(VERSION)$(DEBUG_EXT).so.1.0
+
+
+LIBS=		-lpthread -ldl  -lutil
+LIBM=		-lm
+LIBC=		
+SYSLIBS=	$(LIBM) $(LIBC)
+SHLIBS=		$(LIBS)
+
+THREADOBJ=	Python/thread.o
+DLINCLDIR=	.
+DYNLOADFILE=	dynload_shlib.o
+MACHDEP_OBJS=	
+LIBOBJDIR=	Python/
+LIBOBJS=	
+UNICODE_OBJS=   Objects/unicodeobject.o Objects/unicodectype.o
+
+PYTHON=		python$(EXE)
+BUILDPYTHON=	python$(BUILDEXE)
+
+PYTHON_FOR_BUILD=./$(BUILDPYTHON) -E
+_PYTHON_HOST_PLATFORM=
+HOST_GNU_TYPE=  x86_64-unknown-linux-gnu
+
+# Tcl and Tk config info from --with-tcltk-includes and -libs options
+TCLTK_INCLUDES=	
+TCLTK_LIBS=	
+
+# The task to run while instrument when building the profile-opt target
+PROFILE_TASK=	$(srcdir)/Tools/pybench/pybench.py -n 2 --with-gc --with-syscheck
+#PROFILE_TASK=	$(srcdir)/Lib/test/regrtest.py
+
+# === Definitions added by makesetup ===
+
+LOCALMODLIBS=                                 -L$(exec_prefix)/lib -lz         
+BASEMODLIBS=
+GLHACK=-Dclear=__GLclear
+PYTHONPATH=$(COREPYTHONPATH)
+COREPYTHONPATH=$(DESTPATH)$(SITEPATH)$(TESTPATH)$(MACHDEPPATH)$(EXTRAMACHDEPPATH)$(TKPATH)$(OLDPATH)
+OLDPATH=:lib-old
+TKPATH=:lib-tk
+EXTRAMACHDEPPATH=
+MACHDEPPATH=:plat-$(MULTIARCH)
+TESTPATH=
+SITEPATH=
+DESTPATH=
+MACHDESTLIB=$(BINLIBDEST)
+DESTLIB=$(LIBDEST)
+
+
+
+##########################################################################
+# Modules
+MODULE_OBJS=	\
+		Modules/config.o \
+		Modules/getpath.o \
+		Modules/main.o \
+		Modules/gcmodule.o
+
+# Used of signalmodule.o is not available
+SIGNAL_OBJS=	
+
+
+##########################################################################
+# Grammar
+GRAMMAR_H=	Include/graminit.h
+GRAMMAR_C=	Python/graminit.c
+GRAMMAR_INPUT=	$(srcdir)/Grammar/Grammar
+
+
+LIBFFI_INCLUDEDIR=	
+
+##########################################################################
+# Parser
+PGEN=		Parser/pgen$(EXE)
+
+PSRCS=		\
+		Parser/acceler.c \
+		Parser/grammar1.c \
+		Parser/listnode.c \
+		Parser/node.c \
+		Parser/parser.c \
+		Parser/parsetok.c \
+		Parser/bitset.c \
+		Parser/metagrammar.c \
+		Parser/firstsets.c \
+		Parser/grammar.c \
+		Parser/pgen.c
+
+POBJS=		\
+		Parser/acceler.o \
+		Parser/grammar1.o \
+		Parser/listnode.o \
+		Parser/node.o \
+		Parser/parser.o \
+		Parser/parsetok.o \
+		Parser/bitset.o \
+		Parser/metagrammar.o \
+		Parser/firstsets.o \
+		Parser/grammar.o \
+		Parser/pgen.o
+
+PARSER_OBJS=	$(POBJS) Parser/myreadline.o Parser/tokenizer.o
+
+PGSRCS=		\
+		Objects/obmalloc.c \
+		Python/mysnprintf.c \
+		Python/pyctype.c \
+		Parser/tokenizer_pgen.c \
+		Parser/printgrammar.c \
+		Parser/pgenmain.c
+
+PGOBJS=		\
+		Objects/obmalloc.o \
+		Python/mysnprintf.o \
+		Python/pyctype.o \
+		Parser/tokenizer_pgen.o \
+		Parser/printgrammar.o \
+		Parser/pgenmain.o
+
+PARSER_HEADERS= \
+		Parser/parser.h \
+		Parser/tokenizer.h
+
+PGENSRCS=	$(PSRCS) $(PGSRCS)
+PGENOBJS=	$(POBJS) $(PGOBJS)
+
+##########################################################################
+# AST
+AST_H_DIR=	Include
+AST_H=		$(AST_H_DIR)/Python-ast.h
+AST_C_DIR=	Python
+AST_C=		$(AST_C_DIR)/Python-ast.c
+AST_ASDL=	$(srcdir)/Parser/Python.asdl
+
+ASDLGEN_FILES=	$(srcdir)/Parser/asdl.py $(srcdir)/Parser/asdl_c.py
+# XXX Note that a build now requires Python exist before the build starts
+ASDLGEN=	$(srcdir)/Parser/asdl_c.py
+
+##########################################################################
+# Python
+PYTHON_OBJS=	\
+		Python/_warnings.o \
+		Python/Python-ast.o \
+		Python/asdl.o \
+		Python/ast.o \
+		Python/bltinmodule.o \
+		Python/ceval.o \
+		Python/compile.o \
+		Python/codecs.o \
+		Python/errors.o \
+		Python/frozen.o \
+		Python/frozenmain.o \
+		Python/future.o \
+		Python/getargs.o \
+		Python/getcompiler.o \
+		Python/getcopyright.o \
+		Python/getplatform.o \
+		Python/getversion.o \
+		Python/graminit.o \
+		Python/import.o \
+		Python/importdl.o \
+		Python/marshal.o \
+		Python/modsupport.o \
+		Python/mystrtoul.o \
+		Python/mysnprintf.o \
+		Python/peephole.o \
+		Python/pyarena.o \
+		Python/pyctype.o \
+		Python/pyfpe.o \
+		Python/pymath.o \
+		Python/pystate.o \
+		Python/pythonrun.o \
+                Python/random.o \
+		Python/structmember.o \
+		Python/symtable.o \
+		Python/sysmodule.o \
+		Python/traceback.o \
+		Python/getopt.o \
+		Python/pystrcmp.o \
+		Python/pystrtod.o \
+		Python/dtoa.o \
+		Python/formatter_unicode.o \
+		Python/formatter_string.o \
+		Python/$(DYNLOADFILE) \
+		$(LIBOBJS) \
+		$(MACHDEP_OBJS) \
+		$(THREADOBJ)
+
+
+##########################################################################
+# Objects
+OBJECT_OBJS=	\
+		Objects/abstract.o \
+		Objects/boolobject.o \
+		Objects/bufferobject.o \
+		Objects/bytes_methods.o \
+		Objects/bytearrayobject.o \
+		Objects/capsule.o \
+		Objects/cellobject.o \
+		Objects/classobject.o \
+		Objects/cobject.o \
+		Objects/codeobject.o \
+		Objects/complexobject.o \
+		Objects/descrobject.o \
+		Objects/enumobject.o \
+		Objects/exceptions.o \
+		Objects/genobject.o \
+		Objects/fileobject.o \
+		Objects/floatobject.o \
+		Objects/frameobject.o \
+		Objects/funcobject.o \
+		Objects/intobject.o \
+		Objects/iterobject.o \
+		Objects/listobject.o \
+		Objects/longobject.o \
+		Objects/dictobject.o \
+		Objects/memoryobject.o \
+		Objects/methodobject.o \
+		Objects/moduleobject.o \
+		Objects/object.o \
+		Objects/obmalloc.o \
+		Objects/rangeobject.o \
+		Objects/setobject.o \
+		Objects/sliceobject.o \
+		Objects/stringobject.o \
+		Objects/structseq.o \
+		Objects/tupleobject.o \
+		Objects/typeobject.o \
+		Objects/weakrefobject.o \
+		$(UNICODE_OBJS)
+
+
+##########################################################################
+# objects that get linked into the Python library
+LIBRARY_OBJS=	\
+		Modules/getbuildinfo.o \
+		$(PARSER_OBJS) \
+		$(OBJECT_OBJS) \
+		$(PYTHON_OBJS) \
+		$(MODULE_OBJS) \
+		$(SIGNAL_OBJS) \
+		$(sort $(MODOBJS))
+
+#########################################################################
+# Rules
+
+# Default target
+all:		build_all
+build_all:	$(BUILDPYTHON) oldsharedmods sharedmods gdbhooks
+
+# Compile a binary with gcc profile guided optimization.
+profile-opt:
+	@echo "Building with support for profile generation:"
+	$(MAKE) clean
+	$(MAKE) build_all_generate_profile
+	@echo "Running benchmark to generate profile data:"
+	$(MAKE) profile-removal
+	$(MAKE) run_profile_task
+	@echo "Rebuilding with profile guided optimizations:"
+	$(MAKE) clean
+	$(MAKE) build_all_use_profile
+
+build_all_generate_profile:
+	$(MAKE) all PY_CFLAGS="$(PY_CFLAGS) -fprofile-generate" LIBS="$(LIBS) -lgcov"
+
+run_profile_task:
+	: # FIXME: can't run for a cross build
+	-./$(BUILDPYTHON) $(PROFILE_TASK)
+
+build_all_use_profile:
+	$(MAKE) all PY_CFLAGS="$(PY_CFLAGS) -fprofile-use -fprofile-correction"
+
+coverage:
+	@echo "Building with support for coverage checking:"
+	$(MAKE) clean
+	$(MAKE) all PY_CFLAGS="$(PY_CFLAGS) -O0 -pg -fprofile-arcs -ftest-coverage" LIBS="$(LIBS) -lgcov"
+
+
+# Build the interpreter
+$(BUILDPYTHON):	Modules/python.o $(LIBRARY) $(LDLIBRARY)
+		$(LINKCC) $(PY_LDFLAGS) $(PY_CFLAGS) $(LINKFORSHARED) -o $@ \
+			Modules/python.o \
+			-Wl,--whole-archive $(BLDLIBRARY) -Wl,--no-whole-archive $(LIBS) $(MODLIBS) $(SYSLIBS) $(LDLAST)
+
+platform: $(BUILDPYTHON) pybuilddir.txt
+	$(RUNSHARED) $(PYTHON_FOR_BUILD) -c 'import sys ; from sysconfig import get_platform ; print get_platform()+"-"+sys.version[0:3]' >platform
+
+# Create build directory and generate the sysconfig build-time data there.
+# pybuilddir.txt contains the name of the build dir and is used for
+# sys.path fixup -- see Modules/getpath.c.
+pybuilddir.txt: $(BUILDPYTHON)
+		$(RUNSHARED) $(PYTHON_FOR_BUILD) -S -m sysconfig --generate-posix-vars
+
+# Build the shared modules
+# Under GNU make, MAKEFLAGS are sorted and normalized; the 's' for
+# -s, --silent or --quiet is always the first char.
+# Under BSD make, MAKEFLAGS might be " -s -v x=y".
+sharedmods: $(BUILDPYTHON) pybuilddir.txt
+	@case "$$MAKEFLAGS" in \
+	    *\ -s*|s*) quiet="-q";; \
+	    *) quiet="";; \
+	esac; \
+	$(RUNSHARED) CC='$(CC)' LDSHARED='$(BLDSHARED)' LDFLAGS='$(PY_LDFLAGS)' OPT='$(OPT)' \
+		_TCLTK_INCLUDES='$(TCLTK_INCLUDES)' _TCLTK_LIBS='$(TCLTK_LIBS)' \
+		$(PYTHON_FOR_BUILD) $(srcdir)/setup.py $$quiet build
+
+# Build static library
+# avoid long command lines, same as LIBRARY_OBJS
+$(LIBRARY): $(LIBRARY_OBJS)
+	-rm -f $@
+	$(AR) $(ARFLAGS) $@ Modules/getbuildinfo.o
+	$(AR) $(ARFLAGS) $@ $(PARSER_OBJS)
+	$(AR) $(ARFLAGS) $@ $(OBJECT_OBJS)
+	$(AR) $(ARFLAGS) $@ $(PYTHON_OBJS)
+	$(AR) $(ARFLAGS) $@ $(MODULE_OBJS) $(SIGNAL_OBJS)
+	$(AR) $(ARFLAGS) $@ $(sort $(MODOBJS))
+	$(RANLIB) $@
+
+libpython$(VERSION)$(DEBUG_EXT).so: $(LIBRARY_OBJS)
+	if test $(INSTSONAME) != $(LDLIBRARY); then \
+		$(BLDSHARED) $(PY_LDFLAGS) -Wl,-h$(INSTSONAME) -o $(INSTSONAME) $(LIBRARY_OBJS) $(MODLIBS) $(SHLIBS) $(LIBC) $(LIBM) $(LDLAST); \
+		$(LN) -f $(INSTSONAME) $@; \
+	else \
+		$(BLDSHARED) $(PY_LDFLAGS) -o $@ $(LIBRARY_OBJS) $(MODLIBS) $(SHLIBS) $(LIBC) $(LIBM) $(LDLAST); \
+	fi
+
+libpython$(VERSION).dylib: $(LIBRARY_OBJS)
+	 $(CC) -dynamiclib -Wl,-single_module $(PY_LDFLAGS) -undefined dynamic_lookup -Wl,-install_name,$(prefix)/lib/libpython$(VERSION).dylib -Wl,-compatibility_version,$(VERSION) -Wl,-current_version,$(VERSION) -o $@ $(LIBRARY_OBJS) $(SHLIBS) $(LIBC) $(LIBM) $(LDLAST); \
+
+
+libpython$(VERSION).sl: $(LIBRARY_OBJS)
+	$(LDSHARED) $(PY_LDFLAGS) -o $@ $(LIBRARY_OBJS) $(MODLIBS) $(SHLIBS) $(LIBC) $(LIBM) $(LDLAST)
+
+# Copy up the gdb python hooks into a position where they can be automatically
+# loaded by gdb during Lib/test/test_gdb.py
+#
+# Distributors are likely to want to install this somewhere else e.g. relative
+# to the stripped DWARF data for the shared library.
+gdbhooks: $(BUILDPYTHON)-gdb.py
+
+SRC_GDB_HOOKS=$(srcdir)/Tools/gdb/libpython.py
+$(BUILDPYTHON)-gdb.py: $(SRC_GDB_HOOKS)
+	$(INSTALL_DATA) $(SRC_GDB_HOOKS) $(BUILDPYTHON)-gdb.py
+
+# This rule is here for OPENSTEP/Rhapsody/MacOSX. It builds a temporary
+# minimal framework (not including the Lib directory and such) in the current
+# directory.
+RESSRCDIR=Mac/Resources/framework
+$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK): \
+		$(LIBRARY) \
+		$(RESSRCDIR)/Info.plist
+	$(INSTALL) -d -m $(DIRMODE) $(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)
+	$(CC) -o $(LDLIBRARY) $(LDFLAGS)  -dynamiclib \
+		-all_load $(LIBRARY) -Wl,-single_module \
+		-install_name $(DESTDIR)$(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK) \
+		-compatibility_version $(VERSION) \
+		-current_version $(VERSION);
+	$(INSTALL) -d -m $(DIRMODE)  \
+		$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/Resources/English.lproj
+	$(INSTALL_DATA) $(RESSRCDIR)/Info.plist \
+		$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/Resources/Info.plist
+	$(LN) -fsn $(VERSION) $(PYTHONFRAMEWORKDIR)/Versions/Current
+	$(LN) -fsn Versions/Current/$(PYTHONFRAMEWORK) $(PYTHONFRAMEWORKDIR)/$(PYTHONFRAMEWORK)
+	$(LN) -fsn Versions/Current/Headers $(PYTHONFRAMEWORKDIR)/Headers
+	$(LN) -fsn Versions/Current/Resources $(PYTHONFRAMEWORKDIR)/Resources
+
+# This rule builds the Cygwin Python DLL and import library if configured
+# for a shared core library; otherwise, this rule is a noop.
+$(DLLLIBRARY) libpython$(VERSION).dll.a: $(LIBRARY_OBJS)
+	if test -n "$(DLLLIBRARY)"; then \
+		$(LDSHARED) $(PY_LDFLAGS) -Wl,--out-implib=$@ -o $(DLLLIBRARY) $^ \
+			$(LIBS) $(MODLIBS) $(SYSLIBS) $(LDLAST); \
+	else true; \
+	fi
+
+
+oldsharedmods: $(SHAREDMODS)
+
+
+Makefile Modules/config.c: Makefile.pre \
+				$(srcdir)/Modules/config.c.in \
+				$(MAKESETUP) \
+				Modules/Setup.config \
+				Modules/Setup \
+				Modules/Setup.local
+	$(SHELL) $(MAKESETUP) -c $(srcdir)/Modules/config.c.in \
+				-s Modules \
+				Modules/Setup.config \
+				Modules/Setup.local \
+				Modules/Setup
+	@mv config.c Modules
+	@echo "The Makefile was updated, you may need to re-run make."
+
+Python/dynload_shlib.o: $(srcdir)/Python/dynload_shlib.c Makefile
+	$(CC) -c $(PY_CORE_CFLAGS) \
+		$(if $(MULTIARCH),-DMULTIARCH='"$(MULTIARCH)"') \
+		-o $@ $(srcdir)/Python/dynload_shlib.c
+
+Modules/Setup: $(srcdir)/Modules/Setup.dist
+	@if test -f Modules/Setup; then \
+		echo "-----------------------------------------------"; \
+		echo "Modules/Setup.dist is newer than Modules/Setup;"; \
+		echo "check to make sure you have all the updates you"; \
+		echo "need in your Modules/Setup file."; \
+		echo "Usually, copying Modules/Setup.dist to Modules/Setup will work."; \
+		echo "-----------------------------------------------"; \
+	fi
+
+############################################################################
+# Special rules for object files
+
+Modules/getbuildinfo.o: $(PARSER_OBJS) \
+		$(OBJECT_OBJS) \
+		$(PYTHON_OBJS) \
+		$(MODULE_OBJS) \
+		$(SIGNAL_OBJS) \
+		$(MODOBJS) \
+		$(srcdir)/Modules/getbuildinfo.c
+	$(CC) -c $(PY_CORE_CFLAGS) \
+	      -DSVNVERSION="\"`LC_ALL=C $(SVNVERSION)`\"" \
+	      -DHGVERSION="\"`LC_ALL=C $(HGVERSION)`\"" \
+	      -DHGTAG="\"`LC_ALL=C $(HGTAG)`\"" \
+	      -DHGBRANCH="\"`LC_ALL=C $(HGBRANCH)`\"" \
+	      -o $@ $(srcdir)/Modules/getbuildinfo.c
+
+Modules/getpath.o: $(srcdir)/Modules/getpath.c Makefile
+	$(CC) -c $(PY_CORE_CFLAGS) -DPYTHONPATH='"$(PYTHONPATH)"' \
+		-DPREFIX='"$(prefix)"' \
+		-DEXEC_PREFIX='"$(exec_prefix)"' \
+		-DVERSION='"$(VERSION)"' \
+		-DVPATH='"$(VPATH)"' \
+		-o $@ $(srcdir)/Modules/getpath.c
+
+Modules/python.o: $(srcdir)/Modules/python.c
+	$(MAINCC) -c $(PY_CORE_CFLAGS) -o $@ $(srcdir)/Modules/python.c
+
+Modules/posixmodule.o: $(srcdir)/Modules/posixmodule.c $(srcdir)/Modules/posixmodule.h
+
+Modules/grpmodule.o: $(srcdir)/Modules/grpmodule.c $(srcdir)/Modules/posixmodule.h
+
+Modules/pwdmodule.o: $(srcdir)/Modules/pwdmodule.c $(srcdir)/Modules/posixmodule.h
+
+$(GRAMMAR_H): $(GRAMMAR_INPUT) $(PGENSRCS)
+		@$(MKDIR_P) Include
+		$(MAKE) $(PGEN)
+		$(PGEN) $(GRAMMAR_INPUT) $(GRAMMAR_H) $(GRAMMAR_C)
+$(GRAMMAR_C): $(GRAMMAR_H) $(GRAMMAR_INPUT) $(PGENSRCS)
+		$(MAKE) $(GRAMMAR_H)
+		touch $(GRAMMAR_C)
+
+$(PGEN):	$(PGENOBJS)
+		$(CC) $(OPT) $(PY_LDFLAGS) $(PGENOBJS) $(LIBS) -o $(PGEN)
+
+Parser/grammar.o:	$(srcdir)/Parser/grammar.c \
+				$(srcdir)/Include/token.h \
+				$(srcdir)/Include/grammar.h
+Parser/metagrammar.o:	$(srcdir)/Parser/metagrammar.c
+
+Parser/tokenizer_pgen.o:	$(srcdir)/Parser/tokenizer.c
+
+Parser/pgenmain.o:	$(srcdir)/Include/parsetok.h
+
+$(AST_H): $(AST_ASDL) $(ASDLGEN_FILES)
+	$(MKDIR_P) $(AST_H_DIR)
+	$(ASDLGEN) -h $(AST_H_DIR) $(AST_ASDL)
+
+$(AST_C): $(AST_ASDL) $(ASDLGEN_FILES)
+	$(MKDIR_P) $(AST_C_DIR)
+	$(ASDLGEN) -c $(AST_C_DIR) $(AST_ASDL)
+
+Python/compile.o Python/symtable.o Python/ast.o: $(GRAMMAR_H) $(AST_H)
+
+Python/getplatform.o: $(srcdir)/Python/getplatform.c
+		$(CC) -c $(PY_CORE_CFLAGS) -DPLATFORM='"$(MACHDEP)"' -o $@ $(srcdir)/Python/getplatform.c
+
+Python/importdl.o: $(srcdir)/Python/importdl.c
+		$(CC) -c $(PY_CORE_CFLAGS) -I$(DLINCLDIR) -o $@ $(srcdir)/Python/importdl.c
+
+Objects/unicodectype.o:	$(srcdir)/Objects/unicodectype.c \
+				$(srcdir)/Objects/unicodetype_db.h
+
+STRINGLIB_HEADERS= \
+		$(srcdir)/Include/bytes_methods.h \
+		$(srcdir)/Objects/stringlib/count.h \
+		$(srcdir)/Objects/stringlib/ctype.h \
+		$(srcdir)/Objects/stringlib/fastsearch.h \
+		$(srcdir)/Objects/stringlib/find.h \
+		$(srcdir)/Objects/stringlib/formatter.h \
+		$(srcdir)/Objects/stringlib/partition.h \
+		$(srcdir)/Objects/stringlib/split.h \
+		$(srcdir)/Objects/stringlib/stringdefs.h \
+		$(srcdir)/Objects/stringlib/string_format.h \
+		$(srcdir)/Objects/stringlib/transmogrify.h \
+		$(srcdir)/Objects/stringlib/unicodedefs.h \
+		$(srcdir)/Objects/stringlib/localeutil.h
+
+Objects/unicodeobject.o: $(srcdir)/Objects/unicodeobject.c \
+				$(STRINGLIB_HEADERS)
+
+Objects/bytearrayobject.o: $(srcdir)/Objects/bytearrayobject.c \
+				$(STRINGLIB_HEADERS)
+
+Objects/stringobject.o: $(srcdir)/Objects/stringobject.c \
+				$(STRINGLIB_HEADERS)
+
+Python/formatter_unicode.o: $(srcdir)/Python/formatter_unicode.c \
+				$(STRINGLIB_HEADERS)
+
+Python/formatter_string.o: $(srcdir)/Python/formatter_string.c \
+				$(STRINGLIB_HEADERS)
+
+############################################################################
+# Header files
+
+PYTHON_HEADERS= \
+		Include/Python-ast.h \
+		Include/Python.h \
+		Include/abstract.h \
+		Include/asdl.h \
+		Include/ast.h \
+		Include/bitset.h \
+		Include/boolobject.h \
+		Include/bytearrayobject.h \
+		Include/bytes_methods.h \
+		Include/bytesobject.h \
+		Include/bufferobject.h \
+		Include/cellobject.h \
+		Include/ceval.h \
+		Include/classobject.h \
+		Include/cobject.h \
+		Include/code.h \
+		Include/codecs.h \
+		Include/compile.h \
+		Include/complexobject.h \
+		Include/descrobject.h \
+		Include/dictobject.h \
+		Include/dtoa.h \
+		Include/enumobject.h \
+		Include/errcode.h \
+		Include/eval.h \
+		Include/fileobject.h \
+		Include/floatobject.h \
+		Include/frameobject.h \
+		Include/funcobject.h \
+		Include/genobject.h \
+		Include/import.h \
+		Include/intobject.h \
+		Include/intrcheck.h \
+		Include/iterobject.h \
+		Include/listobject.h \
+		Include/longintrepr.h \
+		Include/longobject.h \
+		Include/marshal.h \
+		Include/memoryobject.h \
+		Include/metagrammar.h \
+		Include/methodobject.h \
+		Include/modsupport.h \
+		Include/moduleobject.h \
+		Include/node.h \
+		Include/object.h \
+		Include/objimpl.h \
+		Include/opcode.h \
+		Include/osdefs.h \
+		Include/parsetok.h \
+		Include/patchlevel.h \
+		Include/pgen.h \
+		Include/pgenheaders.h \
+		Include/pyarena.h \
+		Include/pycapsule.h \
+		Include/pyctype.h \
+		Include/pydebug.h \
+		Include/pyerrors.h \
+		Include/pyfpe.h \
+		Include/pymath.h \
+		Include/pygetopt.h \
+		Include/pymem.h \
+		Include/pyport.h \
+		Include/pystate.h \
+		Include/pystrcmp.h \
+		Include/pystrtod.h \
+		Include/pythonrun.h \
+		Include/pythread.h \
+		Include/rangeobject.h \
+		Include/setobject.h \
+		Include/sliceobject.h \
+		Include/stringobject.h \
+		Include/structmember.h \
+		Include/structseq.h \
+		Include/symtable.h \
+		Include/sysmodule.h \
+		Include/traceback.h \
+		Include/tupleobject.h \
+		Include/ucnhash.h \
+		Include/unicodeobject.h \
+		Include/warnings.h \
+		Include/weakrefobject.h \
+		pyconfig.h \
+		$(PARSER_HEADERS) \
+		$(AST_H)
+
+$(LIBRARY_OBJS) $(MODOBJS) Modules/python.o: $(PYTHON_HEADERS)
+
+
+######################################################################
+
+# Test the interpreter (twice, once without .pyc files, once with)
+# In the past, we've had problems where bugs in the marshalling or
+# elsewhere caused bytecode read from .pyc files to behave differently
+# than bytecode generated directly from a .py source file.  Sometimes
+# the bytecode read from a .pyc file had the bug, sometimes the directly
+# generated bytecode.  This is sometimes a very shy bug needing a lot of
+# sample data.
+
+TESTOPTS=	-l $(EXTRATESTOPTS)
+TESTPROG=	$(srcdir)/Lib/test/regrtest.py
+TESTPYTHON=	$(RUNSHARED) ./$(BUILDPYTHON) -Wd -3 -E -tt $(TESTPYTHONOPTS)
+test:		all platform
+		-find $(srcdir)/Lib -name '*.py[co]' -print | xargs rm -f
+		-$(TESTPYTHON) $(TESTPROG) $(TESTOPTS)
+		$(TESTPYTHON) $(TESTPROG) $(TESTOPTS)
+
+testall:	all platform
+		-find $(srcdir)/Lib -name '*.py[co]' -print | xargs rm -f
+		$(TESTPYTHON) $(srcdir)/Lib/compileall.py
+		-find $(srcdir)/Lib -name '*.py[co]' -print | xargs rm -f
+		-$(TESTPYTHON) $(TESTPROG) -uall $(TESTOPTS)
+		$(TESTPYTHON) $(TESTPROG) -uall $(TESTOPTS)
+
+#  Run the unitests for both architectures in a Universal build on OSX
+#  Must be run on an Intel box.
+testuniversal:	all platform
+		if [ `arch` != 'i386' ];then \
+			echo "This can only be used on OSX/i386" ;\
+			exit 1 ;\
+		fi
+		-find $(srcdir)/Lib -name '*.py[co]' -print | xargs rm -f
+		-$(TESTPYTHON) $(TESTPROG) -uall $(TESTOPTS)
+		$(TESTPYTHON) $(TESTPROG) -uall $(TESTOPTS)
+		$(RUNSHARED) /usr/libexec/oah/translate ./$(BUILDPYTHON) -E -tt $(TESTPROG) -uall $(TESTOPTS)
+
+
+# Like testall, but with a single pass only
+# run an optional script to include some information about the build environment
+buildbottest:	all platform
+		-@if which pybuildbot.identify >/dev/null 2>&1; then \
+			pybuildbot.identify "CC='$(CC)'" "CXX='$(CXX)'"; \
+		fi
+		$(TESTPYTHON) -R $(TESTPROG) -uall -rwW $(TESTOPTS)
+
+QUICKTESTOPTS=	$(TESTOPTS) -x test_subprocess test_io test_lib2to3 \
+		test_multibytecodec test_urllib2_localnet test_itertools \
+		test_multiprocessing test_mailbox test_socket test_poll \
+		test_select test_zipfile
+quicktest:	all platform
+		-find $(srcdir)/Lib -name '*.py[co]' -print | xargs rm -f
+		-$(TESTPYTHON) $(TESTPROG) $(QUICKTESTOPTS)
+		$(TESTPYTHON) $(TESTPROG) $(QUICKTESTOPTS)
+
+MEMTESTOPTS=    $(QUICKTESTOPTS) -x test_dl test___all__ test_fork1 \
+		test_longexp
+memtest:	all platform
+		-rm -f $(srcdir)/Lib/test/*.py[co]
+		-$(TESTPYTHON) $(TESTPROG) $(MEMTESTOPTS)
+		$(TESTPYTHON) $(TESTPROG) $(MEMTESTOPTS)
+
+# Install everything
+install:	 altinstall bininstall maninstall 
+
+# Install almost everything without disturbing previous versions
+altinstall:	 altbininstall libinstall inclinstall \
+				libainstall altmaninstall \
+                sharedinstall oldsharedinstall 
+
+# Install shared libraries enabled by Setup
+DESTDIRS=	$(exec_prefix) $(LIBDIR) $(BINLIBDEST) $(DESTSHARED)
+
+oldsharedinstall: $(DESTSHARED) $(SHAREDMODS)
+		@for i in X $(SHAREDMODS); do \
+		  if test $$i != X; then \
+		    echo $(INSTALL_SHARED) $$i $(DESTSHARED)/`basename $$i`; \
+		    $(INSTALL_SHARED) $$i $(DESTDIR)$(DESTSHARED)/`basename $$i`; \
+		  fi; \
+		done
+
+$(DESTSHARED):
+		@for i in $(DESTDIRS); \
+		do \
+			if test ! -d $(DESTDIR)$$i; then \
+				echo "Creating directory $$i"; \
+				$(INSTALL) -d -m $(DIRMODE) $(DESTDIR)$$i; \
+			else    true; \
+			fi; \
+		done
+
+
+# Install the interpreter by creating a symlink chain:
+#  $(PYTHON) -> python2 -> python$(VERSION))
+# Also create equivalent chains for other installed files
+bininstall:	altbininstall
+	-if test -f $(DESTDIR)$(BINDIR)/$(PYTHON) -o -h $(DESTDIR)$(BINDIR)/$(PYTHON); \
+	then rm -f $(DESTDIR)$(BINDIR)/$(PYTHON); \
+	else true; \
+	fi
+	(cd $(DESTDIR)$(BINDIR); $(LN) -s python2$(EXE) $(PYTHON))
+	-rm -f $(DESTDIR)$(BINDIR)/python2$(EXE)
+	(cd $(DESTDIR)$(BINDIR); $(LN) -s python$(VERSION)$(EXE) python2$(EXE))
+	-rm -f $(DESTDIR)$(BINDIR)/python2-config
+	(cd $(DESTDIR)$(BINDIR); $(LN) -s python$(VERSION)-config python2-config)
+	-rm -f $(DESTDIR)$(BINDIR)/python-config
+	(cd $(DESTDIR)$(BINDIR); $(LN) -s python2-config python-config)
+	-test -d $(DESTDIR)$(LIBPC) || $(INSTALL) -d -m $(DIRMODE) $(DESTDIR)$(LIBPC)
+	-rm -f $(DESTDIR)$(LIBPC)/python2.pc
+	(cd $(DESTDIR)$(LIBPC); $(LN) -s python-$(VERSION).pc python2.pc)
+	-rm -f $(DESTDIR)$(LIBPC)/python.pc
+	(cd $(DESTDIR)$(LIBPC); $(LN) -s python2.pc python.pc)
+
+# Install the interpreter with $(VERSION) affixed
+# This goes into $(exec_prefix)
+altbininstall:	$(BUILDPYTHON)
+	@for i in $(BINDIR) $(LIBDIR); \
+	do \
+		if test ! -d $(DESTDIR)$$i; then \
+			echo "Creating directory $$i"; \
+			$(INSTALL) -d -m $(DIRMODE) $(DESTDIR)$$i; \
+		else	true; \
+		fi; \
+	done
+	$(INSTALL_PROGRAM) $(BUILDPYTHON) $(DESTDIR)$(BINDIR)/python$(VERSION)$(EXE)
+	if test -f $(LDLIBRARY); then \
+		if test -n "$(DLLLIBRARY)" ; then \
+			$(INSTALL_SHARED) $(DLLLIBRARY) $(DESTDIR)$(BINDIR); \
+		else \
+			$(INSTALL_SHARED) $(LDLIBRARY) $(DESTDIR)$(LIBDIR)/$(INSTSONAME); \
+			if test $(LDLIBRARY) != $(INSTSONAME); then \
+				(cd $(DESTDIR)$(LIBDIR); $(LN) -sf $(INSTSONAME) $(LDLIBRARY)) \
+			fi \
+		fi; \
+	else	true; \
+	fi
+
+# Install the versioned manual page
+altmaninstall:
+	@for i in $(MANDIR) $(MANDIR)/man1; \
+	do \
+		if test ! -d $(DESTDIR)$$i; then \
+			echo "Creating directory $$i"; \
+			$(INSTALL) -d -m $(DIRMODE) $(DESTDIR)$$i; \
+		else	true; \
+		fi; \
+	done
+	$(INSTALL_DATA) $(srcdir)/Misc/python.man \
+		$(DESTDIR)$(MANDIR)/man1/python$(VERSION).1
+
+# Install the unversioned manual pages
+maninstall:	altmaninstall
+	-rm -f $(DESTDIR)$(MANDIR)/man1/python2.1
+	(cd $(DESTDIR)$(MANDIR)/man1; $(LN) -s python$(VERSION).1 python2.1)
+	-rm -f $(DESTDIR)$(MANDIR)/man1/python.1
+	(cd $(DESTDIR)$(MANDIR)/man1; $(LN) -s python2.1 python.1)
+
+# Install the library
+PLATDIR=	plat-$(MULTIARCH)
+EXTRAPLATDIR= 
+EXTRAMACHDEPPATH=
+MACHDEPS=	$(PLATDIR) $(EXTRAPLATDIR)
+XMLLIBSUBDIRS=  xml xml/dom xml/etree xml/parsers xml/sax
+PLATMACDIRS= plat-mac plat-mac/Carbon plat-mac/lib-scriptpackages \
+	plat-mac/lib-scriptpackages/_builtinSuites \
+	plat-mac/lib-scriptpackages/CodeWarrior \
+	plat-mac/lib-scriptpackages/Explorer \
+	plat-mac/lib-scriptpackages/Finder \
+	plat-mac/lib-scriptpackages/Netscape \
+	plat-mac/lib-scriptpackages/StdSuites \
+	plat-mac/lib-scriptpackages/SystemEvents \
+	plat-mac/lib-scriptpackages/Terminal
+PLATMACPATH=:plat-mac:plat-mac/lib-scriptpackages
+LIBSUBDIRS=	lib-tk lib-tk/test lib-tk/test/test_tkinter \
+		lib-tk/test/test_ttk site-packages test test/audiodata test/data \
+		test/cjkencodings test/decimaltestdata test/xmltestdata \
+		test/imghdrdata \
+		test/subprocessdata \
+		test/tracedmodules \
+		encodings compiler hotshot \
+		email email/mime email/test email/test/data \
+		json json/tests \
+		sqlite3 sqlite3/test \
+		logging bsddb bsddb/test csv importlib wsgiref \
+		lib2to3 lib2to3/fixes lib2to3/pgen2 lib2to3/tests \
+		lib2to3/tests/data lib2to3/tests/data/fixers lib2to3/tests/data/fixers/myfixes \
+		ctypes ctypes/test ctypes/macholib \
+		idlelib idlelib/Icons idlelib/idle_test \
+		distutils distutils/command distutils/tests $(XMLLIBSUBDIRS) \
+		multiprocessing multiprocessing/dummy \
+		unittest unittest/test \
+		lib-old \
+		curses pydoc_data $(MACHDEPS)
+libinstall:	build_all $(srcdir)/Lib/$(PLATDIR) $(srcdir)/Modules/xxmodule.c
+	@for i in $(SCRIPTDIR) $(LIBDEST); \
+	do \
+		if test ! -d $(DESTDIR)$$i; then \
+			echo "Creating directory $$i"; \
+			$(INSTALL) -d -m $(DIRMODE) $(DESTDIR)$$i; \
+		else	true; \
+		fi; \
+	done
+	@for d in $(LIBSUBDIRS); \
+	do \
+		a=$(srcdir)/Lib/$$d; \
+		if test ! -d $$a; then continue; else true; fi; \
+		b=$(LIBDEST)/$$d; \
+		if test ! -d $(DESTDIR)$$b; then \
+			echo "Creating directory $$b"; \
+			$(INSTALL) -d -m $(DIRMODE) $(DESTDIR)$$b; \
+		else	true; \
+		fi; \
+	done
+	@for i in $(srcdir)/Lib/*.py `cat pybuilddir.txt`/_sysconfigdata.py $(srcdir)/Lib/*.doc $(srcdir)/Lib/*.egg-info ; \
+	do \
+		if test -x $$i; then \
+			$(INSTALL_SCRIPT) $$i $(DESTDIR)$(LIBDEST); \
+			echo $(INSTALL_SCRIPT) $$i $(LIBDEST); \
+		else \
+			$(INSTALL_DATA) $$i $(DESTDIR)$(LIBDEST); \
+			echo $(INSTALL_DATA) $$i $(LIBDEST); \
+		fi; \
+	done
+	@for d in $(LIBSUBDIRS); \
+	do \
+		a=$(srcdir)/Lib/$$d; \
+		if test ! -d $$a; then continue; else true; fi; \
+		if test `ls $$a | wc -l` -lt 1; then continue; fi; \
+		b=$(LIBDEST)/$$d; \
+		for i in $$a/*; \
+		do \
+			case $$i in \
+			*CVS) ;; \
+			*.py[co]) ;; \
+			*.orig) ;; \
+			*~) ;; \
+			*) \
+				if test -d $$i; then continue; fi; \
+				if test -x $$i; then \
+				    echo $(INSTALL_SCRIPT) $$i $$b; \
+				    $(INSTALL_SCRIPT) $$i $(DESTDIR)$$b; \
+				else \
+				    echo $(INSTALL_DATA) $$i $$b; \
+				    $(INSTALL_DATA) $$i $(DESTDIR)$$b; \
+				fi;; \
+			esac; \
+		done; \
+	done
+	$(INSTALL_DATA) $(srcdir)/LICENSE $(DESTDIR)$(LIBDEST)/LICENSE.txt
+	if test -d $(DESTDIR)$(LIBDEST)/distutils/tests; then \
+		$(INSTALL_DATA) $(srcdir)/Modules/xxmodule.c \
+			$(DESTDIR)$(LIBDEST)/distutils/tests ; \
+	fi
+	PYTHONPATH=$(DESTDIR)$(LIBDEST)  $(RUNSHARED) \
+		$(PYTHON_FOR_BUILD) -Wi -tt $(DESTDIR)$(LIBDEST)/compileall.py \
+		-d $(LIBDEST) -f \
+		-x 'bad_coding|badsyntax|site-packages|lib2to3/tests/data' \
+		$(DESTDIR)$(LIBDEST)
+	PYTHONPATH=$(DESTDIR)$(LIBDEST) $(RUNSHARED) \
+		$(PYTHON_FOR_BUILD) -Wi -tt -O $(DESTDIR)$(LIBDEST)/compileall.py \
+		-d $(LIBDEST) -f \
+		-x 'bad_coding|badsyntax|site-packages|lib2to3/tests/data' \
+		$(DESTDIR)$(LIBDEST)
+	-PYTHONPATH=$(DESTDIR)$(LIBDEST)  $(RUNSHARED) \
+		$(PYTHON_FOR_BUILD) -Wi -t $(DESTDIR)$(LIBDEST)/compileall.py \
+		-d $(LIBDEST)/site-packages -f \
+		-x badsyntax $(DESTDIR)$(LIBDEST)/site-packages
+	-PYTHONPATH=$(DESTDIR)$(LIBDEST) $(RUNSHARED) \
+		$(PYTHON_FOR_BUILD) -Wi -t -O $(DESTDIR)$(LIBDEST)/compileall.py \
+		-d $(LIBDEST)/site-packages -f \
+		-x badsyntax $(DESTDIR)$(LIBDEST)/site-packages
+	-PYTHONPATH=$(DESTDIR)$(LIBDEST) $(RUNSHARED) \
+		$(PYTHON_FOR_BUILD) -m lib2to3.pgen2.driver $(DESTDIR)$(LIBDEST)/lib2to3/Grammar.txt
+	-PYTHONPATH=$(DESTDIR)$(LIBDEST) $(RUNSHARED) \
+		$(PYTHON_FOR_BUILD) -m lib2to3.pgen2.driver $(DESTDIR)$(LIBDEST)/lib2to3/PatternGrammar.txt
+
+# Create the PLATDIR source directory, if one wasn't distributed..
+$(srcdir)/Lib/$(PLATDIR):
+	mkdir $(srcdir)/Lib/$(PLATDIR)
+	cp $(srcdir)/Lib/plat-generic/regen $(srcdir)/Lib/$(PLATDIR)/regen
+	export PATH; PATH="`pwd`:$$PATH"; \
+	export PYTHONPATH; PYTHONPATH="$(srcdir)/Lib:$(abs_builddir)/`cat pybuilddir.txt`"; \
+	export DYLD_FRAMEWORK_PATH; DYLD_FRAMEWORK_PATH="`pwd`"; \
+	export EXE; EXE="$(BUILDEXE)"; \
+	if [ -n "$(MULTIARCH)" ]; then export MULTIARCH; MULTIARCH=$(MULTIARCH); fi; \
+	export PYTHON_FOR_BUILD; \
+	if [ "$(build)" = "$(host)" ]; then \
+	  PYTHON_FOR_BUILD="$(BUILDPYTHON)"; \
+	else \
+	  PYTHON_FOR_BUILD="$(PYTHON_FOR_BUILD)"; \
+	fi; \
+	cd $(srcdir)/Lib/$(PLATDIR); $(RUNSHARED) ./regen
+
+python-config: $(srcdir)/Misc/python-config.in
+	# Substitution happens here, as the completely-expanded BINDIR
+	# is not available in configure
+	sed -e "s,@EXENAME@,$(BINDIR)/python$(VERSION)$(EXE)," < $(srcdir)/Misc/python-config.in >python-config
+	# Replace makefile compat. variable references with shell script compat. ones; $(VAR) -> ${VAR}
+	sed -e "s,\$$(\([A-Za-z0-9_]*\)),\$$\{\1\},g" < Misc/python-config.sh >python-config.sh
+
+# Install the include files
+INCLDIRSTOMAKE=$(INCLUDEDIR) $(CONFINCLUDEDIR) $(INCLUDEPY) $(CONFINCLUDEPY)
+inclinstall:
+	@for i in $(INCLDIRSTOMAKE); \
+	do \
+		if test ! -d $(DESTDIR)$$i; then \
+			echo "Creating directory $$i"; \
+			$(INSTALL) -d -m $(DIRMODE) $(DESTDIR)$$i; \
+		else	true; \
+		fi; \
+	done
+	@for i in $(srcdir)/Include/*.h; \
+	do \
+		echo $(INSTALL_DATA) $$i $(INCLUDEPY); \
+		$(INSTALL_DATA) $$i $(DESTDIR)$(INCLUDEPY); \
+	done
+	$(INSTALL_DATA) pyconfig.h $(DESTDIR)$(CONFINCLUDEPY)/pyconfig.h
+
+# Install the library and miscellaneous stuff needed for extending/embedding
+# This goes into $(exec_prefix)$(DEBUG_EXT)
+LIBPL=		$(LIBP)/config-$(MULTIARCH)$(DEBUG_EXT)
+
+# pkgconfig directory
+LIBPC=		$(LIBDIR)/$(MULTIARCH)/pkgconfig
+
+libainstall:	all python-config
+	@for i in $(LIBDIR) $(LIBP) $(LIBPL) $(LIBPC); \
+	do \
+		if test ! -d $(DESTDIR)$$i; then \
+			echo "Creating directory $$i"; \
+			$(INSTALL) -d -m $(DIRMODE) $(DESTDIR)$$i; \
+		else	true; \
+		fi; \
+	done
+	@if test -d $(LIBRARY); then :; else \
+		if test "$(PYTHONFRAMEWORKDIR)" = no-framework; then \
+			if test "$(SO)" = .dll; then \
+				$(INSTALL_DATA) $(LDLIBRARY) $(DESTDIR)$(LIBPL) ; \
+			else \
+				$(INSTALL_DATA) $(LIBRARY) $(DESTDIR)$(LIBPL)/$(LIBRARY) ; \
+				$(RANLIB) $(DESTDIR)$(LIBPL)/$(LIBRARY) ; \
+			fi; \
+		else \
+			echo Skip install of $(LIBRARY) - use make frameworkinstall; \
+		fi; \
+	fi
+	$(INSTALL_DATA) Modules/config.c $(DESTDIR)$(LIBPL)/config.c
+	$(INSTALL_DATA) Modules/python.o $(DESTDIR)$(LIBPL)/python.o
+	$(INSTALL_DATA) $(srcdir)/Modules/config.c.in $(DESTDIR)$(LIBPL)/config.c.in
+	$(INSTALL_DATA) Makefile $(DESTDIR)$(LIBPL)/Makefile
+	$(INSTALL_DATA) Modules/Setup $(DESTDIR)$(LIBPL)/Setup
+	$(INSTALL_DATA) Modules/Setup.local $(DESTDIR)$(LIBPL)/Setup.local
+	$(INSTALL_DATA) Modules/Setup.config $(DESTDIR)$(LIBPL)/Setup.config
+	$(INSTALL_DATA) Misc/python.pc $(DESTDIR)$(LIBPC)/python-$(VERSION).pc
+	$(INSTALL_SCRIPT) $(srcdir)/Modules/makesetup $(DESTDIR)$(LIBPL)/makesetup
+	$(INSTALL_SCRIPT) $(srcdir)/install-sh $(DESTDIR)$(LIBPL)/install-sh
+	$(INSTALL_SCRIPT) python-config $(DESTDIR)$(BINDIR)/python$(VERSION)-config
+	rm python-config
+	$(INSTALL_SCRIPT) python-config.sh $(DESTDIR)$(BINDIR)/python-config.sh
+	@if [ -s Modules/python.exp -a \
+		"`echo $(MACHDEP) | sed 's/^\(...\).*/\1/'`" = "aix" ]; then \
+		echo; echo "Installing support files for building shared extension modules on AIX:"; \
+		$(INSTALL_DATA) Modules/python.exp		\
+				$(DESTDIR)$(LIBPL)/python.exp;		\
+		echo; echo "$(LIBPL)/python.exp";		\
+		$(INSTALL_SCRIPT) $(srcdir)/Modules/makexp_aix	\
+				$(DESTDIR)$(LIBPL)/makexp_aix;		\
+		echo "$(LIBPL)/makexp_aix";			\
+		$(INSTALL_SCRIPT) $(srcdir)/Modules/ld_so_aix	\
+				$(DESTDIR)$(LIBPL)/ld_so_aix;		\
+		echo "$(LIBPL)/ld_so_aix";			\
+		echo; echo "See Misc/AIX-NOTES for details.";	\
+	else true; \
+	fi
+	@case "$(MACHDEP)" in beos*) \
+		echo; echo "Installing support files for building shared extension modules on BeOS:"; \
+		$(INSTALL_DATA) Misc/BeOS-NOTES $(DESTDIR)$(LIBPL)/README;	\
+		echo; echo "$(LIBPL)/README";			\
+		$(INSTALL_SCRIPT) Modules/ar_beos $(DESTDIR)$(LIBPL)/ar_beos; \
+		echo "$(LIBPL)/ar_beos";			\
+		$(INSTALL_SCRIPT) Modules/ld_so_beos $(DESTDIR)$(LIBPL)/ld_so_beos; \
+		echo "$(LIBPL)/ld_so_beos";			\
+		echo; echo "See Misc/BeOS-NOTES for details.";	\
+		;; \
+	esac
+
+# Install the dynamically loadable modules
+# This goes into $(exec_prefix)
+sharedinstall: sharedmods
+	$(RUNSHARED) $(PYTHON_FOR_BUILD) $(srcdir)/setup.py install \
+	   	--prefix=$(prefix) \
+		--install-scripts=$(BINDIR) \
+		--install-platlib=$(DESTSHARED) \
+		--root=$(DESTDIR)/
+	-rm $(DESTDIR)$(DESTSHARED)/_sysconfigdata.py*
+
+# Here are a couple of targets for MacOSX again, to install a full
+# framework-based Python. frameworkinstall installs everything, the
+# subtargets install specific parts. Much of the actual work is offloaded to
+# the Makefile in Mac
+#
+#
+# This target is here for backward compatiblity, previous versions of Python
+# hadn't integrated framework installation in the normal install process.
+frameworkinstall: install
+
+# On install, we re-make the framework
+# structure in the install location, /Library/Frameworks/ or the argument to
+# --enable-framework. If --enable-framework has been specified then we have
+# automatically set prefix to the location deep down in the framework, so we
+# only have to cater for the structural bits of the framework.
+
+frameworkinstallframework: frameworkinstallstructure install frameworkinstallmaclib
+
+frameworkinstallstructure:	$(LDLIBRARY)
+	@if test "$(PYTHONFRAMEWORKDIR)" = no-framework; then \
+		echo Not configured with --enable-framework; \
+		exit 1; \
+	else true; \
+	fi
+	@for i in $(prefix)/Resources/English.lproj $(prefix)/lib; do\
+		if test ! -d $(DESTDIR)$$i; then \
+			echo "Creating directory $(DESTDIR)$$i"; \
+			$(INSTALL) -d -m $(DIRMODE) $(DESTDIR)$$i; \
+		else	true; \
+		fi; \
+	done
+	$(LN) -fsn include/python$(VERSION) $(DESTDIR)$(prefix)/Headers
+	sed 's/%VERSION%/'"`$(RUNSHARED) ./$(BUILDPYTHON) -c 'import platform; print platform.python_version()'`"'/g' < $(RESSRCDIR)/Info.plist > $(DESTDIR)$(prefix)/Resources/Info.plist
+	$(LN) -fsn $(VERSION) $(DESTDIR)$(PYTHONFRAMEWORKINSTALLDIR)/Versions/Current
+	$(LN) -fsn Versions/Current/$(PYTHONFRAMEWORK) $(DESTDIR)$(PYTHONFRAMEWORKINSTALLDIR)/$(PYTHONFRAMEWORK)
+	$(LN) -fsn Versions/Current/Headers $(DESTDIR)$(PYTHONFRAMEWORKINSTALLDIR)/Headers
+	$(LN) -fsn Versions/Current/Resources $(DESTDIR)$(PYTHONFRAMEWORKINSTALLDIR)/Resources
+	$(INSTALL_SHARED) $(LDLIBRARY) $(DESTDIR)$(PYTHONFRAMEWORKPREFIX)/$(LDLIBRARY)
+
+# This installs Mac/Lib into the framework
+# Install a number of symlinks to keep software that expects a normal unix
+# install (which includes python-config) happy.
+frameworkinstallmaclib:
+	ln -fs "../../../$(PYTHONFRAMEWORK)" "$(DESTDIR)$(prefix)/lib/python$(VERSION)/config/libpython$(VERSION).a"
+	ln -fs "../../../$(PYTHONFRAMEWORK)" "$(DESTDIR)$(prefix)/lib/python$(VERSION)/config/libpython$(VERSION).dylib"
+	ln -fs "../$(PYTHONFRAMEWORK)" "$(DESTDIR)$(prefix)/lib/libpython$(VERSION).dylib"
+	cd Mac && $(MAKE) installmacsubtree DESTDIR="$(DESTDIR)"
+
+# This installs the IDE, the Launcher and other apps into /Applications
+frameworkinstallapps:
+	cd Mac && $(MAKE) installapps DESTDIR="$(DESTDIR)"
+
+# This install the unix python and pythonw tools in /usr/local/bin
+frameworkinstallunixtools:
+	cd Mac && $(MAKE) installunixtools DESTDIR="$(DESTDIR)"
+
+frameworkaltinstallunixtools:
+	cd Mac && $(MAKE) altinstallunixtools DESTDIR="$(DESTDIR)"
+
+# This installs the Demos and Tools into the applications directory.
+# It is not part of a normal frameworkinstall
+frameworkinstallextras:
+	cd Mac && $(MAKE) installextras DESTDIR="$(DESTDIR)"
+
+# This installs a few of the useful scripts in Tools/scripts
+scriptsinstall:
+	SRCDIR=$(srcdir) $(RUNSHARED) \
+	$(PYTHON_FOR_BUILD) $(srcdir)/Tools/scripts/setup.py install \
+	--prefix=$(prefix) \
+	--install-scripts=$(BINDIR) \
+	--root=$(DESTDIR)/
+
+# Build the toplevel Makefile
+Makefile.pre: Makefile.pre.in config.status
+	CONFIG_FILES=Makefile.pre CONFIG_HEADERS= $(SHELL) config.status
+	$(MAKE) -f Makefile.pre Makefile
+
+# Run the configure script.
+config.status:	$(srcdir)/configure
+	$(SHELL) $(srcdir)/configure $(CONFIG_ARGS)
+
+.PRECIOUS: config.status $(BUILDPYTHON) Makefile Makefile.pre
+
+# Some make's put the object file in the current directory
+.c.o:
+	$(CC) -c $(PY_CORE_CFLAGS) -o $@ $<
+
+# Run reindent on the library
+reindent:
+	./$(BUILDPYTHON) $(srcdir)/Tools/scripts/reindent.py -r $(srcdir)/Lib
+
+# Rerun configure with the same options as it was run last time,
+# provided the config.status script exists
+recheck:
+	$(SHELL) config.status --recheck
+	$(SHELL) config.status
+
+# Rebuild the configure script from configure.ac; also rebuild pyconfig.h.in
+autoconf:
+	(cd $(srcdir); autoconf)
+	(cd $(srcdir); autoheader)
+
+# Create a tags file for vi
+tags::
+	cd $(srcdir); \
+	ctags -w -t Include/*.h; \
+	for i in $(SRCDIRS); do ctags -w -t -a $$i/*.[ch]; \
+	done; \
+	sort -o tags tags
+
+# Create a tags file for GNU Emacs
+TAGS::
+	cd $(srcdir); \
+	etags Include/*.h; \
+	for i in $(SRCDIRS); do etags -a $$i/*.[ch]; done
+
+# Touch generated files
+touch:
+	touch Include/Python-ast.h Python/Python-ast.c
+
+# Sanitation targets -- clean leaves libraries, executables and tags
+# files, which clobber removes as well
+pycremoval:
+	find $(srcdir) -name '*.py[co]' -exec rm -f {} ';'
+
+clean: pycremoval
+	find . -name '*.[oa]' -exec rm -f {} ';'
+	find . -name '*.s[ol]' -exec rm -f {} ';'
+	find . -name '*.so.[0-9]*.[0-9]*' -exec rm -f {} ';'
+	find build -name 'fficonfig.h' -exec rm -f {} ';' || true
+	find build -name 'fficonfig.py' -exec rm -f {} ';' || true
+	-rm -f Lib/lib2to3/*Grammar*.pickle
+
+profile-removal:
+	find . -name '*.gc??' -exec rm -f {} ';'
+
+clobber: clean profile-removal
+	-rm -f $(BUILDPYTHON) $(PGEN) $(LIBRARY) $(LDLIBRARY) $(DLLLIBRARY) \
+		tags TAGS \
+		config.cache config.log pyconfig.h Modules/config.c
+	-rm -rf build platform
+	-rm -rf $(PYTHONFRAMEWORKDIR)
+
+# Make things extra clean, before making a distribution:
+# remove all generated files, even Makefile[.pre]
+# Keep configure and Python-ast.[ch], it's possible they can't be generated
+distclean: clobber
+	for file in Lib/test/data/* ; do \
+	    if test "$$file" != "Lib/test/data/README"; then rm "$$file"; fi; \
+	done
+	-rm -f core Makefile Makefile.pre config.status \
+		Modules/Setup Modules/Setup.local Modules/Setup.config \
+		Modules/ld_so_aix Modules/python.exp Misc/python.pc
+	-rm -f python*-gdb.py
+	-rm -f pybuilddir.txt
+	find $(srcdir)/[a-zA-Z]* '(' -name '*.fdc' -o -name '*~' \
+				     -o -name '[@,#]*' -o -name '*.old' \
+				     -o -name '*.orig' -o -name '*.rej' \
+				     -o -name '*.bak' ')' \
+				     -exec rm -f {} ';'
+
+# Check for smelly exported symbols (not starting with Py/_Py)
+smelly: all
+	nm -p $(LIBRARY) | \
+		sed -n "/ [TDB] /s/.* //p" | grep -v "^_*Py" | sort -u; \
+
+# Find files with funny names
+funny:
+	find $(SUBDIRS) $(SUBDIRSTOO) -type d \
+		-o -name '*.[chs]' \
+		-o -name '*.py' \
+		-o -name '*.doc' \
+		-o -name '*.sty' \
+		-o -name '*.bib' \
+		-o -name '*.dat' \
+		-o -name '*.el' \
+		-o -name '*.fd' \
+		-o -name '*.in' \
+		-o -name '*.tex' \
+		-o -name '*,[vpt]' \
+		-o -name 'Setup' \
+		-o -name 'Setup.*' \
+		-o -name README \
+		-o -name Makefile \
+		-o -name ChangeLog \
+		-o -name Repository \
+		-o -name Root \
+		-o -name Entries \
+		-o -name Tag \
+		-o -name tags \
+		-o -name TAGS \
+		-o -name .cvsignore \
+		-o -name MANIFEST \
+		-o -print
+
+# Perform some verification checks on any modified files.
+patchcheck:
+	$(RUNSHARED) ./$(BUILDPYTHON) $(srcdir)/Tools/scripts/patchcheck.py
+
+# Dependencies
+
+Python/thread.o:  $(srcdir)/Python/thread_atheos.h $(srcdir)/Python/thread_beos.h $(srcdir)/Python/thread_cthread.h $(srcdir)/Python/thread_foobar.h $(srcdir)/Python/thread_lwp.h $(srcdir)/Python/thread_nt.h $(srcdir)/Python/thread_os2.h $(srcdir)/Python/thread_pth.h $(srcdir)/Python/thread_pthread.h $(srcdir)/Python/thread_sgi.h $(srcdir)/Python/thread_solaris.h $(srcdir)/Python/thread_wince.h
+
+Python/sysmodule.o: $(srcdir)/Python/sysmodule.c Makefile
+	$(CC) -c $(PY_CORE_CFLAGS) \
+		-DMULTIARCH='"$(MULTIARCH)"' \
+		-o $@ $(srcdir)/Python/sysmodule.c
+
+# Declare targets that aren't real files
+.PHONY: all build_all sharedmods oldsharedmods test quicktest memtest
+.PHONY: install altinstall oldsharedinstall bininstall altbininstall
+.PHONY: maninstall libinstall inclinstall libainstall sharedinstall
+.PHONY: frameworkinstall frameworkinstallframework frameworkinstallstructure
+.PHONY: frameworkinstallmaclib frameworkinstallapps frameworkinstallunixtools
+.PHONY: frameworkaltinstallunixtools recheck autoconf clean clobber distclean
+.PHONY: smelly funny patchcheck touch altmaninstall
+.PHONY: gdbhooks
+
+# IF YOU PUT ANYTHING HERE IT WILL GO AWAY
+
+# Rules appended by makedepend
+
+Modules/threadmodule.o: $(srcdir)/Modules/threadmodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/threadmodule.c -o Modules/threadmodule.o
+Modules/threadmodule$(SO):  Modules/threadmodule.o; $(BLDSHARED)  Modules/threadmodule.o   -o Modules/threadmodule$(SO)
+Modules/signalmodule.o: $(srcdir)/Modules/signalmodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/signalmodule.c -o Modules/signalmodule.o
+Modules/signalmodule$(SO):  Modules/signalmodule.o; $(BLDSHARED)  Modules/signalmodule.o   -o Modules/signalmodule$(SO)
+Modules/arraymodule.o: $(srcdir)/Modules/arraymodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/arraymodule.c -o Modules/arraymodule.o
+Modules/arraymodule$(SO):  Modules/arraymodule.o; $(BLDSHARED)  Modules/arraymodule.o   -o Modules/arraymodule$(SO)
+Modules/cmathmodule.o: $(srcdir)/Modules/cmathmodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/cmathmodule.c -o Modules/cmathmodule.o
+Modules/cmathmodule$(SO):  Modules/cmathmodule.o; $(BLDSHARED)  Modules/cmathmodule.o   -o Modules/cmathmodule$(SO)
+Modules/mathmodule.o: $(srcdir)/Modules/mathmodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/mathmodule.c -o Modules/mathmodule.o
+Modules/_math.o: $(srcdir)/Modules/_math.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/_math.c -o Modules/_math.o
+Modules/math$(SO):  Modules/mathmodule.o Modules/_math.o; $(BLDSHARED)  Modules/mathmodule.o Modules/_math.o   -o Modules/math$(SO)
+Modules/_struct.o: $(srcdir)/Modules/_struct.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/_struct.c -o Modules/_struct.o
+Modules/_struct$(SO):  Modules/_struct.o; $(BLDSHARED)  Modules/_struct.o   -o Modules/_struct$(SO)
+Modules/timemodule.o: $(srcdir)/Modules/timemodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/timemodule.c -o Modules/timemodule.o
+Modules/timemodule$(SO):  Modules/timemodule.o; $(BLDSHARED)  Modules/timemodule.o   -o Modules/timemodule$(SO)
+Modules/operator.o: $(srcdir)/Modules/operator.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/operator.c -o Modules/operator.o
+Modules/operator$(SO):  Modules/operator.o; $(BLDSHARED)  Modules/operator.o   -o Modules/operator$(SO)
+Modules/_randommodule.o: $(srcdir)/Modules/_randommodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/_randommodule.c -o Modules/_randommodule.o
+Modules/_randommodule$(SO):  Modules/_randommodule.o; $(BLDSHARED)  Modules/_randommodule.o   -o Modules/_randommodule$(SO)
+Modules/_collectionsmodule.o: $(srcdir)/Modules/_collectionsmodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/_collectionsmodule.c -o Modules/_collectionsmodule.o
+Modules/_collectionsmodule$(SO):  Modules/_collectionsmodule.o; $(BLDSHARED)  Modules/_collectionsmodule.o   -o Modules/_collectionsmodule$(SO)
+Modules/_heapqmodule.o: $(srcdir)/Modules/_heapqmodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/_heapqmodule.c -o Modules/_heapqmodule.o
+Modules/_heapqmodule$(SO):  Modules/_heapqmodule.o; $(BLDSHARED)  Modules/_heapqmodule.o   -o Modules/_heapqmodule$(SO)
+Modules/itertoolsmodule.o: $(srcdir)/Modules/itertoolsmodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/itertoolsmodule.c -o Modules/itertoolsmodule.o
+Modules/itertoolsmodule$(SO):  Modules/itertoolsmodule.o; $(BLDSHARED)  Modules/itertoolsmodule.o   -o Modules/itertoolsmodule$(SO)
+Modules/stropmodule.o: $(srcdir)/Modules/stropmodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/stropmodule.c -o Modules/stropmodule.o
+Modules/stropmodule$(SO):  Modules/stropmodule.o; $(BLDSHARED)  Modules/stropmodule.o   -o Modules/stropmodule$(SO)
+Modules/_functoolsmodule.o: $(srcdir)/Modules/_functoolsmodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/_functoolsmodule.c -o Modules/_functoolsmodule.o
+Modules/_functoolsmodule$(SO):  Modules/_functoolsmodule.o; $(BLDSHARED)  Modules/_functoolsmodule.o   -o Modules/_functoolsmodule$(SO)
+Modules/_bisectmodule.o: $(srcdir)/Modules/_bisectmodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/_bisectmodule.c -o Modules/_bisectmodule.o
+Modules/_bisectmodule$(SO):  Modules/_bisectmodule.o; $(BLDSHARED)  Modules/_bisectmodule.o   -o Modules/_bisectmodule$(SO)
+Modules/unicodedata.o: $(srcdir)/Modules/unicodedata.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/unicodedata.c -o Modules/unicodedata.o
+Modules/unicodedata$(SO):  Modules/unicodedata.o; $(BLDSHARED)  Modules/unicodedata.o   -o Modules/unicodedata$(SO)
+Modules/_localemodule.o: $(srcdir)/Modules/_localemodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/_localemodule.c -o Modules/_localemodule.o
+Modules/_localemodule$(SO):  Modules/_localemodule.o; $(BLDSHARED)  Modules/_localemodule.o   -o Modules/_localemodule$(SO)
+Modules/bufferedio.o: $(srcdir)/Modules/_io/bufferedio.c; $(CC) $(PY_CORE_CFLAGS)  -I$(srcdir)/Modules/_io -c $(srcdir)/Modules/_io/bufferedio.c -o Modules/bufferedio.o
+Modules/bytesio.o: $(srcdir)/Modules/_io/bytesio.c; $(CC) $(PY_CORE_CFLAGS)  -I$(srcdir)/Modules/_io -c $(srcdir)/Modules/_io/bytesio.c -o Modules/bytesio.o
+Modules/fileio.o: $(srcdir)/Modules/_io/fileio.c; $(CC) $(PY_CORE_CFLAGS)  -I$(srcdir)/Modules/_io -c $(srcdir)/Modules/_io/fileio.c -o Modules/fileio.o
+Modules/iobase.o: $(srcdir)/Modules/_io/iobase.c; $(CC) $(PY_CORE_CFLAGS)  -I$(srcdir)/Modules/_io -c $(srcdir)/Modules/_io/iobase.c -o Modules/iobase.o
+Modules/_iomodule.o: $(srcdir)/Modules/_io/_iomodule.c; $(CC) $(PY_CORE_CFLAGS)  -I$(srcdir)/Modules/_io -c $(srcdir)/Modules/_io/_iomodule.c -o Modules/_iomodule.o
+Modules/stringio.o: $(srcdir)/Modules/_io/stringio.c; $(CC) $(PY_CORE_CFLAGS)  -I$(srcdir)/Modules/_io -c $(srcdir)/Modules/_io/stringio.c -o Modules/stringio.o
+Modules/textio.o: $(srcdir)/Modules/_io/textio.c; $(CC) $(PY_CORE_CFLAGS)  -I$(srcdir)/Modules/_io -c $(srcdir)/Modules/_io/textio.c -o Modules/textio.o
+Modules/_iomodule$(SO):  Modules/bufferedio.o Modules/bytesio.o Modules/fileio.o Modules/iobase.o Modules/_iomodule.o Modules/stringio.o Modules/textio.o; $(BLDSHARED)  Modules/bufferedio.o Modules/bytesio.o Modules/fileio.o Modules/iobase.o Modules/_iomodule.o Modules/stringio.o Modules/textio.o   -o Modules/_iomodule$(SO)
+Modules/fcntlmodule.o: $(srcdir)/Modules/fcntlmodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/fcntlmodule.c -o Modules/fcntlmodule.o
+Modules/fcntlmodule$(SO):  Modules/fcntlmodule.o; $(BLDSHARED)  Modules/fcntlmodule.o   -o Modules/fcntlmodule$(SO)
+Modules/spwdmodule.o: $(srcdir)/Modules/spwdmodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/spwdmodule.c -o Modules/spwdmodule.o
+Modules/spwdmodule$(SO):  Modules/spwdmodule.o; $(BLDSHARED)  Modules/spwdmodule.o   -o Modules/spwdmodule$(SO)
+Modules/grpmodule.o: $(srcdir)/Modules/grpmodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/grpmodule.c -o Modules/grpmodule.o
+Modules/grpmodule$(SO):  Modules/grpmodule.o; $(BLDSHARED)  Modules/grpmodule.o   -o Modules/grpmodule$(SO)
+Modules/selectmodule.o: $(srcdir)/Modules/selectmodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/selectmodule.c -o Modules/selectmodule.o
+Modules/selectmodule$(SO):  Modules/selectmodule.o; $(BLDSHARED)  Modules/selectmodule.o   -o Modules/selectmodule$(SO)
+Modules/socketmodule.o: $(srcdir)/Modules/socketmodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/socketmodule.c -o Modules/socketmodule.o
+Modules/timemodule.o: $(srcdir)/Modules/timemodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/timemodule.c -o Modules/timemodule.o
+Modules/_socketmodule$(SO):  Modules/socketmodule.o Modules/timemodule.o; $(BLDSHARED)  Modules/socketmodule.o Modules/timemodule.o   -o Modules/_socketmodule$(SO)
+Modules/md5module.o: $(srcdir)/Modules/md5module.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/md5module.c -o Modules/md5module.o
+Modules/md5.o: $(srcdir)/Modules/md5.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/md5.c -o Modules/md5.o
+Modules/_md5module$(SO):  Modules/md5module.o Modules/md5.o; $(BLDSHARED)  Modules/md5module.o Modules/md5.o   -o Modules/_md5module$(SO)
+Modules/shamodule.o: $(srcdir)/Modules/shamodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/shamodule.c -o Modules/shamodule.o
+Modules/_shamodule$(SO):  Modules/shamodule.o; $(BLDSHARED)  Modules/shamodule.o   -o Modules/_shamodule$(SO)
+Modules/sha256module.o: $(srcdir)/Modules/sha256module.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/sha256module.c -o Modules/sha256module.o
+Modules/_sha256module$(SO):  Modules/sha256module.o; $(BLDSHARED)  Modules/sha256module.o   -o Modules/_sha256module$(SO)
+Modules/sha512module.o: $(srcdir)/Modules/sha512module.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/sha512module.c -o Modules/sha512module.o
+Modules/_sha512module$(SO):  Modules/sha512module.o; $(BLDSHARED)  Modules/sha512module.o   -o Modules/_sha512module$(SO)
+Modules/syslogmodule.o: $(srcdir)/Modules/syslogmodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/syslogmodule.c -o Modules/syslogmodule.o
+Modules/syslogmodule$(SO):  Modules/syslogmodule.o; $(BLDSHARED)  Modules/syslogmodule.o   -o Modules/syslogmodule$(SO)
+Modules/binascii.o: $(srcdir)/Modules/binascii.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/binascii.c -o Modules/binascii.o
+Modules/binascii$(SO):  Modules/binascii.o; $(BLDSHARED)  Modules/binascii.o   -o Modules/binascii$(SO)
+Modules/cStringIO.o: $(srcdir)/Modules/cStringIO.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/cStringIO.c -o Modules/cStringIO.o
+Modules/cStringIO$(SO):  Modules/cStringIO.o; $(BLDSHARED)  Modules/cStringIO.o   -o Modules/cStringIO$(SO)
+Modules/cPickle.o: $(srcdir)/Modules/cPickle.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/cPickle.c -o Modules/cPickle.o
+Modules/cPickle$(SO):  Modules/cPickle.o; $(BLDSHARED)  Modules/cPickle.o   -o Modules/cPickle$(SO)
+Modules/zlibmodule.o: $(srcdir)/Modules/zlibmodule.c; $(CC) $(PY_CORE_CFLAGS)  -I$(prefix)/include -c $(srcdir)/Modules/zlibmodule.c -o Modules/zlibmodule.o
+Modules/zlibmodule$(SO):  Modules/zlibmodule.o; $(BLDSHARED)  Modules/zlibmodule.o  -L$(exec_prefix)/lib -lz  -o Modules/zlibmodule$(SO)
+Modules/posixmodule.o: $(srcdir)/Modules/posixmodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/posixmodule.c -o Modules/posixmodule.o
+Modules/posixmodule$(SO):  Modules/posixmodule.o; $(BLDSHARED)  Modules/posixmodule.o   -o Modules/posixmodule$(SO)
+Modules/errnomodule.o: $(srcdir)/Modules/errnomodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/errnomodule.c -o Modules/errnomodule.o
+Modules/errnomodule$(SO):  Modules/errnomodule.o; $(BLDSHARED)  Modules/errnomodule.o   -o Modules/errnomodule$(SO)
+Modules/pwdmodule.o: $(srcdir)/Modules/pwdmodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/pwdmodule.c -o Modules/pwdmodule.o
+Modules/pwdmodule$(SO):  Modules/pwdmodule.o; $(BLDSHARED)  Modules/pwdmodule.o   -o Modules/pwdmodule$(SO)
+Modules/_sre.o: $(srcdir)/Modules/_sre.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/_sre.c -o Modules/_sre.o
+Modules/_sre$(SO):  Modules/_sre.o; $(BLDSHARED)  Modules/_sre.o   -o Modules/_sre$(SO)
+Modules/_codecsmodule.o: $(srcdir)/Modules/_codecsmodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/_codecsmodule.c -o Modules/_codecsmodule.o
+Modules/_codecsmodule$(SO):  Modules/_codecsmodule.o; $(BLDSHARED)  Modules/_codecsmodule.o   -o Modules/_codecsmodule$(SO)
+Modules/_weakref.o: $(srcdir)/Modules/_weakref.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/_weakref.c -o Modules/_weakref.o
+Modules/_weakref$(SO):  Modules/_weakref.o; $(BLDSHARED)  Modules/_weakref.o   -o Modules/_weakref$(SO)
+Modules/zipimport.o: $(srcdir)/Modules/zipimport.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/zipimport.c -o Modules/zipimport.o
+Modules/zipimport$(SO):  Modules/zipimport.o; $(BLDSHARED)  Modules/zipimport.o   -o Modules/zipimport$(SO)
+Modules/symtablemodule.o: $(srcdir)/Modules/symtablemodule.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/symtablemodule.c -o Modules/symtablemodule.o
+Modules/_symtablemodule$(SO):  Modules/symtablemodule.o; $(BLDSHARED)  Modules/symtablemodule.o   -o Modules/_symtablemodule$(SO)
+Modules/xxsubtype.o: $(srcdir)/Modules/xxsubtype.c; $(CC) $(PY_CORE_CFLAGS)  -c $(srcdir)/Modules/xxsubtype.c -o Modules/xxsubtype.o
+Modules/xxsubtype$(SO):  Modules/xxsubtype.o; $(BLDSHARED)  Modules/xxsubtype.o   -o Modules/xxsubtype$(SO)

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/__init__.py

@@ -0,0 +1 @@
+#empty

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/__main__.py

@@ -0,0 +1,4 @@
+import sys
+from .main import main
+
+sys.exit(main("lib2to3.fixes"))

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/btm_matcher.py

@@ -0,0 +1,168 @@
+"""A bottom-up tree matching algorithm implementation meant to speed
+up 2to3's matching process. After the tree patterns are reduced to
+their rarest linear path, a linear Aho-Corasick automaton is
+created. The linear automaton traverses the linear paths from the
+leaves to the root of the AST and returns a set of nodes for further
+matching. This reduces significantly the number of candidate nodes."""
+
+__author__ = "George Boutsioukis <gboutsioukis@gmail.com>"
+
+import logging
+import itertools
+from collections import defaultdict
+
+from . import pytree
+from .btm_utils import reduce_tree
+
+class BMNode(object):
+    """Class for a node of the Aho-Corasick automaton used in matching"""
+    count = itertools.count()
+    def __init__(self):
+        self.transition_table = {}
+        self.fixers = []
+        self.id = next(BMNode.count)
+        self.content = ''
+
+class BottomMatcher(object):
+    """The main matcher class. After instantiating the patterns should
+    be added using the add_fixer method"""
+
+    def __init__(self):
+        self.match = set()
+        self.root = BMNode()
+        self.nodes = [self.root]
+        self.fixers = []
+        self.logger = logging.getLogger("RefactoringTool")
+
+    def add_fixer(self, fixer):
+        """Reduces a fixer's pattern tree to a linear path and adds it
+        to the matcher(a common Aho-Corasick automaton). The fixer is
+        appended on the matching states and called when they are
+        reached"""
+        self.fixers.append(fixer)
+        tree = reduce_tree(fixer.pattern_tree)
+        linear = tree.get_linear_subpattern()
+        match_nodes = self.add(linear, start=self.root)
+        for match_node in match_nodes:
+            match_node.fixers.append(fixer)
+
+    def add(self, pattern, start):
+        "Recursively adds a linear pattern to the AC automaton"
+        #print("adding pattern", pattern, "to", start)
+        if not pattern:
+            #print("empty pattern")
+            return [start]
+        if isinstance(pattern[0], tuple):
+            #alternatives
+            #print("alternatives")
+            match_nodes = []
+            for alternative in pattern[0]:
+                #add all alternatives, and add the rest of the pattern
+                #to each end node
+                end_nodes = self.add(alternative, start=start)
+                for end in end_nodes:
+                    match_nodes.extend(self.add(pattern[1:], end))
+            return match_nodes
+        else:
+            #single token
+            #not last
+            if pattern[0] not in start.transition_table:
+                #transition did not exist, create new
+                next_node = BMNode()
+                start.transition_table[pattern[0]] = next_node
+            else:
+                #transition exists already, follow
+                next_node = start.transition_table[pattern[0]]
+
+            if pattern[1:]:
+                end_nodes = self.add(pattern[1:], start=next_node)
+            else:
+                end_nodes = [next_node]
+            return end_nodes
+
+    def run(self, leaves):
+        """The main interface with the bottom matcher. The tree is
+        traversed from the bottom using the constructed
+        automaton. Nodes are only checked once as the tree is
+        retraversed. When the automaton fails, we give it one more
+        shot(in case the above tree matches as a whole with the
+        rejected leaf), then we break for the next leaf. There is the
+        special case of multiple arguments(see code comments) where we
+        recheck the nodes
+
+        Args:
+           The leaves of the AST tree to be matched
+
+        Returns:
+           A dictionary of node matches with fixers as the keys
+        """
+        current_ac_node = self.root
+        results = defaultdict(list)
+        for leaf in leaves:
+            current_ast_node = leaf
+            while current_ast_node:
+                current_ast_node.was_checked = True
+                for child in current_ast_node.children:
+                    # multiple statements, recheck
+                    if isinstance(child, pytree.Leaf) and child.value == u";":
+                        current_ast_node.was_checked = False
+                        break
+                if current_ast_node.type == 1:
+                    #name
+                    node_token = current_ast_node.value
+                else:
+                    node_token = current_ast_node.type
+
+                if node_token in current_ac_node.transition_table:
+                    #token matches
+                    current_ac_node = current_ac_node.transition_table[node_token]
+                    for fixer in current_ac_node.fixers:
+                        if not fixer in results:
+                            results[fixer] = []
+                        results[fixer].append(current_ast_node)
+
+                else:
+                    #matching failed, reset automaton
+                    current_ac_node = self.root
+                    if (current_ast_node.parent is not None
+                        and current_ast_node.parent.was_checked):
+                        #the rest of the tree upwards has been checked, next leaf
+                        break
+
+                    #recheck the rejected node once from the root
+                    if node_token in current_ac_node.transition_table:
+                        #token matches
+                        current_ac_node = current_ac_node.transition_table[node_token]
+                        for fixer in current_ac_node.fixers:
+                            if not fixer in results.keys():
+                                results[fixer] = []
+                            results[fixer].append(current_ast_node)
+
+                current_ast_node = current_ast_node.parent
+        return results
+
+    def print_ac(self):
+        "Prints a graphviz diagram of the BM automaton(for debugging)"
+        print("digraph g{")
+        def print_node(node):
+            for subnode_key in node.transition_table.keys():
+                subnode = node.transition_table[subnode_key]
+                print("%d -> %d [label=%s] //%s" %
+                      (node.id, subnode.id, type_repr(subnode_key), str(subnode.fixers)))
+                if subnode_key == 1:
+                    print(subnode.content)
+                print_node(subnode)
+        print_node(self.root)
+        print("}")
+
+# taken from pytree.py for debugging; only used by print_ac
+_type_reprs = {}
+def type_repr(type_num):
+    global _type_reprs
+    if not _type_reprs:
+        from .pygram import python_symbols
+        # printing tokens is possible but not as useful
+        # from .pgen2 import token // token.__dict__.items():
+        for name, val in python_symbols.__dict__.items():
+            if type(val) == int: _type_reprs[val] = name
+    return _type_reprs.setdefault(type_num, type_num)

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/btm_utils.py

@@ -0,0 +1,283 @@
+"Utility functions used by the btm_matcher module"
+
+from . import pytree
+from .pgen2 import grammar, token
+from .pygram import pattern_symbols, python_symbols
+
+syms = pattern_symbols
+pysyms = python_symbols
+tokens = grammar.opmap
+token_labels = token
+
+TYPE_ANY = -1
+TYPE_ALTERNATIVES = -2
+TYPE_GROUP = -3
+
+class MinNode(object):
+    """This class serves as an intermediate representation of the
+    pattern tree during the conversion to sets of leaf-to-root
+    subpatterns"""
+
+    def __init__(self, type=None, name=None):
+        self.type = type
+        self.name = name
+        self.children = []
+        self.leaf = False
+        self.parent = None
+        self.alternatives = []
+        self.group = []
+
+    def __repr__(self):
+        return str(self.type) + ' ' + str(self.name)
+
+    def leaf_to_root(self):
+        """Internal method. Returns a characteristic path of the
+        pattern tree. This method must be run for all leaves until the
+        linear subpatterns are merged into a single"""
+        node = self
+        subp = []
+        while node:
+            if node.type == TYPE_ALTERNATIVES:
+                node.alternatives.append(subp)
+                if len(node.alternatives) == len(node.children):
+                    #last alternative
+                    subp = [tuple(node.alternatives)]
+                    node.alternatives = []
+                    node = node.parent
+                    continue
+                else:
+                    node = node.parent
+                    subp = None
+                    break
+
+            if node.type == TYPE_GROUP:
+                node.group.append(subp)
+                #probably should check the number of leaves
+                if len(node.group) == len(node.children):
+                    subp = get_characteristic_subpattern(node.group)
+                    node.group = []
+                    node = node.parent
+                    continue
+                else:
+                    node = node.parent
+                    subp = None
+                    break
+
+            if node.type == token_labels.NAME and node.name:
+                #in case of type=name, use the name instead
+                subp.append(node.name)
+            else:
+                subp.append(node.type)
+
+            node = node.parent
+        return subp
+
+    def get_linear_subpattern(self):
+        """Drives the leaf_to_root method. The reason that
+        leaf_to_root must be run multiple times is because we need to
+        reject 'group' matches; for example the alternative form
+        (a | b c) creates a group [b c] that needs to be matched. Since
+        matching multiple linear patterns overcomes the automaton's
+        capabilities, leaf_to_root merges each group into a single
+        choice based on 'characteristic'ity,
+
+        i.e. (a|b c) -> (a|b) if b more characteristic than c
+
+        Returns: The most 'characteristic'(as defined by
+          get_characteristic_subpattern) path for the compiled pattern
+          tree.
+        """
+
+        for l in self.leaves():
+            subp = l.leaf_to_root()
+            if subp:
+                return subp
+
+    def leaves(self):
+        "Generator that returns the leaves of the tree"
+        for child in self.children:
+            for x in child.leaves():
+                yield x
+        if not self.children:
+            yield self
+
+def reduce_tree(node, parent=None):
+    """
+    Internal function. Reduces a compiled pattern tree to an
+    intermediate representation suitable for feeding the
+    automaton. This also trims off any optional pattern elements(like
+    [a], a*).
+    """
+
+    new_node = None
+    #switch on the node type
+    if node.type == syms.Matcher:
+        #skip
+        node = node.children[0]
+
+    if node.type == syms.Alternatives  :
+        #2 cases
+        if len(node.children) <= 2:
+            #just a single 'Alternative', skip this node
+            new_node = reduce_tree(node.children[0], parent)
+        else:
+            #real alternatives
+            new_node = MinNode(type=TYPE_ALTERNATIVES)
+            #skip odd children('|' tokens)
+            for child in node.children:
+                if node.children.index(child)%2:
+                    continue
+                reduced = reduce_tree(child, new_node)
+                if reduced is not None:
+                    new_node.children.append(reduced)
+    elif node.type == syms.Alternative:
+        if len(node.children) > 1:
+
+            new_node = MinNode(type=TYPE_GROUP)
+            for child in node.children:
+                reduced = reduce_tree(child, new_node)
+                if reduced:
+                    new_node.children.append(reduced)
+            if not new_node.children:
+                # delete the group if all of the children were reduced to None
+                new_node = None
+
+        else:
+            new_node = reduce_tree(node.children[0], parent)
+
+    elif node.type == syms.Unit:
+        if (isinstance(node.children[0], pytree.Leaf) and
+            node.children[0].value == '('):
+            #skip parentheses
+            return reduce_tree(node.children[1], parent)
+        if ((isinstance(node.children[0], pytree.Leaf) and
+               node.children[0].value == '[')
+               or
+               (len(node.children)>1 and
+               hasattr(node.children[1], "value") and
+               node.children[1].value == '[')):
+            #skip whole unit if its optional
+            return None
+
+        leaf = True
+        details_node = None
+        alternatives_node = None
+        has_repeater = False
+        repeater_node = None
+        has_variable_name = False
+
+        for child in node.children:
+            if child.type == syms.Details:
+                leaf = False
+                details_node = child
+            elif child.type == syms.Repeater:
+                has_repeater = True
+                repeater_node = child
+            elif child.type == syms.Alternatives:
+                alternatives_node = child
+            if hasattr(child, 'value') and child.value == '=': # variable name
+                has_variable_name = True
+
+        #skip variable name
+        if has_variable_name:
+            #skip variable name, '='
+            name_leaf = node.children[2]
+            if hasattr(name_leaf, 'value') and name_leaf.value == '(':
+                # skip parenthesis
+                name_leaf = node.children[3]
+        else:
+            name_leaf = node.children[0]
+
+        #set node type
+        if name_leaf.type == token_labels.NAME:
+            #(python) non-name or wildcard
+            if name_leaf.value == 'any':
+                new_node = MinNode(type=TYPE_ANY)
+            else:
+                if hasattr(token_labels, name_leaf.value):
+                    new_node = MinNode(type=getattr(token_labels, name_leaf.value))
+                else:
+                    new_node = MinNode(type=getattr(pysyms, name_leaf.value))
+
+        elif name_leaf.type == token_labels.STRING:
+            #(python) name or character; remove the apostrophes from
+            #the string value
+            name = name_leaf.value.strip("'")
+            if name in tokens:
+                new_node = MinNode(type=tokens[name])
+            else:
+                new_node = MinNode(type=token_labels.NAME, name=name)
+        elif name_leaf.type == syms.Alternatives:
+            new_node = reduce_tree(alternatives_node, parent)
+
+        #handle repeaters
+        if has_repeater:
+            if repeater_node.children[0].value == '*':
+                #reduce to None
+                new_node = None
+            elif repeater_node.children[0].value == '+':
+                #reduce to a single occurence i.e. do nothing
+                pass
+            else:
+                #TODO: handle {min, max} repeaters
+                raise NotImplementedError
+                pass
+
+        #add children
+        if details_node and new_node is not None:
+            for child in details_node.children[1:-1]:
+                #skip '<', '>' markers
+                reduced = reduce_tree(child, new_node)
+                if reduced is not None:
+                    new_node.children.append(reduced)
+    if new_node:
+        new_node.parent = parent
+    return new_node
+
+
+def get_characteristic_subpattern(subpatterns):
+    """Picks the most characteristic from a list of linear patterns
+    Current order used is:
+    names > common_names > common_chars
+    """
+    if not isinstance(subpatterns, list):
+        return subpatterns
+    if len(subpatterns)==1:
+        return subpatterns[0]
+
+    # first pick out the ones containing variable names
+    subpatterns_with_names = []
+    subpatterns_with_common_names = []
+    common_names = ['in', 'for', 'if' , 'not', 'None']
+    subpatterns_with_common_chars = []
+    common_chars = "[]().,:"
+    for subpattern in subpatterns:
+        if any(rec_test(subpattern, lambda x: type(x) is str)):
+            if any(rec_test(subpattern,
+                            lambda x: isinstance(x, str) and x in common_chars)):
+                subpatterns_with_common_chars.append(subpattern)
+            elif any(rec_test(subpattern,
+                              lambda x: isinstance(x, str) and x in common_names)):
+                subpatterns_with_common_names.append(subpattern)
+
+            else:
+                subpatterns_with_names.append(subpattern)
+
+    if subpatterns_with_names:
+        subpatterns = subpatterns_with_names
+    elif subpatterns_with_common_names:
+        subpatterns = subpatterns_with_common_names
+    elif subpatterns_with_common_chars:
+        subpatterns = subpatterns_with_common_chars
+    # of the remaining subpatterns pick out the longest one
+    return max(subpatterns, key=len)
+
+def rec_test(sequence, test_func):
+    """Tests test_func on all items of sequence and items of included
+    sub-iterables"""
+    for x in sequence:
+        if isinstance(x, (list, tuple)):
+            for y in rec_test(x, test_func):
+                yield y
+        else:
+            yield test_func(x)

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixer_base.py

@@ -0,0 +1,189 @@
+# Copyright 2006 Google, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Base class for fixers (optional, but recommended)."""
+
+# Python imports
+import logging
+import itertools
+
+# Local imports
+from .patcomp import PatternCompiler
+from . import pygram
+from .fixer_util import does_tree_import
+
+class BaseFix(object):
+
+    """Optional base class for fixers.
+
+    The subclass name must be FixFooBar where FooBar is the result of
+    removing underscores and capitalizing the words of the fix name.
+    For example, the class name for a fixer named 'has_key' should be
+    FixHasKey.
+    """
+
+    PATTERN = None  # Most subclasses should override with a string literal
+    pattern = None  # Compiled pattern, set by compile_pattern()
+    pattern_tree = None # Tree representation of the pattern
+    options = None  # Options object passed to initializer
+    filename = None # The filename (set by set_filename)
+    logger = None   # A logger (set by set_filename)
+    numbers = itertools.count(1) # For new_name()
+    used_names = set() # A set of all used NAMEs
+    order = "post" # Does the fixer prefer pre- or post-order traversal
+    explicit = False # Is this ignored by refactor.py -f all?
+    run_order = 5   # Fixers will be sorted by run order before execution
+                    # Lower numbers will be run first.
+    _accept_type = None # [Advanced and not public] This tells RefactoringTool
+                        # which node type to accept when there's not a pattern.
+
+    keep_line_order = False # For the bottom matcher: match with the
+                            # original line order
+    BM_compatible = False # Compatibility with the bottom matching
+                          # module; every fixer should set this
+                          # manually
+
+    # Shortcut for access to Python grammar symbols
+    syms = pygram.python_symbols
+
+    def __init__(self, options, log):
+        """Initializer.  Subclass may override.
+
+        Args:
+            options: an dict containing the options passed to RefactoringTool
+            that could be used to customize the fixer through the command line.
+            log: a list to append warnings and other messages to.
+        """
+        self.options = options
+        self.log = log
+        self.compile_pattern()
+
+    def compile_pattern(self):
+        """Compiles self.PATTERN into self.pattern.
+
+        Subclass may override if it doesn't want to use
+        self.{pattern,PATTERN} in .match().
+        """
+        if self.PATTERN is not None:
+            PC = PatternCompiler()
+            self.pattern, self.pattern_tree = PC.compile_pattern(self.PATTERN,
+                                                                 with_tree=True)
+
+    def set_filename(self, filename):
+        """Set the filename, and a logger derived from it.
+
+        The main refactoring tool should call this.
+        """
+        self.filename = filename
+        self.logger = logging.getLogger(filename)
+
+    def match(self, node):
+        """Returns match for a given parse tree node.
+
+        Should return a true or false object (not necessarily a bool).
+        It may return a non-empty dict of matching sub-nodes as
+        returned by a matching pattern.
+
+        Subclass may override.
+        """
+        results = {"node": node}
+        return self.pattern.match(node, results) and results
+
+    def transform(self, node, results):
+        """Returns the transformation for a given parse tree node.
+
+        Args:
+          node: the root of the parse tree that matched the fixer.
+          results: a dict mapping symbolic names to part of the match.
+
+        Returns:
+          None, or a node that is a modified copy of the
+          argument node.  The node argument may also be modified in-place to
+          effect the same change.
+
+        Subclass *must* override.
+        """
+        raise NotImplementedError()
+
+    def new_name(self, template=u"xxx_todo_changeme"):
+        """Return a string suitable for use as an identifier
+
+        The new name is guaranteed not to conflict with other identifiers.
+        """
+        name = template
+        while name in self.used_names:
+            name = template + unicode(self.numbers.next())
+        self.used_names.add(name)
+        return name
+
+    def log_message(self, message):
+        if self.first_log:
+            self.first_log = False
+            self.log.append("### In file %s ###" % self.filename)
+        self.log.append(message)
+
+    def cannot_convert(self, node, reason=None):
+        """Warn the user that a given chunk of code is not valid Python 3,
+        but that it cannot be converted automatically.
+
+        First argument is the top-level node for the code in question.
+        Optional second argument is why it can't be converted.
+        """
+        lineno = node.get_lineno()
+        for_output = node.clone()
+        for_output.prefix = u""
+        msg = "Line %d: could not convert: %s"
+        self.log_message(msg % (lineno, for_output))
+        if reason:
+            self.log_message(reason)
+
+    def warning(self, node, reason):
+        """Used for warning the user about possible uncertainty in the
+        translation.
+
+        First argument is the top-level node for the code in question.
+        Optional second argument is why it can't be converted.
+        """
+        lineno = node.get_lineno()
+        self.log_message("Line %d: %s" % (lineno, reason))
+
+    def start_tree(self, tree, filename):
+        """Some fixers need to maintain tree-wide state.
+        This method is called once, at the start of tree fix-up.
+
+        tree - the root node of the tree to be processed.
+        filename - the name of the file the tree came from.
+        """
+        self.used_names = tree.used_names
+        self.set_filename(filename)
+        self.numbers = itertools.count(1)
+        self.first_log = True
+
+    def finish_tree(self, tree, filename):
+        """Some fixers need to maintain tree-wide state.
+        This method is called once, at the conclusion of tree fix-up.
+
+        tree - the root node of the tree to be processed.
+        filename - the name of the file the tree came from.
+        """
+        pass
+
+
+class ConditionalFix(BaseFix):
+    """ Base class for fixers which not execute if an import is found. """
+
+    # This is the name of the import which, if found, will cause the test to be skipped
+    skip_on = None
+
+    def start_tree(self, *args):
+        super(ConditionalFix, self).start_tree(*args)
+        self._should_skip = None
+
+    def should_skip(self, node):
+        if self._should_skip is not None:
+            return self._should_skip
+        pkg = self.skip_on.split(".")
+        name = pkg[-1]
+        pkg = ".".join(pkg[:-1])
+        self._should_skip = does_tree_import(pkg, name, node)
+        return self._should_skip

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixer_util.py

@@ -0,0 +1,432 @@
+"""Utility functions, node construction macros, etc."""
+# Author: Collin Winter
+
+from itertools import islice
+
+# Local imports
+from .pgen2 import token
+from .pytree import Leaf, Node
+from .pygram import python_symbols as syms
+from . import patcomp
+
+
+###########################################################
+### Common node-construction "macros"
+###########################################################
+
+def KeywordArg(keyword, value):
+    return Node(syms.argument,
+                [keyword, Leaf(token.EQUAL, u"="), value])
+
+def LParen():
+    return Leaf(token.LPAR, u"(")
+
+def RParen():
+    return Leaf(token.RPAR, u")")
+
+def Assign(target, source):
+    """Build an assignment statement"""
+    if not isinstance(target, list):
+        target = [target]
+    if not isinstance(source, list):
+        source.prefix = u" "
+        source = [source]
+
+    return Node(syms.atom,
+                target + [Leaf(token.EQUAL, u"=", prefix=u" ")] + source)
+
+def Name(name, prefix=None):
+    """Return a NAME leaf"""
+    return Leaf(token.NAME, name, prefix=prefix)
+
+def Attr(obj, attr):
+    """A node tuple for obj.attr"""
+    return [obj, Node(syms.trailer, [Dot(), attr])]
+
+def Comma():
+    """A comma leaf"""
+    return Leaf(token.COMMA, u",")
+
+def Dot():
+    """A period (.) leaf"""
+    return Leaf(token.DOT, u".")
+
+def ArgList(args, lparen=LParen(), rparen=RParen()):
+    """A parenthesised argument list, used by Call()"""
+    node = Node(syms.trailer, [lparen.clone(), rparen.clone()])
+    if args:
+        node.insert_child(1, Node(syms.arglist, args))
+    return node
+
+def Call(func_name, args=None, prefix=None):
+    """A function call"""
+    node = Node(syms.power, [func_name, ArgList(args)])
+    if prefix is not None:
+        node.prefix = prefix
+    return node
+
+def Newline():
+    """A newline literal"""
+    return Leaf(token.NEWLINE, u"\n")
+
+def BlankLine():
+    """A blank line"""
+    return Leaf(token.NEWLINE, u"")
+
+def Number(n, prefix=None):
+    return Leaf(token.NUMBER, n, prefix=prefix)
+
+def Subscript(index_node):
+    """A numeric or string subscript"""
+    return Node(syms.trailer, [Leaf(token.LBRACE, u"["),
+                               index_node,
+                               Leaf(token.RBRACE, u"]")])
+
+def String(string, prefix=None):
+    """A string leaf"""
+    return Leaf(token.STRING, string, prefix=prefix)
+
+def ListComp(xp, fp, it, test=None):
+    """A list comprehension of the form [xp for fp in it if test].
+
+    If test is None, the "if test" part is omitted.
+    """
+    xp.prefix = u""
+    fp.prefix = u" "
+    it.prefix = u" "
+    for_leaf = Leaf(token.NAME, u"for")
+    for_leaf.prefix = u" "
+    in_leaf = Leaf(token.NAME, u"in")
+    in_leaf.prefix = u" "
+    inner_args = [for_leaf, fp, in_leaf, it]
+    if test:
+        test.prefix = u" "
+        if_leaf = Leaf(token.NAME, u"if")
+        if_leaf.prefix = u" "
+        inner_args.append(Node(syms.comp_if, [if_leaf, test]))
+    inner = Node(syms.listmaker, [xp, Node(syms.comp_for, inner_args)])
+    return Node(syms.atom,
+                       [Leaf(token.LBRACE, u"["),
+                        inner,
+                        Leaf(token.RBRACE, u"]")])
+
+def FromImport(package_name, name_leafs):
+    """ Return an import statement in the form:
+        from package import name_leafs"""
+    # XXX: May not handle dotted imports properly (eg, package_name='foo.bar')
+    #assert package_name == '.' or '.' not in package_name, "FromImport has "\
+    #       "not been tested with dotted package names -- use at your own "\
+    #       "peril!"
+
+    for leaf in name_leafs:
+        # Pull the leaves out of their old tree
+        leaf.remove()
+
+    children = [Leaf(token.NAME, u"from"),
+                Leaf(token.NAME, package_name, prefix=u" "),
+                Leaf(token.NAME, u"import", prefix=u" "),
+                Node(syms.import_as_names, name_leafs)]
+    imp = Node(syms.import_from, children)
+    return imp
+
+
+###########################################################
+### Determine whether a node represents a given literal
+###########################################################
+
+def is_tuple(node):
+    """Does the node represent a tuple literal?"""
+    if isinstance(node, Node) and node.children == [LParen(), RParen()]:
+        return True
+    return (isinstance(node, Node)
+            and len(node.children) == 3
+            and isinstance(node.children[0], Leaf)
+            and isinstance(node.children[1], Node)
+            and isinstance(node.children[2], Leaf)
+            and node.children[0].value == u"("
+            and node.children[2].value == u")")
+
+def is_list(node):
+    """Does the node represent a list literal?"""
+    return (isinstance(node, Node)
+            and len(node.children) > 1
+            and isinstance(node.children[0], Leaf)
+            and isinstance(node.children[-1], Leaf)
+            and node.children[0].value == u"["
+            and node.children[-1].value == u"]")
+
+
+###########################################################
+### Misc
+###########################################################
+
+def parenthesize(node):
+    return Node(syms.atom, [LParen(), node, RParen()])
+
+
+consuming_calls = set(["sorted", "list", "set", "any", "all", "tuple", "sum",
+                       "min", "max", "enumerate"])
+
+def attr_chain(obj, attr):
+    """Follow an attribute chain.
+
+    If you have a chain of objects where a.foo -> b, b.foo-> c, etc,
+    use this to iterate over all objects in the chain. Iteration is
+    terminated by getattr(x, attr) is None.
+
+    Args:
+        obj: the starting object
+        attr: the name of the chaining attribute
+
+    Yields:
+        Each successive object in the chain.
+    """
+    next = getattr(obj, attr)
+    while next:
+        yield next
+        next = getattr(next, attr)
+
+p0 = """for_stmt< 'for' any 'in' node=any ':' any* >
+        | comp_for< 'for' any 'in' node=any any* >
+     """
+p1 = """
+power<
+    ( 'iter' | 'list' | 'tuple' | 'sorted' | 'set' | 'sum' |
+      'any' | 'all' | 'enumerate' | (any* trailer< '.' 'join' >) )
+    trailer< '(' node=any ')' >
+    any*
+>
+"""
+p2 = """
+power<
+    ( 'sorted' | 'enumerate' )
+    trailer< '(' arglist<node=any any*> ')' >
+    any*
+>
+"""
+pats_built = False
+def in_special_context(node):
+    """ Returns true if node is in an environment where all that is required
+        of it is being iterable (ie, it doesn't matter if it returns a list
+        or an iterator).
+        See test_map_nochange in test_fixers.py for some examples and tests.
+        """
+    global p0, p1, p2, pats_built
+    if not pats_built:
+        p0 = patcomp.compile_pattern(p0)
+        p1 = patcomp.compile_pattern(p1)
+        p2 = patcomp.compile_pattern(p2)
+        pats_built = True
+    patterns = [p0, p1, p2]
+    for pattern, parent in zip(patterns, attr_chain(node, "parent")):
+        results = {}
+        if pattern.match(parent, results) and results["node"] is node:
+            return True
+    return False
+
+def is_probably_builtin(node):
+    """
+    Check that something isn't an attribute or function name etc.
+    """
+    prev = node.prev_sibling
+    if prev is not None and prev.type == token.DOT:
+        # Attribute lookup.
+        return False
+    parent = node.parent
+    if parent.type in (syms.funcdef, syms.classdef):
+        return False
+    if parent.type == syms.expr_stmt and parent.children[0] is node:
+        # Assignment.
+        return False
+    if parent.type == syms.parameters or \
+            (parent.type == syms.typedargslist and (
+            (prev is not None and prev.type == token.COMMA) or
+            parent.children[0] is node
+            )):
+        # The name of an argument.
+        return False
+    return True
+
+def find_indentation(node):
+    """Find the indentation of *node*."""
+    while node is not None:
+        if node.type == syms.suite and len(node.children) > 2:
+            indent = node.children[1]
+            if indent.type == token.INDENT:
+                return indent.value
+        node = node.parent
+    return u""
+
+###########################################################
+### The following functions are to find bindings in a suite
+###########################################################
+
+def make_suite(node):
+    if node.type == syms.suite:
+        return node
+    node = node.clone()
+    parent, node.parent = node.parent, None
+    suite = Node(syms.suite, [node])
+    suite.parent = parent
+    return suite
+
+def find_root(node):
+    """Find the top level namespace."""
+    # Scamper up to the top level namespace
+    while node.type != syms.file_input:
+        node = node.parent
+        if not node:
+            raise ValueError("root found before file_input node was found.")
+    return node
+
+def does_tree_import(package, name, node):
+    """ Returns true if name is imported from package at the
+        top level of the tree which node belongs to.
+        To cover the case of an import like 'import foo', use
+        None for the package and 'foo' for the name. """
+    binding = find_binding(name, find_root(node), package)
+    return bool(binding)
+
+def is_import(node):
+    """Returns true if the node is an import statement."""
+    return node.type in (syms.import_name, syms.import_from)
+
+def touch_import(package, name, node):
+    """ Works like `does_tree_import` but adds an import statement
+        if it was not imported. """
+    def is_import_stmt(node):
+        return (node.type == syms.simple_stmt and node.children and
+                is_import(node.children[0]))
+
+    root = find_root(node)
+
+    if does_tree_import(package, name, root):
+        return
+
+    # figure out where to insert the new import.  First try to find
+    # the first import and then skip to the last one.
+    insert_pos = offset = 0
+    for idx, node in enumerate(root.children):
+        if not is_import_stmt(node):
+            continue
+        for offset, node2 in enumerate(root.children[idx:]):
+            if not is_import_stmt(node2):
+                break
+        insert_pos = idx + offset
+        break
+
+    # if there are no imports where we can insert, find the docstring.
+    # if that also fails, we stick to the beginning of the file
+    if insert_pos == 0:
+        for idx, node in enumerate(root.children):
+            if (node.type == syms.simple_stmt and node.children and
+               node.children[0].type == token.STRING):
+                insert_pos = idx + 1
+                break
+
+    if package is None:
+        import_ = Node(syms.import_name, [
+            Leaf(token.NAME, u"import"),
+            Leaf(token.NAME, name, prefix=u" ")
+        ])
+    else:
+        import_ = FromImport(package, [Leaf(token.NAME, name, prefix=u" ")])
+
+    children = [import_, Newline()]
+    root.insert_child(insert_pos, Node(syms.simple_stmt, children))
+
+
+_def_syms = set([syms.classdef, syms.funcdef])
+def find_binding(name, node, package=None):
+    """ Returns the node which binds variable name, otherwise None.
+        If optional argument package is supplied, only imports will
+        be returned.
+        See test cases for examples."""
+    for child in node.children:
+        ret = None
+        if child.type == syms.for_stmt:
+            if _find(name, child.children[1]):
+                return child
+            n = find_binding(name, make_suite(child.children[-1]), package)
+            if n: ret = n
+        elif child.type in (syms.if_stmt, syms.while_stmt):
+            n = find_binding(name, make_suite(child.children[-1]), package)
+            if n: ret = n
+        elif child.type == syms.try_stmt:
+            n = find_binding(name, make_suite(child.children[2]), package)
+            if n:
+                ret = n
+            else:
+                for i, kid in enumerate(child.children[3:]):
+                    if kid.type == token.COLON and kid.value == ":":
+                        # i+3 is the colon, i+4 is the suite
+                        n = find_binding(name, make_suite(child.children[i+4]), package)
+                        if n: ret = n
+        elif child.type in _def_syms and child.children[1].value == name:
+            ret = child
+        elif _is_import_binding(child, name, package):
+            ret = child
+        elif child.type == syms.simple_stmt:
+            ret = find_binding(name, child, package)
+        elif child.type == syms.expr_stmt:
+            if _find(name, child.children[0]):
+                ret = child
+
+        if ret:
+            if not package:
+                return ret
+            if is_import(ret):
+                return ret
+    return None
+
+_block_syms = set([syms.funcdef, syms.classdef, syms.trailer])
+def _find(name, node):
+    nodes = [node]
+    while nodes:
+        node = nodes.pop()
+        if node.type > 256 and node.type not in _block_syms:
+            nodes.extend(node.children)
+        elif node.type == token.NAME and node.value == name:
+            return node
+    return None
+
+def _is_import_binding(node, name, package=None):
+    """ Will reuturn node if node will import name, or node
+        will import * from package.  None is returned otherwise.
+        See test cases for examples. """
+
+    if node.type == syms.import_name and not package:
+        imp = node.children[1]
+        if imp.type == syms.dotted_as_names:
+            for child in imp.children:
+                if child.type == syms.dotted_as_name:
+                    if child.children[2].value == name:
+                        return node
+                elif child.type == token.NAME and child.value == name:
+                    return node
+        elif imp.type == syms.dotted_as_name:
+            last = imp.children[-1]
+            if last.type == token.NAME and last.value == name:
+                return node
+        elif imp.type == token.NAME and imp.value == name:
+            return node
+    elif node.type == syms.import_from:
+        # unicode(...) is used to make life easier here, because
+        # from a.b import parses to ['import', ['a', '.', 'b'], ...]
+        if package and unicode(node.children[1]).strip() != package:
+            return None
+        n = node.children[3]
+        if package and _find(u"as", n):
+            # See test_from_import_as for explanation
+            return None
+        elif n.type == syms.import_as_names and _find(name, n):
+            return node
+        elif n.type == syms.import_as_name:
+            child = n.children[2]
+            if child.type == token.NAME and child.value == name:
+                return node
+        elif n.type == token.NAME and n.value == name:
+            return node
+        elif package and n.type == token.STAR:
+            return node
+    return None

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/__init__.py

@@ -0,0 +1 @@
+# Dummy file to make this directory a package.

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_apply.py

@@ -0,0 +1,59 @@
+# Copyright 2006 Google, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Fixer for apply().
+
+This converts apply(func, v, k) into (func)(*v, **k)."""
+
+# Local imports
+from .. import pytree
+from ..pgen2 import token
+from .. import fixer_base
+from ..fixer_util import Call, Comma, parenthesize
+
+class FixApply(fixer_base.BaseFix):
+    BM_compatible = True
+
+    PATTERN = """
+    power< 'apply'
+        trailer<
+            '('
+            arglist<
+                (not argument<NAME '=' any>) func=any ','
+                (not argument<NAME '=' any>) args=any [','
+                (not argument<NAME '=' any>) kwds=any] [',']
+            >
+            ')'
+        >
+    >
+    """
+
+    def transform(self, node, results):
+        syms = self.syms
+        assert results
+        func = results["func"]
+        args = results["args"]
+        kwds = results.get("kwds")
+        prefix = node.prefix
+        func = func.clone()
+        if (func.type not in (token.NAME, syms.atom) and
+            (func.type != syms.power or
+             func.children[-2].type == token.DOUBLESTAR)):
+            # Need to parenthesize
+            func = parenthesize(func)
+        func.prefix = ""
+        args = args.clone()
+        args.prefix = ""
+        if kwds is not None:
+            kwds = kwds.clone()
+            kwds.prefix = ""
+        l_newargs = [pytree.Leaf(token.STAR, u"*"), args]
+        if kwds is not None:
+            l_newargs.extend([Comma(),
+                              pytree.Leaf(token.DOUBLESTAR, u"**"),
+                              kwds])
+            l_newargs[-2].prefix = u" " # that's the ** token
+        # XXX Sometimes we could be cleverer, e.g. apply(f, (x, y) + t)
+        # can be translated into f(x, y, *t) instead of f(*(x, y) + t)
+        #new = pytree.Node(syms.power, (func, ArgList(l_newargs)))
+        return Call(func, l_newargs, prefix=prefix)

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_basestring.py

@@ -0,0 +1,14 @@
+"""Fixer for basestring -> str."""
+# Author: Christian Heimes
+
+# Local imports
+from .. import fixer_base
+from ..fixer_util import Name
+
+class FixBasestring(fixer_base.BaseFix):
+    BM_compatible = True
+
+    PATTERN = "'basestring'"
+
+    def transform(self, node, results):
+        return Name(u"str", prefix=node.prefix)

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_buffer.py

@@ -0,0 +1,22 @@
+# Copyright 2007 Google, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Fixer that changes buffer(...) into memoryview(...)."""
+
+# Local imports
+from .. import fixer_base
+from ..fixer_util import Name
+
+
+class FixBuffer(fixer_base.BaseFix):
+    BM_compatible = True
+
+    explicit = True # The user must ask for this fixer
+
+    PATTERN = """
+              power< name='buffer' trailer< '(' [any] ')' > any* >
+              """
+
+    def transform(self, node, results):
+        name = results["name"]
+        name.replace(Name(u"memoryview", prefix=name.prefix))

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_callable.py

@@ -0,0 +1,37 @@
+# Copyright 2007 Google, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Fixer for callable().
+
+This converts callable(obj) into isinstance(obj, collections.Callable), adding a
+collections import if needed."""
+
+# Local imports
+from lib2to3 import fixer_base
+from lib2to3.fixer_util import Call, Name, String, Attr, touch_import
+
+class FixCallable(fixer_base.BaseFix):
+    BM_compatible = True
+
+    order = "pre"
+
+    # Ignore callable(*args) or use of keywords.
+    # Either could be a hint that the builtin callable() is not being used.
+    PATTERN = """
+    power< 'callable'
+           trailer< lpar='('
+                    ( not(arglist | argument<any '=' any>) func=any
+                      | func=arglist<(not argument<any '=' any>) any ','> )
+                    rpar=')' >
+           after=any*
+    >
+    """
+
+    def transform(self, node, results):
+        func = results['func']
+
+        touch_import(None, u'collections', node=node)
+
+        args = [func.clone(), String(u', ')]
+        args.extend(Attr(Name(u'collections'), Name(u'Callable')))
+        return Call(Name(u'isinstance'), args, prefix=node.prefix)

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_dict.py

@@ -0,0 +1,107 @@
+# Copyright 2007 Google, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Fixer for dict methods.
+
+d.keys() -> list(d.keys())
+d.items() -> list(d.items())
+d.values() -> list(d.values())
+
+d.iterkeys() -> iter(d.keys())
+d.iteritems() -> iter(d.items())
+d.itervalues() -> iter(d.values())
+
+d.viewkeys() -> d.keys()
+d.viewitems() -> d.items()
+d.viewvalues() -> d.values()
+
+Except in certain very specific contexts: the iter() can be dropped
+when the context is list(), sorted(), iter() or for...in; the list()
+can be dropped when the context is list() or sorted() (but not iter()
+or for...in!). Special contexts that apply to both: list(), sorted(), tuple()
+set(), any(), all(), sum().
+
+Note: iter(d.keys()) could be written as iter(d) but since the
+original d.iterkeys() was also redundant we don't fix this.  And there
+are (rare) contexts where it makes a difference (e.g. when passing it
+as an argument to a function that introspects the argument).
+"""
+
+# Local imports
+from .. import pytree
+from .. import patcomp
+from ..pgen2 import token
+from .. import fixer_base
+from ..fixer_util import Name, Call, LParen, RParen, ArgList, Dot
+from .. import fixer_util
+
+
+iter_exempt = fixer_util.consuming_calls | set(["iter"])
+
+
+class FixDict(fixer_base.BaseFix):
+    BM_compatible = True
+
+    PATTERN = """
+    power< head=any+
+         trailer< '.' method=('keys'|'items'|'values'|
+                              'iterkeys'|'iteritems'|'itervalues'|
+                              'viewkeys'|'viewitems'|'viewvalues') >
+         parens=trailer< '(' ')' >
+         tail=any*
+    >
+    """
+
+    def transform(self, node, results):
+        head = results["head"]
+        method = results["method"][0] # Extract node for method name
+        tail = results["tail"]
+        syms = self.syms
+        method_name = method.value
+        isiter = method_name.startswith(u"iter")
+        isview = method_name.startswith(u"view")
+        if isiter or isview:
+            method_name = method_name[4:]
+        assert method_name in (u"keys", u"items", u"values"), repr(method)
+        head = [n.clone() for n in head]
+        tail = [n.clone() for n in tail]
+        special = not tail and self.in_special_context(node, isiter)
+        args = head + [pytree.Node(syms.trailer,
+                                   [Dot(),
+                                    Name(method_name,
+                                         prefix=method.prefix)]),
+                       results["parens"].clone()]
+        new = pytree.Node(syms.power, args)
+        if not (special or isview):
+            new.prefix = u""
+            new = Call(Name(u"iter" if isiter else u"list"), [new])
+        if tail:
+            new = pytree.Node(syms.power, [new] + tail)
+        new.prefix = node.prefix
+        return new
+
+    P1 = "power< func=NAME trailer< '(' node=any ')' > any* >"
+    p1 = patcomp.compile_pattern(P1)
+
+    P2 = """for_stmt< 'for' any 'in' node=any ':' any* >
+            | comp_for< 'for' any 'in' node=any any* >
+         """
+    p2 = patcomp.compile_pattern(P2)
+
+    def in_special_context(self, node, isiter):
+        if node.parent is None:
+            return False
+        results = {}
+        if (node.parent.parent is not None and
+               self.p1.match(node.parent.parent, results) and
+               results["node"] is node):
+            if isiter:
+                # iter(d.iterkeys()) -> iter(d.keys()), etc.
+                return results["func"].value in iter_exempt
+            else:
+                # list(d.keys()) -> list(d.keys()), etc.
+                return results["func"].value in fixer_util.consuming_calls
+        if not isiter:
+            return False
+        # for ... in d.iterkeys() -> for ... in d.keys(), etc.
+        return self.p2.match(node.parent, results) and results["node"] is node

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_except.py

@@ -0,0 +1,93 @@
+"""Fixer for except statements with named exceptions.
+
+The following cases will be converted:
+
+- "except E, T:" where T is a name:
+
+    except E as T:
+
+- "except E, T:" where T is not a name, tuple or list:
+
+        except E as t:
+            T = t
+
+    This is done because the target of an "except" clause must be a
+    name.
+
+- "except E, T:" where T is a tuple or list literal:
+
+        except E as t:
+            T = t.args
+"""
+# Author: Collin Winter
+
+# Local imports
+from .. import pytree
+from ..pgen2 import token
+from .. import fixer_base
+from ..fixer_util import Assign, Attr, Name, is_tuple, is_list, syms
+
+def find_excepts(nodes):
+    for i, n in enumerate(nodes):
+        if n.type == syms.except_clause:
+            if n.children[0].value == u'except':
+                yield (n, nodes[i+2])
+
+class FixExcept(fixer_base.BaseFix):
+    BM_compatible = True
+
+    PATTERN = """
+    try_stmt< 'try' ':' (simple_stmt | suite)
+                  cleanup=(except_clause ':' (simple_stmt | suite))+
+                  tail=(['except' ':' (simple_stmt | suite)]
+                        ['else' ':' (simple_stmt | suite)]
+                        ['finally' ':' (simple_stmt | suite)]) >
+    """
+
+    def transform(self, node, results):
+        syms = self.syms
+
+        tail = [n.clone() for n in results["tail"]]
+
+        try_cleanup = [ch.clone() for ch in results["cleanup"]]
+        for except_clause, e_suite in find_excepts(try_cleanup):
+            if len(except_clause.children) == 4:
+                (E, comma, N) = except_clause.children[1:4]
+                comma.replace(Name(u"as", prefix=u" "))
+
+                if N.type != token.NAME:
+                    # Generate a new N for the except clause
+                    new_N = Name(self.new_name(), prefix=u" ")
+                    target = N.clone()
+                    target.prefix = u""
+                    N.replace(new_N)
+                    new_N = new_N.clone()
+
+                    # Insert "old_N = new_N" as the first statement in
+                    #  the except body. This loop skips leading whitespace
+                    #  and indents
+                    #TODO(cwinter) suite-cleanup
+                    suite_stmts = e_suite.children
+                    for i, stmt in enumerate(suite_stmts):
+                        if isinstance(stmt, pytree.Node):
+                            break
+
+                    # The assignment is different if old_N is a tuple or list
+                    # In that case, the assignment is old_N = new_N.args
+                    if is_tuple(N) or is_list(N):
+                        assign = Assign(target, Attr(new_N, Name(u'args')))
+                    else:
+                        assign = Assign(target, new_N)
+
+                    #TODO(cwinter) stopgap until children becomes a smart list
+                    for child in reversed(suite_stmts[:i]):
+                        e_suite.insert_child(0, child)
+                    e_suite.insert_child(i, assign)
+                elif N.prefix == u"":
+                    # No space after a comma is legal; no space after "as",
+                    # not so much.
+                    N.prefix = u" "
+
+        #TODO(cwinter) fix this when children becomes a smart list
+        children = [c.clone() for c in node.children[:3]] + try_cleanup + tail
+        return pytree.Node(node.type, children)

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_exec.py

@@ -0,0 +1,40 @@
+# Copyright 2006 Google, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Fixer for exec.
+
+This converts usages of the exec statement into calls to a built-in
+exec() function.
+
+exec code in ns1, ns2 -> exec(code, ns1, ns2)
+"""
+
+# Local imports
+from .. import pytree
+from .. import fixer_base
+from ..fixer_util import Comma, Name, Call
+
+
+class FixExec(fixer_base.BaseFix):
+    BM_compatible = True
+
+    PATTERN = """
+    exec_stmt< 'exec' a=any 'in' b=any [',' c=any] >
+    |
+    exec_stmt< 'exec' (not atom<'(' [any] ')'>) a=any >
+    """
+
+    def transform(self, node, results):
+        assert results
+        syms = self.syms
+        a = results["a"]
+        b = results.get("b")
+        c = results.get("c")
+        args = [a.clone()]
+        args[0].prefix = ""
+        if b is not None:
+            args.extend([Comma(), b.clone()])
+        if c is not None:
+            args.extend([Comma(), c.clone()])
+
+        return Call(Name(u"exec"), args, prefix=node.prefix)

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_execfile.py

@@ -0,0 +1,52 @@
+# Copyright 2006 Google, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Fixer for execfile.
+
+This converts usages of the execfile function into calls to the built-in
+exec() function.
+"""
+
+from .. import fixer_base
+from ..fixer_util import (Comma, Name, Call, LParen, RParen, Dot, Node,
+                          ArgList, String, syms)
+
+
+class FixExecfile(fixer_base.BaseFix):
+    BM_compatible = True
+
+    PATTERN = """
+    power< 'execfile' trailer< '(' arglist< filename=any [',' globals=any [',' locals=any ] ] > ')' > >
+    |
+    power< 'execfile' trailer< '(' filename=any ')' > >
+    """
+
+    def transform(self, node, results):
+        assert results
+        filename = results["filename"]
+        globals = results.get("globals")
+        locals = results.get("locals")
+
+        # Copy over the prefix from the right parentheses end of the execfile
+        # call.
+        execfile_paren = node.children[-1].children[-1].clone()
+        # Construct open().read().
+        open_args = ArgList([filename.clone()], rparen=execfile_paren)
+        open_call = Node(syms.power, [Name(u"open"), open_args])
+        read = [Node(syms.trailer, [Dot(), Name(u'read')]),
+                Node(syms.trailer, [LParen(), RParen()])]
+        open_expr = [open_call] + read
+        # Wrap the open call in a compile call. This is so the filename will be
+        # preserved in the execed code.
+        filename_arg = filename.clone()
+        filename_arg.prefix = u" "
+        exec_str = String(u"'exec'", u" ")
+        compile_args = open_expr + [Comma(), filename_arg, Comma(), exec_str]
+        compile_call = Call(Name(u"compile"), compile_args, u"")
+        # Finally, replace the execfile call with an exec call.
+        args = [compile_call]
+        if globals is not None:
+            args.extend([Comma(), globals.clone()])
+        if locals is not None:
+            args.extend([Comma(), locals.clone()])
+        return Call(Name(u"exec"), args, prefix=node.prefix)

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_exitfunc.py

@@ -0,0 +1,72 @@
+"""
+Convert use of sys.exitfunc to use the atexit module.
+"""
+
+# Author: Benjamin Peterson
+
+from lib2to3 import pytree, fixer_base
+from lib2to3.fixer_util import Name, Attr, Call, Comma, Newline, syms
+
+
+class FixExitfunc(fixer_base.BaseFix):
+    keep_line_order = True
+    BM_compatible = True
+
+    PATTERN = """
+              (
+                  sys_import=import_name<'import'
+                      ('sys'
+                      |
+                      dotted_as_names< (any ',')* 'sys' (',' any)* >
+                      )
+                  >
+              |
+                  expr_stmt<
+                      power< 'sys' trailer< '.' 'exitfunc' > >
+                  '=' func=any >
+              )
+              """
+
+    def __init__(self, *args):
+        super(FixExitfunc, self).__init__(*args)
+
+    def start_tree(self, tree, filename):
+        super(FixExitfunc, self).start_tree(tree, filename)
+        self.sys_import = None
+
+    def transform(self, node, results):
+        # First, find a the sys import. We'll just hope it's global scope.
+        if "sys_import" in results:
+            if self.sys_import is None:
+                self.sys_import = results["sys_import"]
+            return
+
+        func = results["func"].clone()
+        func.prefix = u""
+        register = pytree.Node(syms.power,
+                               Attr(Name(u"atexit"), Name(u"register"))
+                               )
+        call = Call(register, [func], node.prefix)
+        node.replace(call)
+
+        if self.sys_import is None:
+            # That's interesting.
+            self.warning(node, "Can't find sys import; Please add an atexit "
+                             "import at the top of your file.")
+            return
+
+        # Now add an atexit import after the sys import.
+        names = self.sys_import.children[1]
+        if names.type == syms.dotted_as_names:
+            names.append_child(Comma())
+            names.append_child(Name(u"atexit", u" "))
+        else:
+            containing_stmt = self.sys_import.parent
+            position = containing_stmt.children.index(self.sys_import)
+            stmt_container = containing_stmt.parent
+            new_import = pytree.Node(syms.import_name,
+                              [Name(u"import"), Name(u"atexit", u" ")]
+                              )
+            new = pytree.Node(syms.simple_stmt, [new_import])
+            containing_stmt.insert_child(position + 1, Newline())
+            containing_stmt.insert_child(position + 2, new)

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_filter.py

@@ -0,0 +1,76 @@
+# Copyright 2007 Google, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Fixer that changes filter(F, X) into list(filter(F, X)).
+
+We avoid the transformation if the filter() call is directly contained
+in iter(<>), list(<>), tuple(<>), sorted(<>), ...join(<>), or
+for V in <>:.
+
+NOTE: This is still not correct if the original code was depending on
+filter(F, X) to return a string if X is a string and a tuple if X is a
+tuple.  That would require type inference, which we don't do.  Let
+Python 2.6 figure it out.
+"""
+
+# Local imports
+from ..pgen2 import token
+from .. import fixer_base
+from ..fixer_util import Name, Call, ListComp, in_special_context
+
+class FixFilter(fixer_base.ConditionalFix):
+    BM_compatible = True
+
+    PATTERN = """
+    filter_lambda=power<
+        'filter'
+        trailer<
+            '('
+            arglist<
+                lambdef< 'lambda'
+                         (fp=NAME | vfpdef< '(' fp=NAME ')'> ) ':' xp=any
+                >
+                ','
+                it=any
+            >
+            ')'
+        >
+    >
+    |
+    power<
+        'filter'
+        trailer< '(' arglist< none='None' ',' seq=any > ')' >
+    >
+    |
+    power<
+        'filter'
+        args=trailer< '(' [any] ')' >
+    >
+    """
+
+    skip_on = "future_builtins.filter"
+
+    def transform(self, node, results):
+        if self.should_skip(node):
+            return
+
+        if "filter_lambda" in results:
+            new = ListComp(results.get("fp").clone(),
+                           results.get("fp").clone(),
+                           results.get("it").clone(),
+                           results.get("xp").clone())
+
+        elif "none" in results:
+            new = ListComp(Name(u"_f"),
+                           Name(u"_f"),
+                           results["seq"].clone(),
+                           Name(u"_f"))
+
+        else:
+            if in_special_context(node):
+                return None
+            new = node.clone()
+            new.prefix = u""
+            new = Call(Name(u"list"), [new])
+        new.prefix = node.prefix
+        return new

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_funcattrs.py

@@ -0,0 +1,21 @@
+"""Fix function attribute names (f.func_x -> f.__x__)."""
+# Author: Collin Winter
+
+# Local imports
+from .. import fixer_base
+from ..fixer_util import Name
+
+
+class FixFuncattrs(fixer_base.BaseFix):
+    BM_compatible = True
+
+    PATTERN = """
+    power< any+ trailer< '.' attr=('func_closure' | 'func_doc' | 'func_globals'
+                                  | 'func_name' | 'func_defaults' | 'func_code'
+                                  | 'func_dict') > any* >
+    """
+
+    def transform(self, node, results):
+        attr = results["attr"][0]
+        attr.replace(Name((u"__%s__" % attr.value[5:]),
+                          prefix=attr.prefix))

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_future.py

@@ -0,0 +1,22 @@
+"""Remove __future__ imports
+
+from __future__ import foo is replaced with an empty line.
+"""
+# Author: Christian Heimes
+
+# Local imports
+from .. import fixer_base
+from ..fixer_util import BlankLine
+
+class FixFuture(fixer_base.BaseFix):
+    BM_compatible = True
+
+    PATTERN = """import_from< 'from' module_name="__future__" 'import' any >"""
+
+    # This should be run last -- some things check for the import
+    run_order = 10
+
+    def transform(self, node, results):
+        new = BlankLine()
+        new.prefix = node.prefix
+        return new

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_getcwdu.py

@@ -0,0 +1,19 @@
+"""
+Fixer that changes os.getcwdu() to os.getcwd().
+"""
+# Author: Victor Stinner
+
+# Local imports
+from .. import fixer_base
+from ..fixer_util import Name
+
+class FixGetcwdu(fixer_base.BaseFix):
+    BM_compatible = True
+
+    PATTERN = """
+              power< 'os' trailer< dot='.' name='getcwdu' > any* >
+              """
+
+    def transform(self, node, results):
+        name = results["name"]
+        name.replace(Name(u"getcwd", prefix=name.prefix))

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_has_key.py

@@ -0,0 +1,110 @@
+# Copyright 2006 Google, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Fixer for has_key().
+
+Calls to .has_key() methods are expressed in terms of the 'in'
+operator:
+
+    d.has_key(k) -> k in d
+
+CAVEATS:
+1) While the primary target of this fixer is dict.has_key(), the
+   fixer will change any has_key() method call, regardless of its
+   class.
+
+2) Cases like this will not be converted:
+
+    m = d.has_key
+    if m(k):
+        ...
+
+   Only *calls* to has_key() are converted. While it is possible to
+   convert the above to something like
+
+    m = d.__contains__
+    if m(k):
+        ...
+
+   this is currently not done.
+"""
+
+# Local imports
+from .. import pytree
+from ..pgen2 import token
+from .. import fixer_base
+from ..fixer_util import Name, parenthesize
+
+
+class FixHasKey(fixer_base.BaseFix):
+    BM_compatible = True
+
+    PATTERN = """
+    anchor=power<
+        before=any+
+        trailer< '.' 'has_key' >
+        trailer<
+            '('
+            ( not(arglist | argument<any '=' any>) arg=any
+            | arglist<(not argument<any '=' any>) arg=any ','>
+            )
+            ')'
+        >
+        after=any*
+    >
+    |
+    negation=not_test<
+        'not'
+        anchor=power<
+            before=any+
+            trailer< '.' 'has_key' >
+            trailer<
+                '('
+                ( not(arglist | argument<any '=' any>) arg=any
+                | arglist<(not argument<any '=' any>) arg=any ','>
+                )
+                ')'
+            >
+        >
+    >
+    """
+
+    def transform(self, node, results):
+        assert results
+        syms = self.syms
+        if (node.parent.type == syms.not_test and
+            self.pattern.match(node.parent)):
+            # Don't transform a node matching the first alternative of the
+            # pattern when its parent matches the second alternative
+            return None
+        negation = results.get("negation")
+        anchor = results["anchor"]
+        prefix = node.prefix
+        before = [n.clone() for n in results["before"]]
+        arg = results["arg"].clone()
+        after = results.get("after")
+        if after:
+            after = [n.clone() for n in after]
+        if arg.type in (syms.comparison, syms.not_test, syms.and_test,
+                        syms.or_test, syms.test, syms.lambdef, syms.argument):
+            arg = parenthesize(arg)
+        if len(before) == 1:
+            before = before[0]
+        else:
+            before = pytree.Node(syms.power, before)
+        before.prefix = u" "
+        n_op = Name(u"in", prefix=u" ")
+        if negation:
+            n_not = Name(u"not", prefix=u" ")
+            n_op = pytree.Node(syms.comp_op, (n_not, n_op))
+        new = pytree.Node(syms.comparison, (arg, n_op, before))
+        if after:
+            new = parenthesize(new)
+            new = pytree.Node(syms.power, (new,) + tuple(after))
+        if node.parent.type in (syms.comparison, syms.expr, syms.xor_expr,
+                                syms.and_expr, syms.shift_expr,
+                                syms.arith_expr, syms.term,
+                                syms.factor, syms.power):
+            new = parenthesize(new)
+        new.prefix = prefix
+        return new

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_idioms.py

@@ -0,0 +1,152 @@
+"""Adjust some old Python 2 idioms to their modern counterparts.
+
+* Change some type comparisons to isinstance() calls:
+    type(x) == T -> isinstance(x, T)
+    type(x) is T -> isinstance(x, T)
+    type(x) != T -> not isinstance(x, T)
+    type(x) is not T -> not isinstance(x, T)
+
+* Change "while 1:" into "while True:".
+
+* Change both
+
+    v = list(EXPR)
+    v.sort()
+    foo(v)
+
+and the more general
+
+    v = EXPR
+    v.sort()
+    foo(v)
+
+into
+
+    v = sorted(EXPR)
+    foo(v)
+"""
+# Author: Jacques Frechet, Collin Winter
+
+# Local imports
+from .. import fixer_base
+from ..fixer_util import Call, Comma, Name, Node, BlankLine, syms
+
+CMP = "(n='!=' | '==' | 'is' | n=comp_op< 'is' 'not' >)"
+TYPE = "power< 'type' trailer< '(' x=any ')' > >"
+
+class FixIdioms(fixer_base.BaseFix):
+    explicit = True # The user must ask for this fixer
+
+    PATTERN = r"""
+        isinstance=comparison< %s %s T=any >
+        |
+        isinstance=comparison< T=any %s %s >
+        |
+        while_stmt< 'while' while='1' ':' any+ >
+        |
+        sorted=any<
+            any*
+            simple_stmt<
+              expr_stmt< id1=any '='
+                         power< list='list' trailer< '(' (not arglist<any+>) any ')' > >
+              >
+              '\n'
+            >
+            sort=
+            simple_stmt<
+              power< id2=any
+                     trailer< '.' 'sort' > trailer< '(' ')' >
+              >
+              '\n'
+            >
+            next=any*
+        >
+        |
+        sorted=any<
+            any*
+            simple_stmt< expr_stmt< id1=any '=' expr=any > '\n' >
+            sort=
+            simple_stmt<
+              power< id2=any
+                     trailer< '.' 'sort' > trailer< '(' ')' >
+              >
+              '\n'
+            >
+            next=any*
+        >
+    """ % (TYPE, CMP, CMP, TYPE)
+
+    def match(self, node):
+        r = super(FixIdioms, self).match(node)
+        # If we've matched one of the sort/sorted subpatterns above, we
+        # want to reject matches where the initial assignment and the
+        # subsequent .sort() call involve different identifiers.
+        if r and "sorted" in r:
+            if r["id1"] == r["id2"]:
+                return r
+            return None
+        return r
+
+    def transform(self, node, results):
+        if "isinstance" in results:
+            return self.transform_isinstance(node, results)
+        elif "while" in results:
+            return self.transform_while(node, results)
+        elif "sorted" in results:
+            return self.transform_sort(node, results)
+        else:
+            raise RuntimeError("Invalid match")
+
+    def transform_isinstance(self, node, results):
+        x = results["x"].clone() # The thing inside of type()
+        T = results["T"].clone() # The type being compared against
+        x.prefix = u""
+        T.prefix = u" "
+        test = Call(Name(u"isinstance"), [x, Comma(), T])
+        if "n" in results:
+            test.prefix = u" "
+            test = Node(syms.not_test, [Name(u"not"), test])
+        test.prefix = node.prefix
+        return test
+
+    def transform_while(self, node, results):
+        one = results["while"]
+        one.replace(Name(u"True", prefix=one.prefix))
+
+    def transform_sort(self, node, results):
+        sort_stmt = results["sort"]
+        next_stmt = results["next"]
+        list_call = results.get("list")
+        simple_expr = results.get("expr")
+
+        if list_call:
+            list_call.replace(Name(u"sorted", prefix=list_call.prefix))
+        elif simple_expr:
+            new = simple_expr.clone()
+            new.prefix = u""
+            simple_expr.replace(Call(Name(u"sorted"), [new],
+                                     prefix=simple_expr.prefix))
+        else:
+            raise RuntimeError("should not have reached here")
+        sort_stmt.remove()
+
+        btwn = sort_stmt.prefix
+        # Keep any prefix lines between the sort_stmt and the list_call and
+        # shove them right after the sorted() call.
+        if u"\n" in btwn:
+            if next_stmt:
+                # The new prefix should be everything from the sort_stmt's
+                # prefix up to the last newline, then the old prefix after a new
+                # line.
+                prefix_lines = (btwn.rpartition(u"\n")[0], next_stmt[0].prefix)
+                next_stmt[0].prefix = u"\n".join(prefix_lines)
+            else:
+                assert list_call.parent
+                assert list_call.next_sibling is None
+                # Put a blank line after list_call and set its prefix.
+                end_line = BlankLine()
+                list_call.parent.append_child(end_line)
+                assert list_call.next_sibling is end_line
+                # The new prefix should be everything up to the first new line
+                # of sort_stmt's prefix.
+                end_line.prefix = btwn.rpartition(u"\n")[0]

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_import.py

@@ -0,0 +1,99 @@
+"""Fixer for import statements.
+If spam is being imported from the local directory, this import:
+    from spam import eggs
+Becomes:
+    from .spam import eggs
+
+And this import:
+    import spam
+Becomes:
+    from . import spam
+"""
+
+# Local imports
+from .. import fixer_base
+from os.path import dirname, join, exists, sep
+from ..fixer_util import FromImport, syms, token
+
+
+def traverse_imports(names):
+    """
+    Walks over all the names imported in a dotted_as_names node.
+    """
+    pending = [names]
+    while pending:
+        node = pending.pop()
+        if node.type == token.NAME:
+            yield node.value
+        elif node.type == syms.dotted_name:
+            yield "".join([ch.value for ch in node.children])
+        elif node.type == syms.dotted_as_name:
+            pending.append(node.children[0])
+        elif node.type == syms.dotted_as_names:
+            pending.extend(node.children[::-2])
+        else:
+            raise AssertionError("unknown node type")
+
+
+class FixImport(fixer_base.BaseFix):
+    BM_compatible = True
+
+    PATTERN = """
+    import_from< 'from' imp=any 'import' ['('] any [')'] >
+    |
+    import_name< 'import' imp=any >
+    """
+
+    def start_tree(self, tree, name):
+        super(FixImport, self).start_tree(tree, name)
+        self.skip = "absolute_import" in tree.future_features
+
+    def transform(self, node, results):
+        if self.skip:
+            return
+        imp = results['imp']
+
+        if node.type == syms.import_from:
+            # Some imps are top-level (eg: 'import ham')
+            # some are first level (eg: 'import ham.eggs')
+            # some are third level (eg: 'import ham.eggs as spam')
+            # Hence, the loop
+            while not hasattr(imp, 'value'):
+                imp = imp.children[0]
+            if self.probably_a_local_import(imp.value):
+                imp.value = u"." + imp.value
+                imp.changed()
+        else:
+            have_local = False
+            have_absolute = False
+            for mod_name in traverse_imports(imp):
+                if self.probably_a_local_import(mod_name):
+                    have_local = True
+                else:
+                    have_absolute = True
+            if have_absolute:
+                if have_local:
+                    # We won't handle both sibling and absolute imports in the
+                    # same statement at the moment.
+                    self.warning(node, "absolute and local imports together")
+                return
+
+            new = FromImport(u".", [imp])
+            new.prefix = node.prefix
+            return new
+
+    def probably_a_local_import(self, imp_name):
+        if imp_name.startswith(u"."):
+            # Relative imports are certainly not local imports.
+            return False
+        imp_name = imp_name.split(u".", 1)[0]
+        base_path = dirname(self.filename)
+        base_path = join(base_path, imp_name)
+        # If there is no __init__.py next to the file its not in a package
+        # so can't be a relative import.
+        if not exists(join(dirname(base_path), "__init__.py")):
+            return False
+        for ext in [".py", sep, ".pyc", ".so", ".sl", ".pyd"]:
+            if exists(base_path + ext):
+                return True
+        return False

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_imports.py

@@ -0,0 +1,145 @@
+"""Fix incompatible imports and module references."""
+# Authors: Collin Winter, Nick Edds
+
+# Local imports
+from .. import fixer_base
+from ..fixer_util import Name, attr_chain
+
+MAPPING = {'StringIO':  'io',
+           'cStringIO': 'io',
+           'cPickle': 'pickle',
+           '__builtin__' : 'builtins',
+           'copy_reg': 'copyreg',
+           'Queue': 'queue',
+           'SocketServer': 'socketserver',
+           'ConfigParser': 'configparser',
+           'repr': 'reprlib',
+           'FileDialog': 'tkinter.filedialog',
+           'tkFileDialog': 'tkinter.filedialog',
+           'SimpleDialog': 'tkinter.simpledialog',
+           'tkSimpleDialog': 'tkinter.simpledialog',
+           'tkColorChooser': 'tkinter.colorchooser',
+           'tkCommonDialog': 'tkinter.commondialog',
+           'Dialog': 'tkinter.dialog',
+           'Tkdnd': 'tkinter.dnd',
+           'tkFont': 'tkinter.font',
+           'tkMessageBox': 'tkinter.messagebox',
+           'ScrolledText': 'tkinter.scrolledtext',
+           'Tkconstants': 'tkinter.constants',
+           'Tix': 'tkinter.tix',
+           'ttk': 'tkinter.ttk',
+           'Tkinter': 'tkinter',
+           'markupbase': '_markupbase',
+           '_winreg': 'winreg',
+           'thread': '_thread',
+           'dummy_thread': '_dummy_thread',
+           # anydbm and whichdb are handled by fix_imports2
+           'dbhash': 'dbm.bsd',
+           'dumbdbm': 'dbm.dumb',
+           'dbm': 'dbm.ndbm',
+           'gdbm': 'dbm.gnu',
+           'xmlrpclib': 'xmlrpc.client',
+           'DocXMLRPCServer': 'xmlrpc.server',
+           'SimpleXMLRPCServer': 'xmlrpc.server',
+           'httplib': 'http.client',
+           'htmlentitydefs' : 'html.entities',
+           'HTMLParser' : 'html.parser',
+           'Cookie': 'http.cookies',
+           'cookielib': 'http.cookiejar',
+           'BaseHTTPServer': 'http.server',
+           'SimpleHTTPServer': 'http.server',
+           'CGIHTTPServer': 'http.server',
+           #'test.test_support': 'test.support',
+           'commands': 'subprocess',
+           'UserString' : 'collections',
+           'UserList' : 'collections',
+           'urlparse' : 'urllib.parse',
+           'robotparser' : 'urllib.robotparser',
+}
+
+
+def alternates(members):
+    return "(" + "|".join(map(repr, members)) + ")"
+
+
+def build_pattern(mapping=MAPPING):
+    mod_list = ' | '.join(["module_name='%s'" % key for key in mapping])
+    bare_names = alternates(mapping.keys())
+
+    yield """name_import=import_name< 'import' ((%s) |
+               multiple_imports=dotted_as_names< any* (%s) any* >) >
+          """ % (mod_list, mod_list)
+    yield """import_from< 'from' (%s) 'import' ['(']
+              ( any | import_as_name< any 'as' any > |
+                import_as_names< any* >)  [')'] >
+          """ % mod_list
+    yield """import_name< 'import' (dotted_as_name< (%s) 'as' any > |
+               multiple_imports=dotted_as_names<
+                 any* dotted_as_name< (%s) 'as' any > any* >) >
+          """ % (mod_list, mod_list)
+
+    # Find usages of module members in code e.g. thread.foo(bar)
+    yield "power< bare_with_attr=(%s) trailer<'.' any > any* >" % bare_names
+
+
+class FixImports(fixer_base.BaseFix):
+
+    BM_compatible = True
+    keep_line_order = True
+    # This is overridden in fix_imports2.
+    mapping = MAPPING
+
+    # We want to run this fixer late, so fix_import doesn't try to make stdlib
+    # renames into relative imports.
+    run_order = 6
+
+    def build_pattern(self):
+        return "|".join(build_pattern(self.mapping))
+
+    def compile_pattern(self):
+        # We override this, so MAPPING can be pragmatically altered and the
+        # changes will be reflected in PATTERN.
+        self.PATTERN = self.build_pattern()
+        super(FixImports, self).compile_pattern()
+
+    # Don't match the node if it's within another match.
+    def match(self, node):
+        match = super(FixImports, self).match
+        results = match(node)
+        if results:
+            # Module usage could be in the trailer of an attribute lookup, so we
+            # might have nested matches when "bare_with_attr" is present.
+            if "bare_with_attr" not in results and \
+                    any(match(obj) for obj in attr_chain(node, "parent")):
+                return False
+            return results
+        return False
+
+    def start_tree(self, tree, filename):
+        super(FixImports, self).start_tree(tree, filename)
+        self.replace = {}
+
+    def transform(self, node, results):
+        import_mod = results.get("module_name")
+        if import_mod:
+            mod_name = import_mod.value
+            new_name = unicode(self.mapping[mod_name])
+            import_mod.replace(Name(new_name, prefix=import_mod.prefix))
+            if "name_import" in results:
+                # If it's not a "from x import x, y" or "import x as y" import,
+                # marked its usage to be replaced.
+                self.replace[mod_name] = new_name
+            if "multiple_imports" in results:
+                # This is a nasty hack to fix multiple imports on a line (e.g.,
+                # "import StringIO, urlparse"). The problem is that I can't
+                # figure out an easy way to make a pattern recognize the keys of
+                # MAPPING randomly sprinkled in an import statement.
+                results = self.match(node)
+                if results:
+                    self.transform(node, results)
+        else:
+            # Replace usage of the module.
+            bare_name = results["bare_with_attr"][0]
+            new_name = self.replace.get(bare_name.value)
+            if new_name:
+                bare_name.replace(Name(new_name, prefix=bare_name.prefix))

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_imports2.py

@@ -0,0 +1,16 @@
+"""Fix incompatible imports and module references that must be fixed after
+fix_imports."""
+from . import fix_imports
+
+
+MAPPING = {
+            'whichdb': 'dbm',
+            'anydbm': 'dbm',
+          }
+
+
+class FixImports2(fix_imports.FixImports):
+
+    run_order = 7
+
+    mapping = MAPPING

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_input.py

@@ -0,0 +1,26 @@
+"""Fixer that changes input(...) into eval(input(...))."""
+# Author: Andre Roberge
+
+# Local imports
+from .. import fixer_base
+from ..fixer_util import Call, Name
+from .. import patcomp
+
+
+context = patcomp.compile_pattern("power< 'eval' trailer< '(' any ')' > >")
+
+
+class FixInput(fixer_base.BaseFix):
+    BM_compatible = True
+    PATTERN = """
+              power< 'input' args=trailer< '(' [any] ')' > >
+              """
+
+    def transform(self, node, results):
+        # If we're already wrapped in a eval() call, we're done.
+        if context.match(node.parent.parent):
+            return
+
+        new = node.clone()
+        new.prefix = u""
+        return Call(Name(u"eval"), [new], prefix=node.prefix)

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_intern.py

@@ -0,0 +1,46 @@
+# Copyright 2006 Georg Brandl.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Fixer for intern().
+
+intern(s) -> sys.intern(s)"""
+
+# Local imports
+from .. import pytree
+from .. import fixer_base
+from ..fixer_util import Name, Attr, touch_import
+
+
+class FixIntern(fixer_base.BaseFix):
+    BM_compatible = True
+    order = "pre"
+
+    PATTERN = """
+    power< 'intern'
+           trailer< lpar='('
+                    ( not(arglist | argument<any '=' any>) obj=any
+                      | obj=arglist<(not argument<any '=' any>) any ','> )
+                    rpar=')' >
+           after=any*
+    >
+    """
+
+    def transform(self, node, results):
+        syms = self.syms
+        obj = results["obj"].clone()
+        if obj.type == syms.arglist:
+            newarglist = obj.clone()
+        else:
+            newarglist = pytree.Node(syms.arglist, [obj.clone()])
+        after = results["after"]
+        if after:
+            after = [n.clone() for n in after]
+        new = pytree.Node(syms.power,
+                          Attr(Name(u"sys"), Name(u"intern")) +
+                          [pytree.Node(syms.trailer,
+                                       [results["lpar"].clone(),
+                                        newarglist,
+                                        results["rpar"].clone()])] + after)
+        new.prefix = node.prefix
+        touch_import(None, u'sys', node)
+        return new

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_isinstance.py

@@ -0,0 +1,52 @@
+# Copyright 2008 Armin Ronacher.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Fixer that cleans up a tuple argument to isinstance after the tokens
+in it were fixed.  This is mainly used to remove double occurrences of
+tokens as a leftover of the long -> int / unicode -> str conversion.
+
+eg.  isinstance(x, (int, long)) -> isinstance(x, (int, int))
+       -> isinstance(x, int)
+"""
+
+from .. import fixer_base
+from ..fixer_util import token
+
+
+class FixIsinstance(fixer_base.BaseFix):
+    BM_compatible = True
+    PATTERN = """
+    power<
+        'isinstance'
+        trailer< '(' arglist< any ',' atom< '('
+            args=testlist_gexp< any+ >
+        ')' > > ')' >
+    >
+    """
+
+    run_order = 6
+
+    def transform(self, node, results):
+        names_inserted = set()
+        testlist = results["args"]
+        args = testlist.children
+        new_args = []
+        iterator = enumerate(args)
+        for idx, arg in iterator:
+            if arg.type == token.NAME and arg.value in names_inserted:
+                if idx < len(args) - 1 and args[idx + 1].type == token.COMMA:
+                    iterator.next()
+                    continue
+            else:
+                new_args.append(arg)
+                if arg.type == token.NAME:
+                    names_inserted.add(arg.value)
+        if new_args and new_args[-1].type == token.COMMA:
+            del new_args[-1]
+        if len(new_args) == 1:
+            atom = testlist.parent
+            new_args[0].prefix = atom.prefix
+            atom.replace(new_args[0])
+        else:
+            args[:] = new_args
+            node.changed()

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_itertools.py

@@ -0,0 +1,43 @@
+""" Fixer for itertools.(imap|ifilter|izip) --> (map|filter|zip) and
+    itertools.ifilterfalse --> itertools.filterfalse (bugs 2360-2363)
+
+    imports from itertools are fixed in fix_itertools_import.py
+
+    If itertools is imported as something else (ie: import itertools as it;
+    it.izip(spam, eggs)) method calls will not get fixed.
+    """
+
+# Local imports
+from .. import fixer_base
+from ..fixer_util import Name
+
+class FixItertools(fixer_base.BaseFix):
+    BM_compatible = True
+    it_funcs = "('imap'|'ifilter'|'izip'|'izip_longest'|'ifilterfalse')"
+    PATTERN = """
+              power< it='itertools'
+                  trailer<
+                     dot='.' func=%(it_funcs)s > trailer< '(' [any] ')' > >
+              |
+              power< func=%(it_funcs)s trailer< '(' [any] ')' > >
+              """ %(locals())
+
+    # Needs to be run after fix_(map|zip|filter)
+    run_order = 6
+
+    def transform(self, node, results):
+        prefix = None
+        func = results['func'][0]
+        if ('it' in results and
+            func.value not in (u'ifilterfalse', u'izip_longest')):
+            dot, it = (results['dot'], results['it'])
+            # Remove the 'itertools'
+            prefix = it.prefix
+            it.remove()
+            # Replace the node which contains ('.', 'function') with the
+            # function (to be consistent with the second part of the pattern)
+            dot.remove()
+            func.parent.replace(func)
+
+        prefix = prefix or func.prefix
+        func.replace(Name(func.value[1:], prefix=prefix))

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_itertools_imports.py

@@ -0,0 +1,57 @@
+""" Fixer for imports of itertools.(imap|ifilter|izip|ifilterfalse) """
+
+# Local imports
+from lib2to3 import fixer_base
+from lib2to3.fixer_util import BlankLine, syms, token
+
+
+class FixItertoolsImports(fixer_base.BaseFix):
+    BM_compatible = True
+    PATTERN = """
+              import_from< 'from' 'itertools' 'import' imports=any >
+              """ %(locals())
+
+    def transform(self, node, results):
+        imports = results['imports']
+        if imports.type == syms.import_as_name or not imports.children:
+            children = [imports]
+        else:
+            children = imports.children
+        for child in children[::2]:
+            if child.type == token.NAME:
+                member = child.value
+                name_node = child
+            elif child.type == token.STAR:
+                # Just leave the import as is.
+                return
+            else:
+                assert child.type == syms.import_as_name
+                name_node = child.children[0]
+            member_name = name_node.value
+            if member_name in (u'imap', u'izip', u'ifilter'):
+                child.value = None
+                child.remove()
+            elif member_name in (u'ifilterfalse', u'izip_longest'):
+                node.changed()
+                name_node.value = (u'filterfalse' if member_name[1] == u'f'
+                                   else u'zip_longest')
+
+        # Make sure the import statement is still sane
+        children = imports.children[:] or [imports]
+        remove_comma = True
+        for child in children:
+            if remove_comma and child.type == token.COMMA:
+                child.remove()
+            else:
+                remove_comma ^= True
+
+        while children and children[-1].type == token.COMMA:
+            children.pop().remove()
+
+        # If there are no imports left, just get rid of the entire statement
+        if (not (imports.children or getattr(imports, 'value', None)) or
+            imports.parent is None):
+            p = node.prefix
+            node = BlankLine()
+            node.prefix = p
+            return node

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_long.py

@@ -0,0 +1,19 @@
+# Copyright 2006 Google, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Fixer that turns 'long' into 'int' everywhere.
+"""
+
+# Local imports
+from lib2to3 import fixer_base
+from lib2to3.fixer_util import is_probably_builtin
+
+
+class FixLong(fixer_base.BaseFix):
+    BM_compatible = True
+    PATTERN = "'long'"
+
+    def transform(self, node, results):
+        if is_probably_builtin(node):
+            node.value = u"int"
+            node.changed()

model/comp_surface/tools/transfer/pdb2pqr-linux-bin64-2.1.1/lib2to3/fixes/fix_map.py

@@ -0,0 +1,91 @@
+# Copyright 2007 Google, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Fixer that changes map(F, ...) into list(map(F, ...)) unless there
+exists a 'from future_builtins import map' statement in the top-level
+namespace.
+
+As a special case, map(None, X) is changed into list(X).  (This is
+necessary because the semantics are changed in this case -- the new
+map(None, X) is equivalent to [(x,) for x in X].)
+
+We avoid the transformation (except for the special case mentioned
+above) if the map() call is directly contained in iter(<>), list(<>),
+tuple(<>), sorted(<>), ...join(<>), or for V in <>:.
+
+NOTE: This is still not correct if the original code was depending on
+map(F, X, Y, ...) to go on until the longest argument is exhausted,
+substituting None for missing values -- like zip(), it now stops as
+soon as the shortest argument is exhausted.
+"""
+
+# Local imports
+from ..pgen2 import token
+from .. import fixer_base
+from ..fixer_util import Name, Call, ListComp, in_special_context
+from ..pygram import python_symbols as syms
+
+class FixMap(fixer_base.ConditionalFix):
+    BM_compatible = True
+
+    PATTERN = """
+    map_none=power<
+        'map'
+        trailer< '(' arglist< 'None' ',' arg=any [','] > ')' >
+    >
+    |
+    map_lambda=power<
+        'map'
+        trailer<
+            '('
+            arglist<
+                lambdef< 'lambda'
+                         (fp=NAME | vfpdef< '(' fp=NAME ')'> ) ':' xp=any
+                >
+                ','
+                it=any
+            >
+            ')'
+        >
+    >
+    |
+    power<
+        'map' trailer< '(' [arglist=any] ')' >
+    >
+    """
+
+    skip_on = 'future_builtins.map'
+
+    def transform(self, node, results):
+        if self.should_skip(node):
+            return
+
+        if node.parent.type == syms.simple_stmt:
+            self.warning(node, "You should use a for loop here")
+            new = node.clone()
+            new.prefix = u""
+            new = Call(Name(u"list"), [new])
+        elif "map_lambda" in results:
+            new = ListComp(results["xp"].clone(),
+                           results["fp"].clone(),
+                           results["it"].clone())
+        else:
+            if "map_none" in results:
+                new = results["arg"].clone()
+            else:
+                if "arglist" in results:
+                    args = results["arglist"]
+                    if args.type == syms.arglist and \
+                       args.children[0].type == token.NAME and \
+                       args.children[0].value == "None":
+                        self.warning(node, "cannot convert map(None, ...) "
+                                     "with multiple arguments because map() "
+                                     "now truncates to the shortest sequence")
+                        return
+                if in_special_context(node):
+                    return None
+                new = node.clone()
+            new.prefix = u""
+            new = Call(Name(u"list"), [new])
+        new.prefix = node.prefix
+        return new