Example #1
0
def prettify(obj):
    if hasattr(obj, 'getSource'):
        return obj.getSource()
    else:
        t = type(obj)
        if t in _SIMPLE_BUILTINS:
            return repr(obj)
        elif t is types.DictType:
            out = ['{']
            for k,v in obj.items():
                out.append('\n\0%s: %s,' % (prettify(k), prettify(v)))
            out.append(len(obj) and '\n\0}' or '}')
            return string.join(out, '')
        elif t is types.ListType:
            out = ["["]
            for x in obj:
                out.append('\n\0%s,' % prettify(x))
            out.append(len(obj) and '\n\0]' or ']')
            return string.join(out, '')
        elif t is types.TupleType:
            out = ["("]
            for x in obj:
                out.append('\n\0%s,' % prettify(x))
            out.append(len(obj) and '\n\0)' or ')')
            return string.join(out, '')
        else:
            raise TypeError("Unsupported type %s when trying to prettify %s." % (t, obj))
Example #2
0
def writedoc(key,top=False):
    """Write HTML documentation to a file in the current directory."""
    if(type(key) == str and (key == "modules" or key == "/.")):
        heading = pydoc.html.heading(
            '<br><big><big><strong>&nbsp;'
            'Python: Index of Modules'
            '</strong></big></big>',
            '#ffffff', '#7799ee')
        builtins = []
        for name in sys.builtin_module_names:
            builtins.append('<a href="%s">%s</a>' % (cgi.escape(name,quote=True), cgi.escape(name)))
        indices = ['<p>Built-in modules: ' + cgi.escape(join(builtins, ', '))]
        seen = {}
        for dir in pydoc.pathdirs():
            indices.append(pydoc.html.index(dir, seen))
        print cleanlinks(heading + join(indices))
        return

    if(type(key) != types.ModuleType):
        object = pydoc.locate(key)
        if(object == None and top):
            print "could not locate module/object for key " + \
                   cgi.escape(key) + "<br><a href=\"pydoc:modules\">go to index</a>";
    else:
        object = key
            
    if object:
        print cleanlinks(pydoc.html.page(pydoc.describe(object), pydoc.html.document(object)))
Example #3
0
def smb4_grant_user_rights(user):
    args = [
        "/usr/local/bin/net",
        "-d 0",
        "sam",
        "rights",
        "grant"
    ]

    rights = [
        "SeTakeOwnershipPrivilege",
        "SeBackupPrivilege",
        "SeRestorePrivilege"
    ]

    net_cmd = "%s %s %s" % (
        string.join(args, ' '),
        user,
        string.join(rights, ' ')
    )

    p = pipeopen(net_cmd)
    net_out = p.communicate()
    if net_out and net_out[0]:
        for line in net_out[0].split('\n'):
            if not line:
                continue
            print line

    if p.returncode != 0:
        return False

    return True
Example #4
0
  def _writeLifecycle(self, fileOut):
    """
    Write default constructor and destructor.
    """
    # Constructor
    fileOut.write("%s::%s::%s(void)\n" % \
                  (string.join(self.namespace, "::"),
                   self.objname, self.objname))

    fileOut.write("{ // constructor\n")

    for scalar in self.scalars:
      n = scalar['name']
      if "char*" != scalar['type']:
        fileOut.write("  %s = %s;\n" % (n[1:], n))
      else:
        fileOut.write("  %s = const_cast<char*>(%s);\n" % (n[1:], n))
    for array in self.arrays:
      n = array['name']
      fileOut.write("  %s = const_cast<%s*>(%s);\n" % \
                    (n[1:], array['type'], n))
    fileOut.write("} // constructor\n\n")

    # Destructor
    fileOut.write("%s::%s::~%s(void)\n" % \
                  (string.join(self.namespace, "::"),
                   self.objname, self.objname))
    fileOut.write("{}\n\n")
    return
Example #5
0
 def _format_data(self, start_time, timestamp, name, units, values):
     fields = _fields[:]
     file_timestamp = time.strftime('%Y%m%d%H%M',time.gmtime(start_time))
     value_timestamp = time.strftime('%Y%m%d%H%M',time.gmtime(timestamp))
     fields[_field_index['units']] = units
     fields[_field_index['commodity']] = self.commodity
     meter_id = name + '|1'
     if units:
         meter_id += '/%s' % units
     fields[_field_index['meter_id']] = meter_id
     fields[_field_index['receiver_id']] = ''
     fields[_field_index['receiver_customer_id']] = self.customer_name + '|' + self.account_name
     fields[_field_index['timestamp']] = file_timestamp
     # interval put into "MMDDHHMM" with MMDD = 0000
     fields[_field_index['interval']] = '0000%02d%02d' % (self.period / 3600, (self.period % 3600) / 60)
     fields[_field_index['count']] = str(len(values))
     value_sets =  []
     for value in values:
         try:
             value = '%f' % value
             protocol_text = ''
         except ValueError:
             value = ''
             protocol_text = 'N'
         value_set = (value_timestamp, protocol_text, value)
         value_sets.append(string.join(value_set, ','))
         value_timestamp = ''
     fields[_field_index['interval_data']] = string.join(value_sets, ',')
     return string.join(fields, ',')
def main( text, key ):
    result = list()
  
    for i in range ( 0, len( text ) ):
        result.append( chr( ord( text[i] ) ^ ord( key[i%len( key )] ) ) )

    print string.join( result, "" ).encode( "hex" ) 
Example #7
0
def checkVersion():
    import sys, string
    if sys.version_info < requiredPythonVersion:
        raise Exception("%s requires at least Python %s, found %s instead." % (
            name,
            string.join(map(str, requiredPythonVersion), "."),
            string.join(map(str, sys.version_info), ".")))
Example #8
0
 def endElement(self, name):
     if name in self.atags:
         aux = string.join(self.interestData)
         if not self.atags[name]:
             #delta_ts could be overwritten by delta_ts of attachment
             self.atags[name] = unicode(aux)
         self.tag_name = None
     elif name in self.long_desc_tags:
         aux = string.join(self.interestData)
         self.long_desc_tags[name] = unicode(aux)
         self.tag_name = None
     elif name in self.btags:
         aux = string.join(self.interestData)
         self.btags[name].append(unicode(aux))
         self.tag_name = None
     elif name in self.ctags:
         if name == 'long_desc':
             aux = self._copy_long_desc_tags()
             self.ctags['long_desc'].append(aux)
             self._init_long_desc_tags()
         elif name == 'attachment':
             pass
         self.tag_name = None
     elif name == "bug":
         #self.issues_data[self.atags["bug_id"]] = self.get_issue()
         self.issues_data.append(self.get_issue())
Example #9
0
def join_header_words(lists):
    """Do the inverse of the conversion done by split_header_words.

    Takes a list of lists of (key, value) pairs and produces a single header
    value.  Attribute values are quoted if needed.

    >>> join_header_words([[("text/plain", None), ("charset", "iso-8859/1")]])
    'text/plain; charset="iso-8859/1"'
    >>> join_header_words([[("text/plain", None)], [("charset", "iso-8859/1")]])
    'text/plain, charset="iso-8859/1"'

    """
    headers = []
    for pairs in lists:
        attr = []
        for k, v in pairs:
            if v is not None:
                if not re.search(r"^\w+$", v):
                    v = join_escape_re.sub(r"\\\1", v)  # escape " and \
                    v = '"%s"' % v
                if k is None:  # Netscape cookies may have no name
                    k = v
                else:
                    k = "%s=%s" % (k, v)
            attr.append(k)
        if attr: headers.append(string.join(attr, "; "))
    return string.join(headers, ", ")
Example #10
0
    def __init__(self, entityTypeModule):
        self.entTypeModule = entityTypeModule
        hv = HashVal()
        import EntityTypes
        reload(EntityTypes)
        reload(self.entTypeModule)

        def getPyExtVersion(filename):
            base, ext = os.path.splitext(filename)
            if ext == '.pyc' or ext == '.pyo':
                filename = base + '.py'
            return filename

        fileLines = file(getPyExtVersion(EntityTypes.__file__)).readlines()
        hv.hashString(string.join(fileLines, ''))
        s = str(hv.asHex())
        s += '.'
        fileLines = file(getPyExtVersion(self.entTypeModule.__file__)).readlines()
        hv.hashString(string.join(fileLines, ''))
        s += str(hv.asHex())
        self.hashStr = s
        getPyExtVersion = None
        classes = []
        for key, value in entityTypeModule.__dict__.items():
            if type(value) is types.ClassType:
                if issubclass(value, EntityTypeDesc.EntityTypeDesc):
                    classes.append(value)

        self.entTypeName2typeDesc = {}
        mostDerivedLast(classes)
        for c in classes:
            if c.__dict__.has_key('type'):
                if self.entTypeName2typeDesc.has_key(c.type):
                    EntityTypeRegistry.notify.debug("replacing %s with %s for entity type '%s'" % (self.entTypeName2typeDesc[c.type].__class__, c, c.type))
                self.entTypeName2typeDesc[c.type] = c()

        self.output2typeNames = {}
        for typename, typeDesc in self.entTypeName2typeDesc.items():
            if typeDesc.isConcrete():
                if hasattr(typeDesc, 'output'):
                    outputType = typeDesc.output
                    self.output2typeNames.setdefault(outputType, [])
                    self.output2typeNames[outputType].append(typename)

        self.permanentTypeNames = []
        for typename, typeDesc in self.entTypeName2typeDesc.items():
            if typeDesc.isPermanent():
                self.permanentTypeNames.append(typename)

        self.typeName2derivedTypeNames = {}
        for typename, typeDesc in self.entTypeName2typeDesc.items():
            typenames = []
            for tn, td in self.entTypeName2typeDesc.items():
                if td.isConcrete():
                    if issubclass(td.__class__, typeDesc.__class__):
                        typenames.append(tn)

            self.typeName2derivedTypeNames[typename] = typenames

        return
Example #11
0
def makePWCSV(pathwayconnections):
    curStr = '"Pathway1 KEGG","Pathway2 KEGG","Connecting reactions","Connection metabolites"\n'
    for pathway in sorted(pathwayconnections.keys()):
        cPathways = pathwayconnections[pathway]
        #print pathway
        
        for cPathway in cPathways:
            if cPathway[:5] != "path:":
                ctPathway = "path:" + cPathway
            else:
                ctPathway = cPathway
            cReactionsStr = ""
            cMeabolitesStr = ""
            
            if pathway[:5] != "path:":
                tPathway = "path:" + pathway
            else:
                tPathway = pathway
            if ((tPathway in pathwayReact.keys()) and (ctPathway in pathwayReact.keys())): 
                cReactions = [reaction[3:] for reaction in pathwayReact[tPathway] if reaction in pathwayReact[ctPathway]]
                cReactionsStr = string.join(cReactions,"|")
                cMetabolites = []
            
                for reaction in cReactions:
                    tReaction = "rn:" + reaction
                    if tReaction in reactionsD.keys():
                        for metabolite in reactionsD[tReaction]["METABOLITES"]:
                            if metabolite not in cMetabolites:
                                cMetabolites.append(metabolite)
                cMetabolitesStr = string.join(cMetabolites,"|")
            #[metabolite for metabolite in rDictionary[reaction]["METABOLITES"] if metaolite in cReactions]
            
            curStr+= '"%s","%s","%s","%s"\n' % (pathway[5:], cPathway,cReactionsStr,cMetabolitesStr)

    return curStr
Example #12
0
    def parse_quoted_string(self, unfold=False):
        """Parses a quoted-string.

        Parses a single instance of the production quoted-string.  The
        return value is the entire matching string (including the quotes
        and any quoted pairs) or None if no quoted-string was found.

        If *unfold* is True then any folding LWS is replaced with a
        single SP.  It defaults to False"""
        if not self.parse(DQUOTE):
            return None
        qs = [DQUOTE]
        while self.the_char is not None:
            if self.parse(DQUOTE):
                qs.append(DQUOTE)
                break
            elif self.match("\\"):
                qp = self.parse_quoted_pair()
                if qp:
                    qs.append(qp)
                else:
                    raise ValueError(
                        "Expected quoted pair: %s..." % self.peek(5))
            else:
                qdtext = self.parse_qdtext(unfold)
                if qdtext:
                    qs.append(qdtext)
                else:
                    raise BadSyntax("Expected closing <\">: %s%s..." %
                                    (string.join(qs, ''), self.peek(5)))
        return string.join(qs, '')
Example #13
0
    def create_columns(self, table_id):
        """
        Create the columns for the table in question.  We call fix_datatype to
        clean up anything PGSQL or MYSQL specific.  The function is to be
        overidden by the database-specific subclass in question.

        """
        col_list = self.tables[table_id].get_columns()
        table_name = self.tables[table_id].name
        num_cols = len(col_list)
        if verbose:
            print "Found %s columns" % num_cols
        for index in range(num_cols):
            colname = col_list[index]

            coltype = self.tables[table_id].get_col_type(colname)
            coltype = self.fix_datatype(coltype)

            colvalue = self.tables[table_id].get_col_value(colname)
            colcomm = self.tables[table_id].get_col_comm(colname)
            if colcomm:
                colcomm.strip()
                self.sql_create = string.join((self.sql_create, "\n\t/* ", \
                         colcomm, " */"), "")
            col_statement = self.fix_value(table_name, colname, coltype, colvalue)
            if index < num_cols-1:
                self.sql_create = string.join((self.sql_create, "\n\t", \
                            string.upper(col_statement)+","), "")
            else:
                self.sql_create = string.join((self.sql_create, "\n\t", \
                            string.upper(col_statement)), "")
Example #14
0
    def getBulletin(self, includeError=False, useFinalLineSeparator=True):
        """getBulletin([includeError]) -> bulletin

           bulletin     : String

           includeError:        Bool
               - If True, include error in bulletin body.

           useFinalLineSeparator:       Bool
               - If True, use finalLineSeparator

           returns the bulletin text.

        """
        if useFinalLineSeparator:
            marqueur = self.finalLineSeparator
        else:
            marqueur = self.lineSeparator

        if self.errorBulletin == None:
            return string.join(self.bulletin, marqueur)
        else:
            if includeError:
                return ("### " + self.errorBulletin[0] + marqueur + "PROBLEM BULLETIN" + marqueur) + string.join(
                    self.bulletin, marqueur
                )
            else:
                return string.join(self.bulletin, marqueur)
Example #15
0
File: ui.py Project: rdgt321/p-NJU
    def UpdateIcon(self, force=False, info=None):
        try:
            isOnline = self.connection.IsOnline(force)
        except UpdateStatusException:
            return

        if isOnline:
            status = u"在线"
            icon = 'online'
        else:
            status = u"离线"
            icon = 'offline'

        if info == None:
            tooltip = string.join(("pNJU", status), " - ")
        else:
            tooltip = string.join(("pNJU", status, info), " - ")

        self.SetIcon(self.MakeIcon(icon), tooltip)

        if force and isOnline:
            newVersion = self.connection.CheckNewVersion()
            if newVersion is not None:
                confirm = wx.MessageBox(
                    u"发现新版本:{0}。是否立即查看更新信息?".format(newVersion),
                    u"pNJU 发现新版本",
                    wx.YES_NO | wx.YES_DEFAULT
                )
                if confirm == wx.YES:
                    import webbrowser
                    webbrowser.open(config.WEBSITE)
    def EdgesBetweenSequences( self ):
        """Write edges between sequences, if they
        share a common domain.
        """

        if self.mLogLevel >= 1:
            print "# instance of <" + str(self.__class__) + "> on " + time.asctime(time.localtime(time.time()))
            print "# source: %s" % (self.mTableNameDomains)
            sys.stdout.flush()

        class_ids = self.mTableFamilies.GetAllClasses()
        class_name = self.mTableFamilies.GetFieldNameClass()
        
        for class_id in class_ids:
            statement = """
            SELECT a.nid, COUNT(*) AS counts
            FROM %s AS a
            WHERE %s = %s
            GROUP BY a.nid
            """ % (self.mTableNameDomains,
                   class_name, class_id)

            result = self.dbhandle.Execute(statement).fetchall()

            for x in range(0, len(result)-1):
                nid1, counts1 = result[x]
                
                for y in range(x+1, len(result)):
                    nid2, counts2 = result[y]
                    print string.join(map(str, (nid1, nid2, counts1 * counts2, class_id)), "\t")
Example #17
0
def main():
	t1 = clock()
	filename = "HashInt.txt"
	inputfile = open(filename, 'r')
	numberDict = dict()
	for line in inputfile:
		number = eval(line)
		if not (number in numberDict):
			numberDict[number] = None
	inputfile.close()

	resultList = [None] * 9
	testfile = open("test.txt", 'r')
	index = 0
	for line in  testfile:
		dest = eval(line)
		for number in numberDict.keys():
			if (dest - number) in numberDict:
				resultList[index] = '1'
				break
		if resultList[index] == None:
			resultList[index] = '0'
		index = index + 1
	print join(resultList, "")
	testfile.close()
	print clock() - t1
Example #18
0
	def iter_some(self, depth, available, extra):
		self.writeout("recur: [%s] %s %d/%d\n" % (
		    string.join(self.selected[:self.selected_committed], ","), 
		    string.join(self.selected[self.selected_committed:], ","), 
		    len(available), len(extra)))

		if depth == 0:
			extra.extend(available)
			return self.iter_end(extra)

		nuninst = None
		
		while len(available) > depth:
			x = available.pop(0)

			self.doop_source(x)
			self.selected.append(x)

			res = self.iter_some(depth - 1, available[:], extra[:])
			if res[0]:
				nuninst = res[0]
				available = filter(lambda x, y=res[1]: x in y,
					available + extra)
				# reset nuninst_orig too
				self.nuninst_orig = nuninst
				extra = []
				continue

			self.srcsn.undo_change()
			self.selected.pop()

			extra.append(x)

		return (nuninst, extra)
    def NumAssignments( self ):
        """Write number of assignments
        """

        if self.mLogLevel >= 1:
            print "# instance of <" + str(self.__class__) + "> on " + time.asctime(time.localtime(time.time()))
            print "# source: %s" % (self.mTableNameDomains)
            print "# hubs between domains"
            print string.join( ("nid", "nassignments", "nclasses"), "\t")            
            sys.stdout.flush()

        result = self.mTableDomains.GetNumAssignments()

        for r in result:
            print string.join(map(str,r), "\t")

        data = map(lambda x:x[1], result)
        h = Histogram.Calculate(data)
        print "# histogram of number of domains per sequence"
        Histogram.Print(h)

        data = map(lambda x:x[2], result)
        h = Histogram.Calculate(data)
        print "# histogram of number of different domains per sequence"
        Histogram.Print(h)
Example #20
0
    def extract_key( self ):
        text = string.strip( self.text )
        key = string.join( string.split( text ) )
        words = string.split( key )
        key = string.join( words[ :2 ] )
        self.text = ''

        try:
            self.open_tag = self.open_tag_stack.pop()
        except:
            self.open_tag = 'open_html'
        if( self.open_tag == 'open_table_data' ):
            if( self.context == 'general_info' ):
                if( self.key_waiting == '' ):
                    self.key_waiting = key
                    self.text = ''
            elif( self.context == 'seq_info' ):
                if( text == 'Key to Symbols' ):
                    self.context = 'legend'
                    self.master_key = key
        elif( self.context == 'general_info' ):
            self.master_key = key
            if( string.find( key, 'SEQUENCE' ) != -1 ):
                self.context = 'seq_info'
            self.queue[ key ] = UserDict.UserDict()
        elif( self.context == 'seq_info' ):
            self.queue[ key ] = UserDict.UserDict()
            self.master_key = key
Example #21
0
 def output(self,seq,outfile,occdata=[]):   ### Output to file
     '''Output to file.'''
     try:### ~ [1] ~ Basic Data ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ###
         if self.opt['OccOnly'] and not occdata: return
         odata = ['Name\t%s' % (seq.shortName()),
                  'Sequence\t%s' % (seq.getSequence(gaps=False)),
                  'Output\t%s' % (string.join(string.split(outfile,'.')[:-1],'.')),
                  'RE\t%s' % (string.join(self.list['PlotRE'],',')),
                  'TrueELMs\tY',
                  'Description\t%s' % (seq.info['Description']),
                  '',]
         ### ~ [2] ~ PlotStats ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ###
         for plot in rje.sortKeys(seq.dict['PlotStat']): odata.append('Plot\t%s\t%s' % (plot,string.join(seq.dict['PlotStat'][plot],', ')))
         if seq.dict['PlotStat']: odata.append('')
         ### ~ [3] ~ PlotFT ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ###
         if seq.obj['Entry']:
             for ft in seq.obj['Entry'].list['Feature']:
                 if ft['Type'] in self.list['PlotFT']: odata.append('Region\t%s %s\t%s:%s' % (ft['Type'],ft['Desc'],ft['Start'],ft['End']))
             odata.append('')
         ### ~ [4] ~ MotifOcc ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ###
         if occdata:
             for occ in occdata: odata.append('Motif\t%s\t%s:%s' % (occ['Pattern'],occ['Start_Pos'],occ['End_Pos']))
         ### ~ [5] ~ Output ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ###
         open(outfile,'w').write(string.join(odata,'\n'))
         self.printLog('#PLOT','SeqPlot output saved as %s' % (outfile))
     except: self.errorLog(rje_zen.Zen().wisdom())
Example #22
0
def PrintRecords(labels, s4, fmtHead, fmtTail="", printHex=True, printNorm=True):
    fmt = fmtHead
    szHead = struct.calcsize(fmtHead)
    szTail = struct.calcsize(fmtTail)
    printableHead = string.join([x for x in fmtHead if fmtmap.has_key(x)],"")
    printableTail = string.join([x for x in fmtTail if fmtmap.has_key(x)],"")
    if fmtTail != "":
        gap = len(s4[0]) - (struct.calcsize(fmtHead) + struct.calcsize(fmtTail))
        fmt = fmtHead + ("x"*gap) + fmtTail
    labels = ["LINE"] + labels[:len(printableHead)] + labels[len(labels)-len(printableTail):]
    PrintMultiLineLabels(labels,6)
    sys.stdout.write(6*" ")
    PrintByteLabels(fmt, len(s4))
    for i in range(0, len(s4)):
        if printNorm:
            sys.stdout.write("%5i:%s\n" % (i, StructToString(s4[i], fmt, 6)))
        if printHex:
            sys.stdout.write("\33[0m")
            sys.stdout.write("            %s\n" % (StructToString(s4[i], fmt, 6, color=False, hexonly=True)))
        if not ((i+1) % 40) or (i == len(s4) - 1):
            PrintMultiLineLabels(labels,6)
            sys.stdout.write(6*" ")
            PrintByteLabels(fmt, len(s4))
        #HexPrintMod(s4[i][:szHead].tostring() + s4[i][len(s4[i]) - szTail:].tostring(), szHead + szTail)
    PrintByteStats(s4, fmt)
Example #23
0
 def readKit(self, parent):
     """
     Reads the data from a xml file (auxiliar recursive function).
     """                             
     for node in parent.childNodes:
         if node.nodeType == Node.ELEMENT_NODE:
             
             attrs = node.attributes                             
             for attrName in attrs.keys():
                 attrNode = attrs.get(attrName)
                 attrValue = attrNode.nodeValue
                 self._Kit[attrName] = attrValue
             
             content = []                                        
             for child in node.childNodes:
                 if child.nodeType == Node.TEXT_NODE:
                     content.append(child.nodeValue)
                     if content and (node.nodeName != "control" and node.nodeName != "kitPackage"):
                         strContent = string.join(content)
                         tmpContent = strContent.replace("\n      ", "")
                         self._Kit[node.nodeName] = tmpContent.replace("\n    ", "")
                     if content and node.nodeName == "kitPackage":
                         strContent = string.join(content)
                         tmpContent = strContent.replace("\n      ", "")
                         self._kitPackages.append(tmpContent.replace("\n    ", ""))
                         
             self.readKit(node)
Example #24
0
def gettags(comment):

    tags = []

    tag = None
    tag_lineno = lineno = 0
    tag_text = []

    for line in comment:
        if line[:1] == "@":
            tags.append((tag_lineno, tag, string.join(tag_text, "\n")))
            line = string.split(line, " ", 1)
            tag = line[0][1:]
            if len(line) > 1:
                tag_text = [line[1]]
            else:
                tag_text = []
            tag_lineno = lineno
        else:
            tag_text.append(line)
        lineno = lineno + 1

    tags.append((tag_lineno, tag, string.join(tag_text, "\n")))

    return tags
Example #25
0
  def Table(self, t,
            has_head=1, headcolor="#ffc0c0", bgcolor="#ffffff"):
    if has_head:
      head = []
      for th in t.pop(0):
        head.append("<th><font size=\"-1\" face=\"arial,sans-serif\">"
                    "%s</font></th>" % th)
      # endfor
      table = ["<tr bgcolor=\"%s\">\n%s</th>\n" % (
        headcolor, string.join(head, "\n"))]
    else:
      table = []
    # endif

    for tr in t:
      row = []
      for td in tr:
        row.append("<td><font size=\"-1\" face=\"arial,sans-serif\">"
                   "%s</font></td>" % td)
      # endfor
      table.append("<tr bgcolor=\"%s\">\n%s</th>\n" % (
        bgcolor, string.join(row, "\n")))
    # endfor
    return "<p><table cellpadding=5 width=100%%>\n%s\n</table></p>\n" % (
      string.join(table, "\n"))
Example #26
0
File: S3.py Project: obulpathi/aws
  def build_post_policy(self, expiration_time, conditions):
    if type(expiration_time) != time.struct_time:
      raise 'Policy document must include a valid expiration Time object'
    if type(conditions) != types.DictionaryType:
      raise 'Policy document must include a valid conditions Hash object'

    # Convert conditions object mappings to condition statements
    conds = []
    for name in conditions:
      test = conditions[name]

      if not test:
        # A nil condition value means allow anything.
        conds.append('["starts-with", "$%s", ""]' % name)
      elif type(test) == types.StringType:
        conds.append('{"%s": "%s"}' % (name, test))
      elif type(test) == types.ListType:
        conds.append('{"%s": "%s"}' % (name, string.join(test, ',')))
      elif type(test) == types.DictionaryType:
        operation = test['op']
        value = test['value']
        conds.append('["%s", "$%s", "%s"]' % (operation, name, value))
      elif type(test) == types.SliceType:
        conds.append('["%s", %i, %i]' % (name, test.start, test.stop))
      else:
        raise 'Unexpected value type for condition "%s": %s' % \
          (name, type(test))

    return '{"expiration": "%s",\n"conditions": [%s]}' % \
      (time.strftime(self.ISO8601, expiration), string.join(conds, ','))
Example #27
0
	def toXML(self, writer, ttFont):
		if hasattr (ttFont, "disassembleInstructions") and ttFont.disassembleInstructions:
			assembly = self.getAssembly()
			writer.begintag("assembly")
			writer.newline()
			i = 0
			nInstr = len(assembly)
			while i < nInstr:
				instr = assembly[i]
				writer.write(instr)
				writer.newline()
				m = _pushCountPat.match(instr)
				i = i + 1
				if m:
					nValues = int(m.group(1))
					line = []
					j = 0
					for j in range(nValues):
						if j and not (j % 25):
							writer.write(string.join(line, " "))
							writer.newline()
							line = []
						line.append(assembly[i+j])
					writer.write(string.join(line, " "))
					writer.newline()
					i = i + j + 1
			writer.endtag("assembly")
		else:
			writer.begintag("bytecode")
			writer.newline()
			writer.dumphex(self.getBytecode())
			writer.endtag("bytecode")
def compact_traceback ():
	t,v,tb = sys.exc_info()
	tbinfo = []
	if tb is None:
		# this should never happen, but then again, lots of things
		# should never happen but do.
		return (('','',''), str(t), str(v), 'traceback is None!!!')
	while 1:
		tbinfo.append (
			tb.tb_frame.f_code.co_filename,
			tb.tb_frame.f_code.co_name,				
			str(tb.tb_lineno)
			)
		tb = tb.tb_next
		if not tb:
			break

	# just to be safe
	del tb

	file, function, line = tbinfo[-1]
	info = '[' + string.join (
		map (
			lambda x: string.join (x, '|'),
			tbinfo
			),
		'] ['
		) + ']'

	return (file, function, line), str(t), str(v), info
Example #29
0
    def MoveFolder(self, From, To):
        OPList = SymbolTools.SplitPath(From);
        OName  = OPList[-1];
        SPList = OPList[:-1];
        Src    = "/"+string.join(SPList,"/");
        NPList = SymbolTools.SplitPath(To);
        NName  = NPList[-1];
        DPList = NPList[:-1];
        Dest   = "/"+string.join(DPList,"/");

        #check if source exists:
        if not self.CheckFolder(From):
            raise Exceptions.ItemNotFound("Can't move folder %s to %s: source doesn't exists!"%(From,To));
        #check if destination is a symbol:
        if self.CheckSymbol(To):
            raise Exceptions.SymbolError("Can't move folder %s to %s: destination allready exists!"%(From,To));

        #remove folder from source:
        folder_obj = self.__GetElementByPath(OPList);
        src_obj = self.__GetElementByPath(SPList);
        src_obj.RemoveFolder(OName);
        #check if dest-folder isn't in src-folder:
        if not self.CheckFolder(Dest):
            src_obj.AddFolder(OName, folder_obj);
            raise Exceptions.SymbolError("Can't move folder %s to %s: destination is part of the source!"%(From,To));
        #move folder
        dest_obj = self.__GetElementByPath(DPList);
        folder_obj.Rename(NName);
        dest_obj.AddFolder(NName, folder_obj);
def generate(tmpl, name, table):
        w_arg_names = [a[1] for a in table[name] if a[0] == 'fop-arg']
        w_arg_types = [a[2] for a in table[name] if a[0] == 'fop-arg']
        u_arg_names = [a[1] for a in table[name] if a[0] == 'cbk-arg']
        u_arg_types = [a[2] for a in table[name] if a[0] == 'cbk-arg']
        fn_arg_names = [a[1] for a in table[name] if a[0] == 'fn-arg']
        fn_arg_types = [a[2] for a in table[name] if a[0] == 'fn-arg']
        ret_type = [a[1] for a in table[name] if a[0] == 'ret-val']
        ret_var = [a[2] for a in table[name] if a[0] == 'ret-val']

        sdict = {}
        #Parameters are (t1, var1), (t2, var2)...
        #Args are (var1, var2,...)
        sdict["@WIND_ARGS@"] = string.join(w_arg_names, ", ")
        sdict["@UNWIND_ARGS@"] = string.join(u_arg_names, ", ")
        sdict["@ERROR_ARGS@"] = string.join(map(get_error_arg, u_arg_types), ", ")
        sdict["@WIND_PARAMS@"] = get_param(w_arg_names, w_arg_types)
        sdict["@UNWIND_PARAMS@"] = get_param(u_arg_names, u_arg_types)
        sdict["@FUNC_PARAMS@"] = get_param(fn_arg_names, fn_arg_types)
        sdict["@NAME@"] = name
        sdict["@FOP_PREFIX@"] = fop_prefix
        sdict["@RET_TYPE@"] = string.join(ret_type, "")
        sdict["@RET_VAR@"] = string.join(ret_var, "")

        for old, new in sdict.iteritems():
                tmpl = tmpl.replace(old, new)
        # TBD: reindent/reformat the result for maximum readability.
        return tmpl
Example #31
0
def replace(file, searchkey, replacekey):
    regex = re.compile(searchkey)
    str_file = str(file)
    str_rep = regex.sub(replacekey, string.join(str_file, ''))
    return posixpath(str_rep)
Example #32
0
 def build_reply_header(self):
     return string.join([self.response(self.reply_code)] + map(
         lambda x: '%s: %s' % x, self.reply_headers.items()),
                        '\r\n') + '\r\n\r\n'
Example #33
0
 def nice_bytes(n):
     return string.join(status_handler.english_bytes(n))
Example #34
0
class http_request:

    # default reply code
    reply_code = 200

    request_counter = counter()

    # Whether to automatically use chunked encoding when
    #
    #   HTTP version is 1.1
    #   Content-Length is not set
    #   Chunked encoding is not already in effect
    #
    # If your clients are having trouble, you might want to disable this.
    use_chunked = 1

    # by default, this request object ignores user data.
    collector = None

    def __init__(self, *args):
        # unpack information about the request
        (self.channel, self.request, self.command, self.uri, self.version,
         self.header) = args

        self.outgoing = []
        self.reply_headers = {
            'Server': 'Medusa/%s' % VERSION_STRING,
            'Date': http_date.build_http_date(time.time())
        }
        self.request_number = http_request.request_counter.increment()
        self._split_uri = None
        self._header_cache = {}

    # --------------------------------------------------
    # reply header management
    # --------------------------------------------------
    def __setitem__(self, key, value):
        self.reply_headers[key] = value

    def __getitem__(self, key):
        return self.reply_headers[key]

    def has_key(self, key):
        return self.reply_headers.has_key(key)

    def build_reply_header(self):
        return string.join([self.response(self.reply_code)] + map(
            lambda x: '%s: %s' % x, self.reply_headers.items()),
                           '\r\n') + '\r\n\r\n'

    # --------------------------------------------------
    # split a uri
    # --------------------------------------------------

    # <path>;<params>?<query>#<fragment>
    path_regex = re.compile(
        #      path      params    query   fragment
        r'([^;?#]*)(;[^?#]*)?(\?[^#]*)?(#.*)?')

    def split_uri(self):
        if self._split_uri is None:
            m = self.path_regex.match(self.uri)
            if m.end() != len(self.uri):
                raise ValueError, "Broken URI"
            else:
                self._split_uri = m.groups()
        return self._split_uri

    def get_header_with_regex(self, head_reg, group):
        for line in self.header:
            m = head_reg.match(line)
            if m.end() == len(line):
                return m.group(group)
        return ''

    def get_header(self, header):
        header = string.lower(header)
        hc = self._header_cache
        if not hc.has_key(header):
            h = header + ': '
            hl = len(h)
            for line in self.header:
                if string.lower(line[:hl]) == h:
                    r = line[hl:]
                    hc[header] = r
                    return r
            hc[header] = None
            return None
        else:
            return hc[header]

    # --------------------------------------------------
    # user data
    # --------------------------------------------------

    def collect_incoming_data(self, data):
        if self.collector:
            self.collector.collect_incoming_data(data)
        else:
            self.log_info(
                'Dropping %d bytes of incoming request data' % len(data),
                'warning')

    def found_terminator(self):
        if self.collector:
            self.collector.found_terminator()
        else:
            self.log_info('Unexpected end-of-record for incoming request',
                          'warning')

    def push(self, thing):
        if type(thing) == type(''):
            self.outgoing.append(producers.simple_producer(thing))
        else:
            self.outgoing.append(thing)

    def response(self, code=200):
        message = self.responses[code]
        self.reply_code = code
        return 'HTTP/%s %d %s' % (self.version, code, message)

    def error(self, code):
        self.reply_code = code
        message = self.responses[code]
        s = self.DEFAULT_ERROR_MESSAGE % {
            'code': code,
            'message': message,
        }
        self['Content-Length'] = len(s)
        self['Content-Type'] = 'text/html'
        # make an error reply
        self.push(s)
        self.done()

    # can also be used for empty replies
    reply_now = error

    def done(self):
        "finalize this transaction - send output to the http channel"

        # ----------------------------------------
        # persistent connection management
        # ----------------------------------------

        #  --- BUCKLE UP! ----

        connection = string.lower(get_header(CONNECTION, self.header))

        close_it = 0
        wrap_in_chunking = 0

        if self.version == '1.0':
            if connection == 'keep-alive':
                if not self.has_key('Content-Length'):
                    close_it = 1
                else:
                    self['Connection'] = 'Keep-Alive'
            else:
                close_it = 1
        elif self.version == '1.1':
            if connection == 'close':
                close_it = 1
            elif not self.has_key('Content-Length'):
                if self.has_key('Transfer-Encoding'):
                    if not self['Transfer-Encoding'] == 'chunked':
                        close_it = 1
                elif self.use_chunked:
                    self['Transfer-Encoding'] = 'chunked'
                    wrap_in_chunking = 1
                else:
                    close_it = 1
        elif self.version is None:
            # Although we don't *really* support http/0.9 (because we'd have to
            # use \r\n as a terminator, and it would just yuck up a lot of stuff)
            # it's very common for developers to not want to type a version number
            # when using telnet to debug a server.
            close_it = 1

        outgoing_header = producers.simple_producer(self.build_reply_header())

        if close_it:
            self['Connection'] = 'close'

        if wrap_in_chunking:
            outgoing_producer = producers.chunked_producer(
                producers.composite_producer(self.outgoing))
            # prepend the header
            outgoing_producer = producers.composite_producer(
                [outgoing_header, outgoing_producer])
        else:
            # prepend the header
            self.outgoing.insert(0, outgoing_header)
            outgoing_producer = producers.composite_producer(self.outgoing)

        # apply a few final transformations to the output
        self.channel.push_with_producer(
            # globbing gives us large packets
            producers.globbing_producer(
                # hooking lets us log the number of bytes sent
                producers.hooked_producer(outgoing_producer, self.log)))

        self.channel.current_request = None

        if close_it:
            self.channel.close_when_done()

    def log_date_string(self, when):
        gmt = time.gmtime(when)
        if time.daylight and gmt[8]:
            tz = time.altzone
        else:
            tz = time.timezone
        if tz > 0:
            neg = 1
        else:
            neg = 0
            tz = -tz
        h, rem = divmod(tz, 3600)
        m, rem = divmod(rem, 60)
        if neg:
            offset = '-%02d%02d' % (h, m)
        else:
            offset = '+%02d%02d' % (h, m)

        return time.strftime('%d/%b/%Y:%H:%M:%S ', gmt) + offset

    def log(self, bytes):
        self.channel.server.logger.log(
            self.channel.addr[0], '%d - - [%s] "%s" %d %d\n' %
            (self.channel.addr[1], self.log_date_string(
                time.time()), self.request, self.reply_code, bytes))

    responses = {
        100: "Continue",
        101: "Switching Protocols",
        200: "OK",
        201: "Created",
        202: "Accepted",
        203: "Non-Authoritative Information",
        204: "No Content",
        205: "Reset Content",
        206: "Partial Content",
        300: "Multiple Choices",
        301: "Moved Permanently",
        302: "Moved Temporarily",
        303: "See Other",
        304: "Not Modified",
        305: "Use Proxy",
        400: "Bad Request",
        401: "Unauthorized",
        402: "Payment Required",
        403: "Forbidden",
        404: "Not Found",
        405: "Method Not Allowed",
        406: "Not Acceptable",
        407: "Proxy Authentication Required",
        408: "Request Time-out",
        409: "Conflict",
        410: "Gone",
        411: "Length Required",
        412: "Precondition Failed",
        413: "Request Entity Too Large",
        414: "Request-URI Too Large",
        415: "Unsupported Media Type",
        500: "Internal Server Error",
        501: "Not Implemented",
        502: "Bad Gateway",
        503: "Service Unavailable",
        504: "Gateway Time-out",
        505: "HTTP Version not supported"
    }

    # Default error message
    DEFAULT_ERROR_MESSAGE = string.join([
        '<head>', '<title>Error response</title>', '</head>', '<body>',
        '<h1>Error response</h1>', '<p>Error code %(code)d.',
        '<p>Message: %(message)s.', '</body>', ''
    ], '\r\n')
Example #35
0
 def getCode(self):
     "pack onto one line; used internally"
     self._code.append('ET')
     return string.join(self._code, ' ')
Example #36
0
 def getCode(self):
     "pack onto one line; used internally"
     return string.join(self._code, ' ')
Example #37
0
    def setPageTransition(self,
                          effectname=None,
                          duration=1,
                          direction=0,
                          dimension='H',
                          motion='I'):
        """PDF allows page transition effects for use when giving
        presentations.  There are six possible effects.  You can
        just guive the effect name, or supply more advanced options
        to refine the way it works.  There are three types of extra
        argument permitted, and here are the allowed values:
            direction_arg = [0,90,180,270]
            dimension_arg = ['H', 'V']
            motion_arg = ['I','O'] (start at inside or outside)
            
        This table says which ones take which arguments:

        PageTransitionEffects = {
            'Split': [direction_arg, motion_arg],
            'Blinds': [dimension_arg],
            'Box': [motion_arg],
            'Wipe' : [direction_arg],
            'Dissolve' : [],
            'Glitter':[direction_arg]
            }
        Have fun!
"""
        if not effectname:
            self._pageTransitionString = ''
            return

        #first check each optional argument has an allowed value
        if direction in [0, 90, 180, 270]:
            direction_arg = '/Di /%d' % direction
        else:
            raise 'PDFError', ' directions allowed are 0,90,180,270'

        if dimension in ['H', 'V']:
            dimension_arg = '/Dm /%s' % dimension
        else:
            raise 'PDFError', 'dimension values allowed are H and V'

        if motion in ['I', 'O']:
            motion_arg = '/M /%s' % motion
        else:
            raise 'PDFError', 'motion values allowed are I and O'

        # this says which effects require which argument types from above
        PageTransitionEffects = {
            'Split': [direction_arg, motion_arg],
            'Blinds': [dimension_arg],
            'Box': [motion_arg],
            'Wipe': [direction_arg],
            'Dissolve': [],
            'Glitter': [direction_arg]
        }

        try:
            args = PageTransitionEffects[effectname]
        except KeyError:
            raise 'PDFError', 'Unknown Effect Name "%s"' % effectname
            self._pageTransitionString = ''
            return

        self._pageTransitionString = (('/Trans <</D %d /S /%s ' %
                                       (duration, effectname)) +
                                      string.join(args, ' ') + ' >>')
Example #38
0
    def explain(self):
        if not self.exists():
            return "building `%s' because it doesn't exist\n" % self

        if self.always_build:
            return "rebuilding `%s' because AlwaysBuild() is specified\n" % self

        old = self.get_stored_info()
        if old is None:
            return None

        old = old.binfo
        old.prepare_dependencies()

        try:
            old_bkids    = old.bsources    + old.bdepends    + old.bimplicit
            old_bkidsigs = old.bsourcesigs + old.bdependsigs + old.bimplicitsigs
        except AttributeError:
            return "Cannot explain why `%s' is being rebuilt: No previous build information found\n" % self

        new = self.get_binfo()

        new_bkids    = new.bsources    + new.bdepends    + new.bimplicit
        new_bkidsigs = new.bsourcesigs + new.bdependsigs + new.bimplicitsigs

        osig = dict(izip(old_bkids, old_bkidsigs))
        nsig = dict(izip(new_bkids, new_bkidsigs))

        # The sources and dependencies we'll want to report are all stored
        # as relative paths to this target's directory, but we want to
        # report them relative to the top-level SConstruct directory,
        # so we only print them after running them through this lambda
        # to turn them into the right relative Node and then return
        # its string.
        def stringify( s, E=self.dir.Entry ) :
            if hasattr( s, 'dir' ) :
                return str(E(s))
            return str(s)

        lines = []

        removed = filter(lambda x, nk=new_bkids: not x in nk, old_bkids)
        if removed:
            removed = map(stringify, removed)
            fmt = "`%s' is no longer a dependency\n"
            lines.extend(map(lambda s, fmt=fmt: fmt % s, removed))

        for k in new_bkids:
            if not k in old_bkids:
                lines.append("`%s' is a new dependency\n" % stringify(k))
            elif k.changed_since_last_build(self, osig[k]):
                lines.append("`%s' changed\n" % stringify(k))

        if len(lines) == 0 and old_bkids != new_bkids:
            lines.append("the dependency order changed:\n" +
                         "%sold: %s\n" % (' '*15, map(stringify, old_bkids)) +
                         "%snew: %s\n" % (' '*15, map(stringify, new_bkids)))

        if len(lines) == 0:
            def fmt_with_title(title, strlines):
                lines = string.split(strlines, '\n')
                sep = '\n' + ' '*(15 + len(title))
                return ' '*15 + title + string.join(lines, sep) + '\n'
            if old.bactsig != new.bactsig:
                if old.bact == new.bact:
                    lines.append("the contents of the build action changed\n" +
                                 fmt_with_title('action: ', new.bact))
                else:
                    lines.append("the build action changed:\n" +
                                 fmt_with_title('old: ', old.bact) +
                                 fmt_with_title('new: ', new.bact))

        if len(lines) == 0:
            return "rebuilding `%s' for unknown reasons\n" % self

        preamble = "rebuilding `%s' because" % self
        if len(lines) == 1:
            return "%s %s"  % (preamble, lines[0])
        else:
            lines = ["%s:\n" % preamble] + lines
            return string.join(lines, ' '*11)
Example #39
0
def gen_handler_imp(addon, md, handler):
    __check_kv = lambda key, val, handler: (key in handler) and (val ==
                                                                 handler[key])
    __request_body_action = lambda action: lambda handler: __check_kv(
        'action_for_request_body', action, handler)
    __read_request_body = __request_body_action('read')
    __discard_request_body = __request_body_action('discard')
    __upstream_has_key = lambda key: lambda handler: use_upstream(
        handler) and (key in handler['upstream'] and handler['upstream'][key])
    __use_parallel = __upstream_has_key('parallel_subrequests')
    __use_sequential = __upstream_has_key('sequential_subrequests')
    __gen_args_decoder = lambda md, handler: tpls['decode_args'].substitute({
        'var_fields':
        merge([
            '    %s %s;' % (type_dict[arg[TYPE]], arg[NAME])
            for arg in handler['args']
        ]),
        'var_flags':
        merge(
            ['    ngx_bool_t has_%s;' % arg[NAME] for arg in handler['args']]),
        'var_arg_t':
        get_args(md, handler),
        'var_decoder':
        get_decoder(md, handler),
        'var_reset':
        merge([
            '    args->%s = %s;' % (arg[NAME], arg[VAL])
            if len(arg) > VAL else FILTER for arg in handler['args']
        ]),
        'var_impl':
        merge([
            tpls['decode_arg'].substitute({
                'var_key': arg[NAME].upper(),
                'var_field': arg[NAME],
                'var_val': val_dict[arg[TYPE]]
            }) for arg in handler['args']
        ]),
    }) if 'args' in handler else FILTER
    __gen_ctx = lambda md, handler: tpls['parallel_ctx'].substitute(
        {'var_ctx_t': get_ctx(md, handler)}) if __use_parallel(
            handler) else substitute_tpls(
                tpls['upstream_ctx'], {
                    'var_peer':
                    '    %s;' % consts['peer_def']
                    if __use_sequential(handler) else FILTER,
                    'var_ctx_t':
                    get_ctx(md, handler)
                }) if use_upstream(handler) else FILTER
    __gen_check_parameter = lambda: tpls['check'].substitute(
        {'var_args': consts['request_args']})
    __gen_post_subrequest_handler = lambda md, handler: FILTER if (
        __use_parallel(handler) or not use_upstream(handler)) else tpls[
            'post_subrequest'].substitute({'var_ctx_t': get_ctx(md, handler)})
    __gen_sr_peer = lambda handler: 'ctx->peer' if __use_sequential(
        handler) else 'peer'
    __gen_sr = lambda prefix, backend_uri, handler: merge([
        merge([
            '    // TODO: initialize the peer here',
            '    %s = NULL;' % consts['peer_def']
        ]) if not __use_sequential(handler) else FILTER,
        '    %sngx_http_gen_subrequest(%s, r, %s,' %
        (prefix, backend_uri, __gen_sr_peer(handler)
         ), '        &ctx->base, __post_subrequest_handler);'
    ])
    __gen_post_body_impl = lambda md, handler: tpls[
        'parallel_post_body'
    ].substitute({
        'var_parallel_call':
        gen_parallel_call(__use_parallel, handler, '    // TODO')
    }) if __use_parallel(handler) else tpls['sequential_post_body'].substitute(
        {
            'var_ctx_t': get_ctx(md, handler),
            'var_sr': __gen_sr('', 'ctx->base.backend_uri', handler)
        }) if use_upstream(
            handler) else '    ngx_http_post_body_handler(r, __post_body_cb);'
    __gen_post_body_handler = lambda md, handler: merge([
        FILTER if use_upstream(handler) else tpls['post_body_cb'].template,
        tpls['post_body_handler'].substitute(
            {'var_impl': __gen_post_body_impl(md, handler)})
    ]) if __read_request_body(handler) else FILTER
    __gen_methods_filter = lambda handler: tpls['http_not_allowed'].substitute(
        {
            'var_cond':
            string.join([
                '!(r->method & NGX_HTTP_%s)' % method.upper()
                for method in handler['methods']
            ], ' && ')
        }) if 'methods' in handler and len(handler['methods']) > 0 else FILTER
    __gen_discard_body = lambda handler: tpls[
        'discard_body'].template if __discard_request_body(handler) else FILTER
    __gen_init_peer = lambda handler: tpls[
        'init_peer'].template if __use_sequential(handler) else FILTER
    __gen_init_ctx_base = lambda handler: '    ctx->base.backend_uri = backend_uri;' if __read_request_body(
        handler) else FILTER
    __gen_init_ctx = lambda handler: '    ctx->peer = ngx_http_first_peer(peers->peer);\n' if __use_sequential(
        handler) else FILTER
    __gen_read_body = lambda handler: tpls['read_body'].substitute({
        'var_rc': ('rc' if __discard_request_body(handler) else 'ngx_int_t rc')
    })
    __gen_first_handler = lambda md, handler: FILTER if __use_parallel(
        handler) else merge([
            'static ngx_int_t __first_%s_handler(%s)' %
            (get_uri(handler), consts['request_args']), '{',
            __gen_methods_filter(handler),
            __gen_discard_body(handler), tpls['call_check'].template,
            __gen_init_peer(handler),
            gen_create_ctx(md, handler),
            __gen_init_ctx_base(handler),
            __gen_init_ctx(handler),
            __gen_read_body(handler)
            if __read_request_body(handler) else __gen_sr(
                'return ', 'backend_uri', handler), '}', ''
        ]) if use_upstream(handler) else FILTER
    __gen_first_loop = lambda md, handler: tpls['first_loop'].substitute(
        {
            'var_ctx_t': get_ctx(md, handler),
            'var_first_handler': '__first_%s_handler' % get_uri(handler)
        })
    __gen_next_loop = lambda handler: tpls['next_loop'].substitute(
        {'var_sr_peer': __gen_sr_peer(handler)}) if __use_sequential(
            handler) else FILTER
    __gen_request_handler = lambda md, handler: merge([
        'ngx_int_t %s_%s_handler(%s)' %
        (md, get_uri(handler), consts['request_args']), '{',
        merge([
            __gen_methods_filter(handler),
            __gen_discard_body(handler),
            tpls['call_check'].template,
            merge(['    %s' % consts['set_ctx'],
                   __gen_read_body(handler)])
            if __read_request_body(handler) else gen_parallel_call(
                __use_parallel, handler, '    return NGX_DONE;'),
        ]) if __use_parallel(handler) else merge([
            __gen_first_loop(md, handler),
            __gen_next_loop(handler), tpls['final_loop'].template
        ]) if use_upstream(handler) else merge([
            __gen_methods_filter(handler),
            __gen_discard_body(handler), tpls['call_check'].template,
            __gen_read_body(handler) if __read_request_body(handler) else tpls[
                'default_handler'].template
        ]), '}'
    ])
    write_file(
        '%s/%s_%s_handler.c' % (addon, md, get_uri(handler)),
        merge([
            '#include "%s_handler.h"' % md, '',
            __gen_args_decoder(md, handler),
            __gen_ctx(md, handler),
            __gen_check_parameter(),
            gen_parallel_imp(__use_parallel, md, handler),
            __gen_post_subrequest_handler(md, handler),
            __gen_post_body_handler(md, handler),
            __gen_first_handler(md, handler),
            __gen_request_handler(md, handler)
        ]))
Example #40
0
 def fmt_with_title(title, strlines):
     lines = string.split(strlines, '\n')
     sep = '\n' + ' '*(15 + len(title))
     return ' '*15 + title + string.join(lines, sep) + '\n'
Example #41
0
    def __updatewithQueryStatus(self):
        """ query device to update information
        """
        try:
           fwv=self.drobo.GetSubPageFirmware()
        except:
           self.statusBar().showMessage( 'bad poll: %d.. need to restart' % self.updates )
           return

        settings=self.drobo.GetSubPageSettings()
        self.Device.id.setText(  self.drobo.GetCharDev() + ' ' + settings[2] + ' firmware: ' + fwv[7] )

        self.Device.id.setToolTip(
           "Firmware build: " + str(fwv[0]) + '.' + str(fwv[1]) + '.' + str(fwv[2]) + "\n Features: " + string.join(fwv[8],"\n") )
        
        self.s=self.drobo.GetSubPageSlotInfo()

        luninfo=self.drobo.GetSubPageLUNs()

        luntooltip="luns, count: " + str(len(luninfo)) + "\n"
        for l in luninfo:
	   luntooltip = luntooltip + "lun id: " + str(l[0]) + " used: " +  \
                   _toGB(l[2]) + " total: " + _toGB(l[1]) 
           if 'SUPPORTS_NEW_LUNINFO2' in self.drobo.features :
              luntooltip = luntooltip + " scheme: " + str(l[3]) + " type: " + str(l[4]) 
           luntooltip = luntooltip + "\n"

        i=0
        mnw=0
        while i < self.drobo.SlotCount() :
          self.Device.slot[i][0].setText(_setDiskLabel(self.s[i][5],self.s[i][1]))
          w= self.Device.slot[i][0].width()
          if w > mnw:
               mnw=w
          self.Device.slot[i][0].setToolTip(luntooltip)
	  i=i+1

        c=self.drobo.GetSubPageConfig()
        self.Format.lunsize =  _toTiB(c[2])

        c=self.drobo.GetSubPageCapacity()
        if c[2] > 0:
           self.Device.fullbar.setValue( c[1]*100/c[2] )
           self.Device.fullbar.setToolTip(  string.join(self.drobo.DiscoverMounts(),',') +
	    "\nused: " + _toGB(c[1]) + ' free: ' + _toGB(c[0]) + ' Total: ' + _toGB(c[2]) + ' GB, update# ' + str(self.updates) )
	#print self.statusmsg
        #self.__StatusBar_space()
        self.statusBar().showMessage( self.statusmsg )
        ss = self.drobo.GetSubPageStatus()
        self.statusmsg = 'Status: ' + str(ss[0]) + ' update: ' + str(self.updates)

        if self.Format.inProgress and ( self.fmt_process.poll() != None) :
               # reset to normal state...
               print('it took: %d updates to run' % (self.updates - self.Format.startupdate ))
               self.Format.inProgress=0
               normal = self.Tools.Updatebutton.palette().color( QtGui.QPalette.Button )
               self.Format.Formatbutton.palette().setColor( QtGui.QPalette.Button, QtCore.Qt.blue )
               self.Format.ext3.setChecked(0)
               self.Format.ntfs.setChecked(0)
               self.Format.msdos.setChecked(0)
               self.Format.Formatbutton.setText('Format Done!')
               self.Format.connect(self.Format.Formatbutton, \
                     QtCore.SIGNAL('clicked()'), self.FormatLUN)
Example #42
0
 def escape_entities(m):
     out = []
     for char in m.group():
         out.append("&#%d;" % ord(char))
     return string.join(out, "")
def mapQuotaEntries(old):
    new = []
    for i in old:
        new.append(string.join(i, ' '))
    return new
Example #44
0
#!/usr/bin/python
# email: [email protected]
import sys
import platform
import os.path
import re
import datetime
import string
import json

TYPE = 0
NAME = 1
VAL = 2

FILTER = '@null_string_place_holder'
join_lines = lambda lines, dim: string.join(
    filter(lambda item: -1 == item.find(FILTER), lines), dim)
merge = lambda lines: join_lines(lines, '\n')


def manual():
    print """
    usage:
        python ngx_wizard.py [conf]
    sample:
        python ngx_wizard.py ngx_wizard.json
        """


def write_file(path, data):
    with open(path, 'w') as f:
        f.writelines(data)
def loadnetCDF_data(filename, mult=False, *args, **kwargs):
    '''
    Open one or many netCDF data files and load them into a python numpy array.

    Input:
    filename = netCDF filename or a string with wildcards that would include
               all desired netCDF files if used for an 'ls' command.  NetCDF4
               files are not supported. Ex: see__L3_*.ncdf
    mult = True for multiple files, False for single (default is False)

    Output:
    out   = a dict containing the data in np.arrays, the dict keys are
            specified by the header data line
    units = a dict containing the units for each data key
    desc  = a dict containing the descriptions for each data key
    '''

    import netCDF4 as cdf
    func_name = string.join([module_name, "loadnetCDF_data"], " ")

    # Open the file
    f = list()

    if mult:
        try:
            temp = cdf.MFDataset(filename)
            f.append(temp)
        except:
            # Probably has the wrong file format.  You'll need to cycle through
            # these individually now.
            import subprocess

            command = "ls %s" % (filename)
            pipe = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE)
            names = pipe.stdout.readlines()

            for name in names:
                print "Opening:", name[0:-1]
                f.append(cdf.Dataset(name[0:-1]))
    else:
        f.append(cdf.Dataset(filename))

    # Load the variables into a standard numpy array and save the description
    # as attributes
    out = dict()
    units = dict()
    desc = dict()
    unit_warning = False
    desc_warning = False

    for fdat in f:
        slist = []
        for fkeys in fdat.variables.keys():
            s = fdat.variables[fkeys].shape

            if(len(s) > 0):
                slist.append(s[0])
        dim1 = np.max(slist)

        for fkeys in fdat.variables.keys():
            # Ensure the data will be stored as an array
            if len(fdat.variables[fkeys].shape) < 1:
                farray = [fdat.variables[fkeys][0] for i in range(dim1)]
            else:
                farray = fdat.variables[fkeys][:]

            if out.has_key(fkeys):
                out[fkeys] = np.append(out[fkeys], farray)
            else:
                out[fkeys] = np.array(farray)

            try:
                if units.has_key(fkeys):
                    units[fkeys] = np.append(units[fkeys],
                                             fdat.variables[fkeys].Units)
                else:
                    units[fkeys] = fdat.variables[fkeys].Units
            except AttributeError:
                if not unit_warning:
                    print module_name, "ADVISEMENT: no unit attribute"
                    unit_warning = True
                
            try:
                if desc.has_key(fkeys):
                    desc[fkeys] = np.append(desc[fkeys],
                                            fdat.variables[fkeys].Description)
                else:
                    desc[fkeys] = fdat.variables[fkeys].Description
            except AttributeError:
                if not desc_warning:
                    print module_name, "ADVISEMENT: no description attribute"
                    desc_warning = True

        fdat.close()
    return(out, units, desc)
Example #46
0
    def __init__(self, reference, resolution="daily", client=None, drive_data_id="1etaxbcHUa8YKiNw0tEkIyMtnC8DShRxQ"):
        if resolution not in self.RESOLUTIONS:
            raise ValueError, "{} not in resolution valid values: {}".format(resolution, string.join(self.RESOLUTIONS, ", "))
        # authenticate user & start Google Drive client
        if not client:
            self.client = get_client()
        else:
            self.client = client

        # initialize object attributes
        self.ref_symbol = reference
        self.resolution = resolution
        self.DATA_ID = drive_data_id
        self.PICKLE = "gdrive-{}.p".format(self.DATA_ID)
        # initialize files list from Google Drive
        self.files = {}
        for file in self.client.ListFile({"q": "'{}' in parents".format(self.DATA_ID)}).GetList():
            filename = file.get("title")
            category, resolution, symbol = self._parse_filename(filename)
            if resolution != self.resolution: continue
            self.files[symbol] = dict(category=category, id=file.get("id"))

        if self.ref_symbol not in self.files:
            raise ValueError, "Symbol '{}' not found.".format(self.ref_symbol)

        # download tables
        if exist(self.PICKLE):
            self.all_dataframes = pk.load(open(self.PICKLE, "rb"))
        else:
            self.all_dataframes = self._download_tables()
            pk.dump((self.all_dataframes), open(self.PICKLE, "wb"))

        # initialize joint dataframe
        self.joint_dataframe = None
def loadASCII_index_profile(filename, miss=None, fill=np.nan, *args, **kwargs):
    '''
    Open an ascii data file and load it into a python numpy array.  Assumes
    this file is seperated into index blocks, which should be maintained.

    Input:
    filename = CINDI data file name
    miss     = string or list denoting missing value options (default=None)
    fill     = fill value (default = NaN)

    Output:
    header  = a list containing the header strings without the '#'
    out     = a dict containing the data in np.arrays, the dict keys are
              specified by the header data line
    nblocks = number of indexed data blocks
    '''

    func_name = string.join([module_name, "loadASCII_data_header"])

    #-----------------------------------------------------------------------
    # Test to ensure the file is small enough to read in.  Python can only
    # allocate 2GB of data.  If you load something larger, python will crash

    fsize = path.getsize(filename)
    header = list()
    out = dict()
    nblocks = 0

    if(fsize > 2.0e9):
        print func_name, "WARNING: File size [", (fsize * 1e-9), "GB > 2 GB]"
        return(header, out, nblocks)
    elif(fsize == 0):
        print func_name, "WARNING: empty file [", filename, "]"
        return(header, out, nblocks)

    #----------------------------------------------
    # Open the datafile and read the header rows

    f = open(filename, "r")

    if not f:
        print func_name, "ERROR: unable to open input file [", filename, "]"
        return header, out, nblocks

    line = f.readline()
    check = 0

    while line.find("#") >= 0:
        hline = string.strip(line.replace("#", ""))
        line = f.readline()
        check += 1

        if(len(hline) > 0):
            header.append(hline)

    if(check > 0):
        hline = hline.split()
    else:
        print func_name, "ERROR: no header in this file [", filename, "]"
        return(header, out, nblocks)

    #-------------------------------------------------
    # Cycle through the data rows, identifying blocks

    while len(line) > 0:
        if (len(line) == 1 and line.find("\n") == 0):
            # A new block has been found.  Only incriment if data has been read
            if len(out) > 0:
                nblocks += 1
            print "TEST: at block", nblocks, len(line)

            # Cycle to new dataline
            while len(line) == 1 and line.find("\n") == 0:
                line = f.readline()

        # Load the dataline into the output structure
        dline = line.split()

        for num,name in enumerate(hline):
            if out.has_key(name):
                if len(out[name]) < nblocks:
                    out[name][nblocks].append(dline[num])
                else:
                    out[name].append([dline[num]])
            else:
                out[name] = [[dline[num]]]

    return(header, out, nblocks)
Example #48
0
import sys
import os
import string

file = open("summary.txt")
lines = file.readlines()
f = open("temp1.txt", "w")
for line in lines:
    #line.split('\t')
    term = line.split('\t')
    t = term[0].split('_')
    if sys.argv[2] in t:
        term[0] = t[1] + " " + t[2] + " " + t[3]
        f.write(string.join(term))

f = open("temp1.txt")
filename = "result_" + sys.argv[2] + "_" + sys.argv[3] + ".dat"
f2 = open(filename, "w+")
lines = f.readlines()
g_counter = 1
g_newline = ""
f2.write("type  noop deadline cfq\n")
for line in lines:
    term = line.split(" ")
    if sys.argv[3] in term:
        if g_counter == 1:
            g_newline += term[0]
            g_newline += " "
            g_newline += term[4].split("=")[1].split("K")[0]
            g_counter += 1
            continue
Example #49
0
    def initialize(self):
        self.__paths = []
        if os.environ.has_key("DISTUTILS_USE_SDK") and os.environ.has_key(
                "MSSdk") and self.find_exe("cl.exe"):
            # Assume that the SDK set up everything alright; don't try to be
            # smarter
            self.cc = "cl.exe"
            self.linker = "link.exe"
            self.lib = "lib.exe"
            self.rc = "rc.exe"
            self.mc = "mc.exe"
        else:
            self.__paths = self.get_msvc_paths("path")

            if len(self.__paths) == 0:
                raise DistutilsPlatformError, \
                      ("Python was built with %s, "
                       "and extensions need to be built with the same "
                       "version of the compiler, but it isn't installed." % self.__product)

            self.cc = self.find_exe("cl.exe")
            self.linker = self.find_exe("link.exe")
            self.lib = self.find_exe("lib.exe")
            self.rc = self.find_exe("rc.exe")  # resource compiler
            self.mc = self.find_exe("mc.exe")  # message compiler
            self.set_path_env_var('lib')
            self.set_path_env_var('include')

        # extend the MSVC path with the current path
        try:
            for p in string.split(os.environ['path'], ';'):
                self.__paths.append(p)
        except KeyError:
            pass
        self.__paths = normalize_and_reduce_paths(self.__paths)
        os.environ['path'] = string.join(self.__paths, ';')

        self.preprocess_options = None
        if self.__arch == "Intel":
            self.compile_options = [
                '/nologo', '/Ox', '/MD', '/W3', '/GX', '/DNDEBUG'
            ]
            self.compile_options_debug = [
                '/nologo', '/Od', '/MDd', '/W3', '/GX', '/Z7', '/D_DEBUG'
            ]
        else:
            # Win64
            self.compile_options = [
                '/nologo', '/Ox', '/MD', '/W3', '/GS-', '/DNDEBUG'
            ]
            self.compile_options_debug = [
                '/nologo', '/Od', '/MDd', '/W3', '/GS-', '/Z7', '/D_DEBUG'
            ]

        self.ldflags_shared = ['/DLL', '/nologo', '/INCREMENTAL:NO']
        if self.__version >= 7:
            self.ldflags_shared_debug = [
                '/DLL', '/nologo', '/INCREMENTAL:no', '/DEBUG'
            ]
        else:
            self.ldflags_shared_debug = [
                '/DLL', '/nologo', '/INCREMENTAL:no', '/pdb:None', '/DEBUG'
            ]
        self.ldflags_static = ['/nologo']

        self.initialized = True
def loadASCII_data_header(filename, miss=None, fill=np.nan, *args, **kwargs):
    '''
    Open an ascii data file and load it into a python numpy array.

    Input:
    filename = CINDI data file name
    miss     = string or list denoting missing value options (default=None)
    fill     = fill value (default = NaN)

    Output:
    header = a list containing the header strings without the '#'
    out    = a dict containing the data in np.arrays, the dict keys are
             specified by the header data line
    '''

    func_name = string.join([module_name, "loadASCII_data_header"], " ")

    #-----------------------------------------------------------------------
    # Test to ensure the file is small enough to read in.  Python can only
    # allocate 2GB of data.  If you load something larger, python will crash

    fsize  = path.getsize(filename)
    header = list()
    out    = dict()

    if(fsize > 2.0e9):
        print func_name, "WARNING: File size [", (fsize * 1e-9), "GB > 2 GB]"
        return(header, out)
    elif(fsize == 0):
        print func_name, "WARNING: empty file [", filename, "]"
        return(header, out)

    #----------------------------------------------
    # Open the datafile and read the header rows

    f = open(filename, "r")

    if not f:
        print func_name, "ERROR: unable to open input file [", filename, "]"
        return header, out

    line   = f.readline()
    check  = 0

    while line.find("#") >= 0:
        hline  = string.strip(line.replace("#", ""))
        line   = f.readline()
        check += 1

        if(len(hline) > 0):
            header.append(hline)

    if(check > 0):
        hline = hline.split()
    else:
        print func_name, "ERROR: no header in this file [", filename, "]"
        return(header, out)

    #-------------------------------------------
    # Open the datafile and read the data rows

    temp = np.genfromtxt(filename, comments="#", missing_values=miss,
                         filling_values=fill)

    if len(temp) > 0:
        #------------------------------------------
        # Create the output dictionary

        for num,name in enumerate(hline):
            out[name] = temp[:,num]

    del temp
    return(header, out)
Example #51
0
def elf_format(dict):
    return struct.pack(string.join(['<'] + [e[1] for e in dict[FMT]], ''),
                       *tuple([dict[e[0]] for e in dict[FMT]]))
def loadASCII_data_hline(filename, hlines, miss=None, fill=np.nan, *args,
                         **kwargs):
    '''
    Open an ascii data file and load it into a python numpy array.  File
    header may be any number of lines and does not have to be preceeded by a
    particular character.

    Input:
    filename = CINDI data file name
    hlines   = number of lines in header
    miss     = string or list denoting missing value options (default=None)
    fill     = fill value (default = NaN)

    Output:
    header = a list containing all specified header lines
    out = a dict containing the data in np.arrays, the dict keys are
          specified by the header data line
    '''

    func_name = string.join([module_name, "loadASCII_data_hline"])

    #-----------------------------------------------------------------------
    # Test to ensure the file is small enough to read in.  Python can only
    # allocate 2GB of data.  If you load something larger, python will crash

    fsize = path.getsize(filename)
    header = list()
    out = dict()

    if(fsize > 2.0e9):
        print func_name, "WARNING: File size [", (fsize * 1e-9), "GB > 2 GB]"
        return hearder, out
    elif(fsize == 0):
        print func_name, "WARNING: empty file [", filename, "]"
        return(header, out)

    #----------------------------------------------
    # Open the datafile and read the header rows

    f = open(filename, "r")

    if not f:
        print func_name, "ERROR: unable to open input file [", filename, "]"
        return out

    for h in range(hlines):
        header.append(f.readline())

    #-------------------------------------------
    # Open the datafile and read the data rows

    temp = np.genfromtxt(filename, skip_header=hlines, missing_values=miss,
                         filling_values=fill)

    if len(temp) > 0:
        #---------------------------------------------------------------------
        # Create the output dictionary, removing the point sign from any keys

        for num,name in enumerate(header[-1].split()):
            name = name.replace("#", "")

            if len(name) > 0:
                out[name] = temp[:,num]

    del temp
    return header, out
Example #53
0
    def execute(self, target, source, env, executor=None):
        """Execute a command action.

        This will handle lists of commands as well as individual commands,
        because construction variable substitution may turn a single
        "command" into a list.  This means that this class can actually
        handle lists of commands, even though that's not how we use it
        externally.
        """
        escape_list = SCons.Subst.escape_list
        flatten_sequence = SCons.Util.flatten_sequence

        try:
            shell = env['SHELL']
        except KeyError:
            raise SCons.Errors.UserError(
                'Missing SHELL construction variable.')

        try:
            spawn = env['SPAWN']
        except KeyError:
            raise SCons.Errors.UserError(
                'Missing SPAWN construction variable.')
        else:
            if is_String(spawn):
                spawn = env.subst(spawn, raw=1, conv=lambda x: x)

        escape = env.get('ESCAPE', lambda x: x)

        ENV = get_default_ENV(env)

        # Ensure that the ENV values are all strings:
        for key, value in ENV.items():
            if not is_String(value):
                if is_List(value):
                    # If the value is a list, then we assume it is a
                    # path list, because that's a pretty common list-like
                    # value to stick in an environment variable:
                    value = flatten_sequence(value)
                    ENV[key] = string.join(map(str, value), os.pathsep)
                else:
                    # If it isn't a string or a list, then we just coerce
                    # it to a string, which is the proper way to handle
                    # Dir and File instances and will produce something
                    # reasonable for just about everything else:
                    ENV[key] = str(value)

        if executor:
            target = executor.get_all_targets()
            source = executor.get_all_sources()
        cmd_list, ignore, silent = self.process(target, map(rfile, source),
                                                env, executor)

        # Use len() to filter out any "command" that's zero-length.
        for cmd_line in filter(len, cmd_list):
            # Escape the command line for the interpreter we are using.
            cmd_line = escape_list(cmd_line, escape)
            result = spawn(shell, escape, cmd_line[0], cmd_line, ENV)
            if not ignore and result:
                msg = "Error %s" % result
                return SCons.Errors.BuildError(errstr=msg,
                                               status=result,
                                               action=self,
                                               command=cmd_line)
        return 0
Example #54
0
def parse_generic(data, fmt):
    tmp = struct.unpack(string.join(['<'] + [e[1] for e in fmt], ''), data)
    tmp = dict((fmt[j][0], tmp[j]) for j in range(len(fmt)))
    tmp[FMT] = fmt
    return tmp
Example #55
0
def _subproc(env, cmd, error='ignore', **kw):
    """Do common setup for a subprocess.Popen() call"""
    # allow std{in,out,err} to be "'devnull'"
    io = kw.get('stdin')
    if is_String(io) and io == 'devnull':
        kw['stdin'] = open(os.devnull)
    io = kw.get('stdout')
    if is_String(io) and io == 'devnull':
        kw['stdout'] = open(os.devnull, 'w')
    io = kw.get('stderr')
    if is_String(io) and io == 'devnull':
        kw['stderr'] = open(os.devnull, 'w')

    # Figure out what shell environment to use
    ENV = kw.get('env', None)
    if ENV is None: ENV = get_default_ENV(env)

    # Ensure that the ENV values are all strings:
    new_env = {}
    for key, value in ENV.items():
        if is_List(value):
            # If the value is a list, then we assume it is a path list,
            # because that's a pretty common list-like value to stick
            # in an environment variable:
            value = SCons.Util.flatten_sequence(value)
            new_env[key] = string.join(map(str, value), os.pathsep)
        else:
            # It's either a string or something else.  If it's a string,
            # we still want to call str() because it might be a *Unicode*
            # string, which makes subprocess.Popen() gag.  If it isn't a
            # string or a list, then we just coerce it to a string, which
            # is the proper way to handle Dir and File instances and will
            # produce something reasonable for just about everything else:
            new_env[key] = str(value)
    kw['env'] = new_env

    try:
        #FUTURE return subprocess.Popen(cmd, **kw)
        return subprocess.Popen(*(cmd, ), **kw)
    except EnvironmentError as e:
        if error == 'raise': raise

        # return a dummy Popen instance that only returns error
        class dummyPopen:
            def __init__(self, e):
                self.exception = e

            def communicate(self):
                return ('', '')

            def wait(self):
                return -self.exception.errno

            stdin = None

            class f:
                def read(self):
                    return ''

                def readline(self):
                    return ''

            stdout = stderr = f()

        return dummyPopen(e)
Example #56
0
def repr_generic(dict):
    return string.join([('%s: %s' % (e[0], e[2])) % (dict[e[0]])
                        for e in dict[FMT]], ' ')
Example #57
0
 def __str__(self):
     return string.join(map(str, self.list), '\n')
Example #58
0
 def __str__(self):
     if is_List(self.cmd_list):
         return string.join(map(str, self.cmd_list), ' ')
     return str(self.cmd_list)
Example #59
0
 def genstring(self, target, source, env):
     return string.join(
         map(lambda a, t=target, s=source, e=env: a.genstring(t, s, e),
             self.list), '\n')
Example #60
0
    def __call__(self,
                 target,
                 source,
                 env,
                 exitstatfunc=_null,
                 presub=_null,
                 show=_null,
                 execute=_null,
                 chdir=_null,
                 executor=None):
        if not is_List(target):
            target = [target]
        if not is_List(source):
            source = [source]

        if presub is _null:
            presub = self.presub
            if presub is _null:
                presub = print_actions_presub
        if exitstatfunc is _null: exitstatfunc = self.exitstatfunc
        if show is _null: show = print_actions
        if execute is _null: execute = execute_actions
        if chdir is _null: chdir = self.chdir
        save_cwd = None
        if chdir:
            save_cwd = os.getcwd()
            try:
                chdir = str(chdir.abspath)
            except AttributeError:
                if not is_String(chdir):
                    if executor:
                        chdir = str(executor.batches[0].targets[0].dir)
                    else:
                        chdir = str(target[0].dir)
        if presub:
            if executor:
                target = executor.get_all_targets()
                source = executor.get_all_sources()
            t = string.join(map(str, target), ' and ')
            l = string.join(self.presub_lines(env), '\n  ')
            out = "Building %s with action:\n  %s\n" % (t, l)
            sys.stdout.write(out)
        cmd = None
        if show and self.strfunction:
            if executor:
                target = executor.get_all_targets()
                source = executor.get_all_sources()
            try:
                cmd = self.strfunction(target, source, env, executor)
            except TypeError:
                cmd = self.strfunction(target, source, env)
            if cmd:
                if chdir:
                    cmd = ('os.chdir(%s)\n' % repr(chdir)) + cmd
                try:
                    get = env.get
                except AttributeError:
                    print_func = self.print_cmd_line
                else:
                    print_func = get('PRINT_CMD_LINE_FUNC')
                    if not print_func:
                        print_func = self.print_cmd_line
                print_func(cmd, target, source, env)
        stat = 0
        if execute:
            if chdir:
                os.chdir(chdir)
            try:
                stat = self.execute(target, source, env, executor=executor)
                if isinstance(stat, SCons.Errors.BuildError):
                    s = exitstatfunc(stat.status)
                    if s:
                        stat.status = s
                    else:
                        stat = s
                else:
                    stat = exitstatfunc(stat)
            finally:
                if save_cwd:
                    os.chdir(save_cwd)
        if cmd and save_cwd:
            print_func('os.chdir(%s)' % repr(save_cwd), target, source, env)

        return stat