Python Parser.__init__方法代码示例

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import __init__ [as 别名]
	def __init__(self, *args, **kwds): #blast, allHits=False, evalue=1e-10, taxFilter=None, taxFilterType=0):
		"""Intialise a BLAST XML parser.
		"""
		#Initialize Parser super class
		Parser.__init__(self, *args, **kwds)

		#Build iter to loop over XML
		self.context = iter(ET.iterparse(self.infile, events=("start", "end")))
		#Boolean to allow hits to be returned
		self.runHSP = True
		#Save the current contig, or queryID 
		self.queryID = None
		#The number of Hits that have been processed
		self.numHits = 0
		#File came form RAPSearch2?
		self.rapsearch = kwds.get("rapsearch", False)

		#Start initial parsing
		event, root = self.context.next()

		if root.tag not in ["BlastOutput", "Output"]:
			raise RuntimeError("This is not a valid BLAST XML file or RAPSearch2 XML file")
		elif root.tag == "Output":
			self.rapsearch = True

		#Start looping over data until we get to first iteration
		for event, elem in self.context:
			if event == "start" and elem.tag == "Iteration":
				break 

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import __init__ [as 别名]
 def __init__(self, rule, parent):
     Parser.__init__(self, rule, parent)
     self.parsers = []  # parsers constructed for each of rule.items
     self.active = None  # main active parser (top of self.parsers)
     self.pos = 0  # position in self.rule.items
     self.tokens = []  # all tokens we have ever seen
     self.backlog = []  # [(pos,#tokens consumed,donetext)]

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import __init__ [as 别名]
 def __init__(self, downloader=None):
     '''Initialize the character parser.'''
     log.debug("Creating character parser with downloader " + str(downloader))
     Parser.__init__(self, downloader=downloader)
     self._gp = GuildParser(downloader=self._downloader)
     self._ip = ItemParser(downloader=self._downloader)
     self._ap = AchievementParser(downloader=self._downloader)
     Base.metadata.create_all(Database.engine)

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import __init__ [as 别名]
 def __init__(self,rule,parent):
   Parser.__init__(self, rule, parent)
   self.parsers = []   # parsers constructed for each of rule.items
   self.active = None  # main active parser (top of self.parsers)
   self.pos = 0        # position in self.rule.items
   self.or_parser = None   # In use if we split into an OrParser
   self.fakePrefix = ''    # Text to prepend to the next parse()'s output
   self.justSplit = False  # True for left branch immediately after a split

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import __init__ [as 别名]
 def __init__(self, stringToScan, scholarshipPackageId='0'):
     self.stringToScan = stringToScan
     Parser.__init__(self, self.stringToScan, '\s[^$\d\.]?[1234]\.\d+')
     self.resultList = []
     self.attributeId = '1'
     self.gpa = ''
     self.logicGroup = '0'
     self.requirementTypeCode = '>='
     self.scholarshipPackageId = scholarshipPackageId

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import __init__ [as 别名]
    def __init__(self):
        Parser.__init__(self)

        self.is_gnome = None

        # Parser context
        self.commit = None
        self.branch = None
        self.branches = []

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import __init__ [as 别名]
    def __init__(self):
        Parser.__init__(self)

        self.root_path = ''
        
        # Parser context
        self.state = SVNParser.COMMIT
        self.commit = None
        self.msg_lines = 0

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import __init__ [as 别名]
 def __init__(self,rule,parent):
   Parser.__init__(self, rule, parent)
   self.parsers = []
   self.displays = {}
   for item in rule.items:
     parser = MakeParser(item, self)
     self.parsers.append(parser)
     self.displays[parser] = ''
   self.lastHappyEnding = ''
   self.unconfirmed = ''
   self.debug = []

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import __init__ [as 别名]
 def __init__(self,rule,parent):
   Parser.__init__(self, rule, parent)
   self.parsers = []   # parsers constructed for each of rule.items
   self.active = None  # main active parser (top of self.parsers)
   self.pos = 0        # position in self.rule.items
   self.unconfirmed = '' # text we have output from active since it started
                         # or was done
   self.activeused = False # have we ever previously returned text from active
   self.everdone = []  # true for each position that was ever done
   self.tokenssincedone = [] # each token observed since the last done state
   self.everevil = False # have we ever emit stuff from a parser that went evil
   self.debug = []

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import __init__ [as 别名]
 def __init__(self,rule,parent):
   Parser.__init__(self, rule, parent)
   if isinstance(self.rule.items, str):
     self.rule.items = [self.rule.items]
   if len(self.rule.items) != 1:
     raise Exception("TerminalParser's Terminal must have one rule.item; instead got '%s'" % self.rule.items)
   self.tname = self.rule.items[0]
   self.value = None
   self.parsedtodone = False # Have we already parsed the token?
                             # Separate from done because we might be optional
   self.displayValue = False
   if hasattr(self.rule, 'displayValue') and self.rule.displayValue:
     self.displayValue = self.rule.displayValue

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import __init__ [as 别名]
    def __init__(self):
        Parser.__init__(self)

        self.root_path = ""
        self.lines = {}

        # Parser context
        self.file = None
        self.file_added_on_branch = None
        self.commit = None
        self.branches = None
        self.tags = None
        self.rev_separator = None
        self.file_separator = None

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import __init__ [as 别名]
  def __init__(self,rule,parent):
    Parser.__init__(self, rule, parent)
    self.parsers = []   # parsers constructed for each of rule.items
    self.active = None  # main active parser (top of self.parsers)
    self.pos = 0        # position in self.rule.items

    # The not-done tokens that immediately followed done-tokens by the last
    # parser that accepted any tokens.  If the next parser that accepts a
    # token's very first token is in this set, then this SeqParser was used
    # erroneously!
    self.firstnotdonetokens = set()
    self.everdone = []  # True for each position that was ever done
    self.tokenssincedone = []   # each token observed since the last done state
    self.display = ''   # buffer of text to emit at the next emittable state
    self.lastdonetext = ''    # text from the last time we were done

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import __init__ [as 别名]
 def __init__(self,rule,parent):
   Parser.__init__(self, rule, parent)
   self.firstparse = True
   msg = self.rule.msg.split('%s')
   self.msg_start = msg[0]
   self.msg_middle = self.rule.msg.count('%s') > 0
   self.msg_end = ''
   if len(msg) == 2:
     self.msg_end = msg[1]
   elif len(msg) > 2:
     raise Exception("DispParser %s found inappropriate msg '%s'" % (self.name, msg))
   if len(self.rule.items) != 1:
     raise Exception("DispParser %s must have 1 item" % self.name)
   self.parser = MakeParser(self.rule.items[0], self)
   self.bad = self.parser.bad
   self.done = self.parser.done
   self.name = self.name % self.parser.name
   self.debug = []

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import __init__ [as 别名]
    def __init__(self, param):
        """
        generated source for method __init__
        """
        Parser.__init__(self)

        self.param = param
        self.differ = Differential(self.param.Seed)

        self.predict = []
        self.interval = None

        # Kalman Filter params
        self.P = 100

        # estimation error covariance (over all time instance)
        self.Q = 1000

        # process noise synthetic data
        self.R = 1000000

        # measurement noise optimal for alpha = 1, synthetic data
        self.K = 0

        # kalman gain
        # PID control params - default
        self.Cp = 0.9  # proportional gain, to keep output proportional to current error
        self.Ci = 0.1  # integral gain, to eliminate offset
        self.Cd = 0.0  # derivative gain, to ensure stability - prevent large error in future

        # fixed internally
        self.theta = 1  # magnitude of changes
        self.xi = 0.2  # gamma (10%)
        self.minIntvl = 1  # make sure the interval is greater than 1

        self.windowPID = 5  # I(integration) window
        self.ratioM = 0.2  # sampling rate

        #
        self.isSampling = False

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import __init__ [as 别名]
 def __init__(self, html):
   Parser.__init__(self, html)
   self.getPlayerNames()