Python record.Record类代码示例

def main():
    arguements = docopt(
        data_io.set_up_doc(__doc__),
        version='0.1'
    )

    record = Record(debug=arguements['--debug'])
    if arguements['<data>']:
        # translation
        from_lang, to_lang, data = _extract(arguements)

        # translate data
        translator = Translator(from_lang, to_lang, data,
                                debug=arguements['--debug'])
        # result is a dictionary contains decoded infomation of the
        # trnaslation.
        result = translator.translate()
        translator.display_result(result)
        # add record
        record.add(from_lang, to_lang,
                   data, result)

    elif arguements['--record']:
        # display record
        record.display()
    else:
        raise Exception('No Implemented Yet.')

    def load(self, ids, modified=False):
        if not ids:
            return True

        if len(ids) >= 1:
            self.lock_signal = True

        new_records = []
        for id in ids:
            new_record = self.get(id)
            if not new_record:
                new_record = Record(self.model_name, id, group=self)
                self.append(new_record)
                new_record.signal_connect(self, "record-changed", self._record_changed)
                new_record.signal_connect(self, "record-modified", self._record_modified)
            new_records.append(new_record)

        # Remove previously removed or deleted records
        for record in self.record_removed[:]:
            if record.id in ids:
                self.record_removed.remove(record)
        for record in self.record_deleted[:]:
            if record.id in ids:
                self.record_deleted.remove(record)

        if self.lock_signal:
            self.lock_signal = False
            self.signal("group-cleared")

        if new_records and modified:
            new_records[0].signal("record-modified")
            new_records[0].signal("record-changed")

        self.current_idx = 0
        return True

    def __init__(self, year, lines):
        """
        Constructor
        @param year - the year to tag the job with
        @param lines - the strings making up this record
        """
        Record.__init__(self, year, lines)

        pat = "Image size of job updated: (?P<imageSize>[\d]+)"
        
        ## size of the image for this job
        self.imageSize = int(self.extract(pat,lines[0], "imageSize"))
        
        ## memory used by this job in MB
        self.memoryUsageMb = 0
        ## resident size of this job in KB
        self.residentSetSizeKb = 0
        if len(lines) == 3:
            pat = "(?P<memoryUsage>[\d]+)"
            self.memoryUsageMb = int(self.extract(pat,lines[1],"memoryUsage"))
            pat = "(?P<residentSetSize>[\d]+)"
            self.residentSetSizeKb = int(self.extract(pat,lines[2],"residentSetSize"))
        else:
            pat = "(?P<residentSetSize>[\d]+)"
            self.residentSetSizeKb = int(self.extract(pat,lines[1],"residentSetSize"))

    def __init__(self, year, lines):
        """
        Constructor
        @param year - the year to tag the job with
        @param lines - the strings making up this record
        """
        Record.__init__(self, year, lines)

        
        pat = r"Error from (?P<slot>[\w][email protected][\d][email protected][\w\-.]+): (?P<reason>.+?)($)"
        ## the slot the job was in at the time of this exception
        self.slot = None
        ## the reason for the exception
        self.reason = None
        ## the number of bytes sent
        self.runBytesSent = None
        ## the number of bytes received
        self.runBytesReceived = None
        if re.search(pat,lines[1]) is not None:
            values = self.extractValues(pat,lines[1])
            self.slot = values["slot"]
            self.reason = values["reason"].strip()
            pat = r"(?P<bytes>\d+) "
            self.runBytesSent = int(self.extract(pat,lines[2],"bytes"))
            self.runBytesReceived = int(self.extract(pat,lines[3],"bytes"))
        else:
            self.reason = lines[1].strip()
            pat = r"(?P<bytes>[\d]+)"
            self.runBytesSent = int(self.extract(pat,lines[2],"bytes"))
            self.runBytesReceived = int(self.extract(pat,lines[3],"bytes"))

    def loadMilestone(self, filename, rID):
        print 'loadMilestone ' + filename
        #if len(self.record_milestone) != 0 and self.record_milestone.has_key(rID):
        #    return
        name = 'extensions/milestone/data/' + filename + '-milestone'
        record_milestone_back = {}
        if os.path.exists(name):
            f = open(name, 'rU')
            all_lines = f.readlines()
            for line in all_lines:
                if line.startswith('#'):
                    continue
                record = Record(line)
                key = record.get_id().strip()
                if key != rID:
                    continue

                if record_milestone_back.has_key(key):
                    record_milestone_back[key].append(record)
                else:
                    record_milestone_back[key] = [record]

        if record_milestone_back.has_key(rID) and len(record_milestone_back[rID]) > 0:
            #if len(record_milestone_back[rID]) > 20:
            record_milestone_back[rID] = reversed(record_milestone_back[rID])

            self.record_milestone[rID] = record_milestone_back[rID]

def read(data):
    lines = data.splitlines()
    records = []

    current_line = lines.pop(0)
    records.append(Record.extract(current_line, PRESENTER_HEADER_RECORD))

    current_line = lines.pop(0)
    records.append(Record.extract(current_line, ORDERING_HEADER_RECORD))

    current_line = lines.pop(0)
    while lines:
        if Record.valid(current_line, REQUIRED_INDIVIDUAL_RECORD):
            record = Record.extract(current_line, REQUIRED_INDIVIDUAL_RECORD)
        elif Record.valid(current_line, OPTIONAL_RECORD):
            record = Record.extract(current_line, OPTIONAL_RECORD)
        elif Record.valid(current_line, ORDERING_FOOTER_RECORD):
            record = Record.extract(current_line, ORDERING_FOOTER_RECORD)
        elif Record.valid(current_line, PRESENTER_FOOTER_RECORD):
            record = Record.extract(current_line, PRESENTER_FOOTER_RECORD)
        else:
            raise Exception('Invalid record: %s' % current_line)
        records.append(record)
        current_line = lines.pop(0)
    return records

 def __init__(self, number_entities, records_per_entity, number_features=2):
     """
     Initializes synthetic database
     No initial corruption, so records from the same cluster have exact same features
     :param number_entities:
     :param records_per_entity: Number of records per entity
     :param number_features:
     """
     indices = range(0, number_features)
     names = ['Name_{0}'.format(s) for s in indices]
     types = ['float' for _ in indices]
     strengths = ['weak' for _ in indices]
     blocking = ['' for _ in indices]
     pairwise_uses = ['numerical_difference' for _ in indices]
     self.labels = dict()  # [record identifier, cluster label]
     self.database = Database()
     feature_descriptor = FeatureDescriptor(names, types, strengths, blocking, pairwise_uses)
     self.database.feature_descriptor = feature_descriptor
     record_index = 0
     for entity_index in range(0, number_entities):
         features = np.random.rand(feature_descriptor.number)
         features = features.astype(str)
         number_records = records_per_entity
         for _ in range(number_records):
             r = Record(record_index, feature_descriptor)
             r.initialize_from_annotation(features)
             self.database.records[record_index] = r
             self.labels[record_index] = entity_index
             record_index += 1

 def add(self, number_entities, records_per_entity):
     """
     Adds additional entities to the database
     :param number_entities:
     :param records_per_entity:
     """
     if len(self.labels) != len(self.database.records):
         raise Exception('Number of records and labels do not match')
     current_max_record_id = 0
     current_max_entity_id = 0
     for (record_id, _), (__, entity_id) in izip(self.database.records.iteritems(), self.labels.iteritems()):
         if record_id > current_max_record_id:
             current_max_record_id = record_id
         if entity_id > current_max_entity_id:
             current_max_entity_id = entity_id
     record_index = current_max_record_id+1
     for entity_index in range(current_max_entity_id+1, current_max_entity_id+1+number_entities):
         features = np.random.rand(self.database.feature_descriptor.number)
         features = features.astype(str)
         number_records = records_per_entity
         for _ in range(number_records):
             r = Record(record_index, self.database.feature_descriptor)
             r.initialize_from_annotation(features)
             self.database.records[record_index] = r
             self.labels[record_index] = entity_index
             record_index += 1

    def __init__(self, builder,  is_revise_mode = False):
        """
        is_revise_mode: 是否是复习模式
        """
        self.builder = builder
        self.is_revise_mode = is_revise_mode

        self.is_new_word = False        # 是一个新的单词吗？
        self.is_correct_mode = False    # 是否是改正模式？
        self.is_first_time = True       # 是否第一次测试？
        self.passed = []                # 通过的单词
        self.failed = []                # 没有通过的单词

        self.typing_sound = True
        self.sound_read_word = True
        self.sound_check_answer = True

        self.__connect_gui()            # 界面连接

        # 获得单词队列
        re = Record()

        words_list = re.get_current_record()

        self.words_len = len(words_list)

        self.queue = []
        for i in range(SPELLING_TIMES):
            temp = words_list[:]
            random.shuffle(temp)
            self.queue += temp

        self.queue_len = len(self.queue)

        self.__start_testing()

 def __init__(self, year, lines):
     """
     Constructor
     @param year - the year to tag the job with
     @param lines - the strings making up this record
     """
     Record.__init__(self, year, lines)

    def __init__(self, year, lines):
        """
        Constructor
        @param year - the year to tag the job with
        @param lines - the strings making up this record
        """
        Record.__init__(self, year, lines)

        ## reason for eviction
        self.reason = lines[1].strip()



        pat = r"\((?P<term>\d+)\) Job was not checkpointed."

        ## termination code
        self.term = self.extract(pat, lines[1], "term")

        userRunRemoteUsage, sysRunRemoteUsage = self.extractUsrSysTimes(lines[2])
        ## remote user run usage time
        self.userRunRemoteUsage = userRunRemoteUsage
        ## remote sys run usage time
        self.sysRunRemoteUsage = sysRunRemoteUsage

        userRunLocalUsage, sysRunLocalUsage  = self.extractUsrSysTimes(lines[3])

        ## local user run usage time
        self.userRunLocalUsage = userRunLocalUsage
        ## local sys run usage time
        self.sysRunLocalUsage  = sysRunLocalUsage

        pat = r"(?P<bytes>\d+) "
        ## bytes sent during the run
        self.runBytesSent = int(self.extract(pat,lines[4], "bytes"))
        ## bytes received during the run
        self.runBytesReceived = int(self.extract(pat,lines[5], "bytes"))


        pat = r"Partitionable Resources :\s+Usage\s+\Request\s+Allocated$"

        ## disk usage
        self.diskUsage = None

        ## disk requested
        self.diskRequest = None

        ## memory usage
        self.memoryUsage = None

        ## memory requested
        self.memoryRequest = None

        ret = re.search(pat, lines[6])
        if ret is None:
            self.diskUsage, self.diskRequest = self.extractUsageRequest(lines[8])
            self.memoryUsage, self.memoryRequest = self.extractUsageRequest(lines[9])
        else:
            self.diskUsage, self.diskRequest, allocated = self.extractUsageRequestAllocated(lines[8])
            self.memoryUsage, self.memoryRequest, allocated = self.extractUsageRequestAllocated(lines[9])

 def test_leading_underscores(self):
   'leading underscores'
   self.assert_(Record.define('Foo', ('_foo',)))
   self.assert_(Record.define('Foo', ('foo',),
     allow_leading_underscores=False))
   self.assertRaises(record.InvalidNameError,
       Record.define, 'Foo', ('_foo',),
       allow_leading_underscores=False)

    def next(self):
		if self._index == self._total:
			raise StopIteration
		record = Record(self._simplemodel)
		record.setColumnProperties(self._data[self._index])
		
		self._index += 1
		return record

 def __init__(self, year, lines):
     """
     Constructor
     @param year - the year to tag the job with
     @param lines - the strings making up this record
     """
     Record.__init__(self, year, lines)
     ## the reason for the failure
     self.reason = lines[1].strip()+";"+lines[2].strip()

    def __init__(self):
        QWidget.__init__(self)
        Record.__init__(self)
        threading.Thread.__init__(self)
        
#         self.record = Record()
        self.btn_begin_record = QtGui.QPushButton(self)
        self.btn_stop_record = QtGui.QPushButton(self)
        self.btn_sel_save_dir= QtGui.QPushButton(self)
        self.btn_postfix= QtGui.QPushButton(self)
        self.layout= QtGui.QGridLayout(self)
        self.lin_show_dir= QtGui.QLineEdit(self)
        self.lab_save_file_dir= QtGui.QLabel(self)
        self.lab_save_name= QtGui.QLabel(self)
        self.lin_save_name= QtGui.QLineEdit(self)
        self.lab_begin_record_time= QtGui.QLabel(self)
        self.lin_begin_record_time= QtGui.QLineEdit(self)
        self.lab_stop_record_time= QtGui.QLabel(self)
        self.lin_stop_record_time= QtGui.QLineEdit(self)
        self.lin_record_time= QtGui.QLineEdit(self)
        self.lab_show_record_time= QtGui.QLabel(self)
        self.record_time=0
        self.lab_begin_record_time.setText(u'开始录音时间:')
        self.lab_stop_record_time.setText(u'停止录音时间:')
        self.btn_begin_record.setText(u'开始录音')
        self.btn_stop_record.setText(u'停止录音')
        self.btn_sel_save_dir.setText(u'...')
        self.btn_postfix.setText(u'.wav')
        self.lab_save_file_dir.setText(u'录音保存路径:')
        self.lab_save_name.setText(u'录音保存名字:')
        self.lab_show_record_time.setText(u'录音时长:')
        self.lin_show_dir.setText(os.getcwd())
        self.btn_begin_record.setFixedWidth(120)
        self.btn_stop_record.setFixedWidth(120)
        self.lab_save_file_dir.setFixedWidth(120)
        self.btn_sel_save_dir.setFixedWidth(20)
        
        self.layout.addWidget(self.lab_save_file_dir,0,0,1,1)
        self.layout.addWidget(self.lin_show_dir,0,1,1,1)
        self.layout.addWidget(self.btn_sel_save_dir,0,2,1,1)
        self.layout.addWidget(self.lab_save_name,1,0,1,1)
        self.layout.addWidget(self.lin_save_name,1,1,1,1)
        self.layout.addWidget(self.btn_postfix,1,2,1,1)
        self.layout.addWidget(self.lab_begin_record_time,2,0,1,1)
        self.layout.addWidget(self.lin_begin_record_time,2,1,1,1)
        self.layout.addWidget(self.lab_stop_record_time,3,0,1,1)
        self.layout.addWidget(self.lin_stop_record_time,3,1,1,1)
        self.layout.addWidget(self.lab_show_record_time,4,0,1,1)
        self.layout.addWidget(self.lin_record_time,4,1,1,1)
        self.layout.addWidget(self.btn_begin_record,5,0,1,1)
        self.layout.addWidget(self.btn_stop_record,5,1,1,1)
        self.setLayout(self.layout)
        
        QtCore.QObject.connect(self.btn_sel_save_dir, QtCore.SIGNAL(QtCore.QString.fromUtf8("clicked()")),self.onSelectDir)
        QtCore.QObject.connect(self.btn_begin_record, QtCore.SIGNAL(QtCore.QString.fromUtf8("clicked()")),self.onBeginRecord)
        QtCore.QObject.connect(self.btn_stop_record, QtCore.SIGNAL(QtCore.QString.fromUtf8("clicked()")),self.onStopRecord)
        QtCore.QMetaObject.connectSlotsByName(self)