def _add_transaction(self, tr, state): """Add the transaction to the transaction storage, thread-safely. @type tr: AbstractTransaction @type state: AbstractTransaction.State """ logger.debug('__add %r', tr) with self.__transactions_lock: assert tr.uuid not in self.__transactions_by_uuid, \ (tr, self.__transactions_by_uuid) assert tr.uuid not in self.__states_by_uuid, \ (tr, self.__states_by_uuid) # 1. By UUID (self.__transactions_by_uuid[tr.uuid], self.__states_by_uuid[tr.uuid]) = (tr, state) # 2. By end time assert self.__transactions_by_end_time == \ sorted(self.__transactions_by_end_time), \ repr(self.__transactions_by_end_time) bisect.insort(self.__transactions_by_end_time, (tr.max_end_time(), tr)) # 3. By class self.__states_by_class_name[tr.msg_class.name][tr.uuid] = state self.__assert_invariant()
def doActivate(self, w): # when activating a timer which has already passed, # simply abort the timer. don't run trough all the stages. if w.shouldSkip(): w.state = PowerTimerEntry.StateEnded else: # when active returns true, this means "accepted". # otherwise, the current state is kept. # the timer entry itself will fix up the delay then. if w.activate(): w.state += 1 try: self.timer_list.remove(w) except: print '[PowerManager]: Remove list failed' # did this timer reached the last state? if w.state < PowerTimerEntry.StateEnded: # no, sort it into active list insort(self.timer_list, w) else: # yes. Process repeated, and re-add. if w.repeated: w.processRepeated() w.state = PowerTimerEntry.StateWaiting self.addTimerEntry(w) else: # Remove old timers as set in config self.cleanupDaily(config.recording.keep_timers.value) insort(self.processed_timers, w) self.stateChanged(w)
def add(self, node, parent, priority=0): """Adds the specified node with the specified parent. If the dep is a soft-dep and the node already has a hard relationship to the parent, the relationship is left as hard.""" if node not in self.nodes: self.nodes[node] = ({}, {}, node) self.order.append(node) if not parent: return if parent not in self.nodes: self.nodes[parent] = ({}, {}, parent) self.order.append(parent) priorities = self.nodes[node][1].get(parent) if priorities is None: priorities = [] self.nodes[node][1][parent] = priorities self.nodes[parent][0][node] = priorities if not priorities or priorities[-1] is not priority: bisect.insort(priorities, priority)
def makeShapeDifferentTo(self, paramValue): #make new shape to compare with [newShape, newParams] = self.shapeModeler.makeRandomShapeFromTriangular(self.params, self.paramsToVary, self.bounds, [ paramValue]) #USE ONLY FIRST PARAM FOR SELF-LEARNING ALGORITHM ATM newParamValue = newParams[self.paramsToVary[0] - 1, 0] #USE ONLY FIRST PARAM FOR SELF-LEARNING ALGORITHM ATM #ensure it is significantly different numAttempts = 1 while (abs(newParamValue - paramValue) < self.minParamDiff and numAttempts < maxNumAttempts): [newShape, newParams] = self.shapeModeler.makeRandomShapeFromTriangular(self.params, self.paramsToVary, self.bounds, [ paramValue]) #USE ONLY FIRST PARAM FOR SELF-LEARNING ALGORITHM ATM newParamValue = newParams[ self.paramsToVary[0] - 1, 0] #USE ONLY FIRST PARAM FOR SELF-LEARNING ALGORITHM ATM numAttempts += 1 if (numAttempts >= maxNumAttempts): #couldn't find a 'different' shape in range print('Oh no!') #this should be prevented by the convergence test below #store it as an attempt if (self.doGroupwiseComparison): bisect.insort(self.params_sorted, newParamValue) self.shapeToParamsMapping.append(newParams) return newShape, newParamValue
def doActivate(self, w): self.timer_list.remove(w) # when activating a timer which has already passed, # simply abort the timer. don't run trough all the stages. if w.shouldSkip(): w.state = TimerEntry.StateEnded else: # when active returns true, this means "accepted". # otherwise, the current state is kept. # the timer entry itself will fix up the delay then. if w.activate(): w.state += 1 # did this timer reached the last state? if w.state < TimerEntry.StateEnded: # no, sort it into active list insort(self.timer_list, w) else: # yes. Process repeated, and re-add. if w.repeated: w.processRepeated() w.state = TimerEntry.StateWaiting self.addTimerEntry(w) else: insort(self.processed_timers, w) self.stateChanged(w)
def update(self,records,**kw): """Update one record of a list of records with new keys and values and update indices""" # ignore unknown fields kw = dict([(k,v) for (k,v) in kw.items() if k in self.fields]) if isinstance(records,dict): records = [ records ] # update indices for indx in set(self.indices.keys()) & set (kw.keys()): for record in records: if record[indx] == kw[indx]: continue _id = record["__id__"] # remove id for the old value old_pos = bisect.bisect(self.indices[indx][record[indx]],_id)-1 del self.indices[indx][record[indx]][old_pos] if not self.indices[indx][record[indx]]: del self.indices[indx][record[indx]] # insert new value bisect.insort(self.indices[indx].setdefault(kw[indx],[]),_id) for record in records: # update record values record.update(kw) # increment version number record["__version__"] += 1
def _free(self, block): # free location and try to merge with neighbours (arena, start, stop) = block try: prev_block = self._stop_to_block[(arena, start)] except KeyError: pass else: start, _ = self._absorb(prev_block) try: next_block = self._start_to_block[(arena, stop)] except KeyError: pass else: _, stop = self._absorb(next_block) block = (arena, start, stop) length = stop - start try: self._len_to_seq[length].append(block) except KeyError: self._len_to_seq[length] = [block] bisect.insort(self._lengths, length) self._start_to_block[(arena, start)] = block self._stop_to_block[(arena, stop)] = block
def create_index(self,*fields): """Create an index on the specified field names An index on a field is a mapping between the values taken by the field and the sorted list of the ids of the records whose field is equal to this value For each indexed field, an attribute of self is created, an instance of the class Index (see above). Its name it the field name, with the prefix _ to avoid name conflicts """ reset = False for f in fields: if not f in self.fields: raise NameError("%s is not a field name %s" %(f,self.fields)) # initialize the indices if self.mode == "open" and f in self.indices: continue reset = True self.indices[f] = {} for _id,record in self.records.items(): # use bisect to quickly insert the id in the list bisect.insort(self.indices[f].setdefault(record[f],[]), _id) # create a new attribute of self, used to find the records # by this index setattr(self,'_'+f,Index(self,f)) if reset: self.commit()
def insert(self,*args,**kw): """Insert a record in the database Parameters can be positional or keyword arguments. If positional they must be in the same order as in the create() method If some of the fields are missing the value is set to None Returns the record identifier """ if args: kw = dict([(f,arg) for f,arg in zip(self.fields,args)]) # initialize all fields to None record = dict([(f,None) for f in self.fields]) # raise exception if unknown field for key in kw: if not key in self.fields: raise NameError("Invalid field name : %s" %key) # set keys and values for (k,v) in kw.items(): record[k]=v # add the key __id__ : record identifier record['__id__'] = self.next_id # add the key __version__ : version number record['__version__'] = 0 # create an entry in the dictionary self.records, indexed by __id__ self.records[self.next_id] = record # update index for ix in self.indices.keys(): bisect.insort(self.indices[ix].setdefault(record[ix],[]), self.next_id) # increment the next __id__ self.next_id += 1 return record['__id__']
def add_global_handler(self, event, handler, priority=0): """Adds a global handler function for a specific event type. Arguments: event -- Event type (a string). Check the values of the numeric_events dictionary in irclib.py for possible event types. handler -- Callback function. priority -- A number (the lower number, the higher priority). The handler function is called whenever the specified event is triggered in any of the connections. See documentation for the Event class. The handler functions are called in priority order (lowest number is highest priority). If a handler function returns \"NO MORE\", no more handlers will be called. """ if not event in self.handlers: self.handlers[event] = [] bisect.insort(self.handlers[event], ((priority, handler)))
def _run_timeouts(self): now = time.time() while len(self._scheduled_timeouts) > 0 and self._scheduled_timeouts[0][0] < now: t, t_id = self._scheduled_timeouts.pop(0) info = self._timeouts.get(t_id, None) if info is None: continue try: ret = info['func'](*info['args']) # Only reschedule if returning True if not ret: self.timeout_remove(t_id) continue # Reschedule now2 = time.time() delta = (now2 - t) % info['delay'] t_new = now2 + info['delay'] - delta logger.debug('Rescheduling timeout %d for %s', t_id, t_new - now2) bisect.insort(self._scheduled_timeouts, (t_new, t_id)) except Exception, e: logger.error('Timeout call %d failed: %s', t_id, str(e)) self.timeout_remove(t_id)
def suppressFire_callback(channel,flag=0): # print GPIO.input(channel), channel # print GPIO.input(24), 24 # print 'callback' if not flag: print 'UVTron just told me about a fire!', GPIO.input(channel) x,y = nan, nan while isnan(x) or isnan(y): print 'no fire in frame yet' # Need to do some sort of check to filter out random spikes here ti = time.time() while GPIO.input(channel): print 'signal went high for some reason' if time.time() - ti >= 0.01: print "Something may be wrong with the UVTron signal" return # FireImage = abs(average(ImQueue[-1],-1) - average(ImQueue[0],-1)) print 'grabbing an image' FireImage = average(ImQueue[0],-1) x,y = findFire(FireImage) # print x,y # fo = '-'.join(map(str, datetime.now().timetuple()[:6])) # imwrite('fire'+fo+'.bmp',FireImage) xdivtmp, ydivtmp = xdivs[:], ydivs[:] bisect.insort(xdivtmp,x) # Insert the fire coordinates into the protection grid bisect.insort(ydivtmp,y) xzone = xdivtmp.index(x) - 1 # Find the grid coordinates yzone = ydivtmp.index(y) - 1 # print 'fire seen in %d,%d' % (xzone,yzone) del xdivtmp, ydivtmp print 'putting out fire' firePorts((xzone,yzone)) print 'Fire at (%.2f,%.2f) in zone %d,%d\nFiring ports %d & %d' % ((x,y,xzone,yzone,) + fireDict[(xzone,yzone)])
def register_middleware(level, middleware, quiet=False): """ Register a middleware for HTTP requests. In addition to standard WSGI entries, the ``environ`` passed to middlewares will include: * ``rdfrest.resource``: the requested resource; may be None * ``rdfrest.requested.uri``: the URI (as an ``rdflib.URIRef``) requested by the client, without its extension (see below) * ``rdfrest.requested.extension``: the requested extension; may be ``""`` :param level: a level governing the order of execution of pre-processors; predefined levels are AUTHENTICATION, AUTHORIZATION :param middleware: a function accepting a WSGI application, and producing a WSGI application wrapping the former """ if middleware in ( i[1] for i in _MIDDLEWARE_REGISTRY ): if not quiet: raise ValueError("middleware already registered") else: return insort(_MIDDLEWARE_REGISTRY, (level, middleware)) global _MIDDLEWARE_STACK_VERSION _MIDDLEWARE_STACK_VERSION += 1
def add(self, time, event, absolute_time=False): """ Adds an event to the schedule. Events are inserted so that the schedule is always chronologically sorted. Parameters ---------- time : float The time at which the event takes place event : dict The properties of the event absolute_time : bool, optional Specifies whether the time is expressed as absolute time or as interval from the latest event of the schedule """ # When a new event is inserted, make sure it is inserted in # chronological order if absolute_time and time < 0: raise ValueError('Time must be a positive value') if absolute_time: if time < self.attrib['t_end']: bisect.insort(self.event, (time, event)) # maintain list sorted return self.attrib['t_end'] = time else: self.attrib['t_end'] += time time = self.attrib['t_end'] self.event.append((time, event))
def get_service(self, bundle, reference): """ Retrieves the service corresponding to the given reference :param bundle: The bundle requiring the service :param reference: A service reference :return: The requested service :raise BundleException: The service could not be found """ with self.__svc_lock: # Be sure to have the instance try: service = self.__svc_registry[reference] # Indicate the dependency imports = self.__bundle_imports.setdefault(bundle, []) bisect.insort(imports, reference) reference.used_by(bundle) return service except KeyError: # Not found raise BundleException("Service not found (reference: {0})" .format(reference))
def init_allocations(): global machine_allocation_dict global allocations_list global node_manager global usages_list global machine_usage_dict logger.info("init allocations:") machines = node_manager.get_allnodes() for machine in machines: allocation = AllocationOfMachine() allocation.machineid = machine allocation.resources = 2 allocation.reliable_resources_allocation_summary = 0 allocation.reliable_allocations = [] allocation.restricted_allocations = [] machine_allocation_dict[machine] = allocation bisect.insort(allocations_list,allocation) usage_of_machine = {} usage_of_machine['machineid']=machine usage_of_machine['cpu_utilization']=0.1 usages_list.append(usage_of_machine) machine_usage_dict[machine] = 0.1
def doActivate(self, w): # when activating a timer which has already passed, # simply abort the timer. don't run trough all the stages. if w.shouldSkip(): w.state = RecordTimerEntry.StateEnded else: # when active returns true, this means "accepted". # otherwise, the current state is kept. # the timer entry itself will fix up the delay then. if w.activate(): w.state += 1 self.timer_list.remove(w) # did this timer reached the last state? if w.state < RecordTimerEntry.StateEnded: # no, sort it into active list insort(self.timer_list, w) else: # yes. Process repeated, and re-add. if w.repeated: w.processRepeated() w.state = RecordTimerEntry.StateWaiting w.first_try_prepare = True self.addTimerEntry(w) else: # correct wrong running timers self.checkWrongRunningTimers() # check for disabled timers, if time as passed set to completed self.cleanupDisabled() # Remove old timers as set in config self.cleanupDaily(config.recording.keep_timers.value) insort(self.processed_timers, w) self.stateChanged(w)
def _add_free_block(self, block): # make block available and try to merge with its neighbours in the arena (arena, start, stop) = block try: prev_block = self._stop_to_block[(arena, start)] except KeyError: pass else: start, _ = self._absorb(prev_block) try: next_block = self._start_to_block[(arena, stop)] except KeyError: pass else: _, stop = self._absorb(next_block) block = (arena, start, stop) length = stop - start try: self._len_to_seq[length].append(block) except KeyError: self._len_to_seq[length] = [block] bisect.insort(self._lengths, length) self._start_to_block[(arena, start)] = block self._stop_to_block[(arena, stop)] = block
def mergeFiles(): SOURCE = "E:/Data/Stats/source/IntraDay/Nifty50_2017-10/" DEST = SOURCE + "OUTPUT/" if not os.path.exists(DEST): os.makedirs(DEST) ScripMap = {} csvs = (file for file in os.listdir(SOURCE) if os.path.isfile(os.path.join(SOURCE, file))) for csv in csvs: split = csv.split('_') scrip = split[0] if( split[1] == 'F1' or split[1] == 'F2'): scrip += '_' + split[1] if( scrip not in ScripMap ): ScripMap[scrip] = [os.path.join(SOURCE, csv)] else: a = ScripMap[scrip] bisect.insort( a, os.path.join(SOURCE, csv) ) for scrip in ScripMap : print( scrip ) outputFile = open(DEST + scrip + '.txt', 'w') inputFiles = ScripMap[scrip] for file in inputFiles : fileO = open(file,'r') outputFile.write( fileO.read() ) fileO.close() outputFile.close()
def addEvidence(self,data,label): """ Adds to the set of training data. If the anchor lists were sorted before the call to this method, the new data will be inserted into the anchor lists using 'bisect.insort' data - a numpy array, either a single point (1D) or a set of points (2D) label - the label for data. A single value, or a list of values in the same order as the points in data. """ if len(data.shape)==1: new_idx = len(self.training_data) self.training_data.append(data) self.data_classes[new_idx] = label if self.is_sorted: for a in self.anchors: dist = self.distfun(data,self.training_data[a]) bisect.insort(self.data_by_anchors[a],(dist,new_idx)) elif len(data.shape)>1: for i in range(len(data)): thing = data[i] new_idx = len(self.training_data) self.training_data.append(thing) self.data_classes[new_idx] = label[i] if self.is_sorted: for a in self.anchors: dist = self.distfun(thing,self.training_data[a]) bisect.insort(self.data_by_anchors[a],(dist,new_idx))
def registerPlugin(self, plugin): """Registers a plugin.""" plugin_types = { 'presence': IPresencePlugin, 'chat': IChatPlugin, 'population': IPopulationPlugin, 'base_plugin': BaseInterface, } # Everything is, at least, a base plugin. valid_types = set(['baseplugin']) # Loop through the types of plugins and check for implentation # of each. claimed_compliances = list(implementedBy(type(plugin))) # Can we use this as a map instead? for t, interface in plugin_types.iteritems(): if interface in claimed_compliances: try: verifyObject(interface, plugin) except DoesNotImplement: log.error('Plugin %s claims to be a %s, but is not!', plugin.name, t) else: # If the above succeeded, then `plugin` implements # `interface`. insort(self.plugins[t], plugin) valid_types.add(t) plugin.setup(self) log.info('registered plugin %s as %s', plugin.name, valid_types)
def _add_contexts(self, all_messages): """Add source lines to the messages. This method has the desired side effect that messages that only differ in line number but that do have the same source line, will be considered identical. Parameters ---------- all_messages : Set([]) of Message instances All errors encountered in the current branch. """ # 1) Collect all messages in a dictionary, where filenames are keys and values # are sorted lists of messages. Only messages with a filename and a line number # must be included. mdict = {} for message in all_messages: if message.filename is not None and message.lineno is not None: l = mdict.setdefault(message.filename, []) bisect.insort(l, message) # 2) Loop over all files and collect some source context for each message for filename, file_messages in mdict.iteritems(): with open(filename) as source_file: lines = source_file.readlines() for message in file_messages: all_messages.discard(message) # The context starts three lines before the line and ends three lines # after. context = "".join(lines[max(0, message.lineno - 3) : min(len(lines), message.lineno + 4)]) all_messages.add(message.add_context(context))
def cycle(self, interval, function, *args, **kwargs): """ Schedule a cycle. A cycle is a deferred that is continuously rescheduled. It will be run at regular intervals. Returns a callable which can be used to cancel the cycle. ========= ============ Argument Description ========= ============ interval The interval, in seconds, at which the cycle should be run. function The callable to be executed when the cycle is run. args The positional arguments to be passed to the callable. kwargs The keyword arguments to be passed to the callable. ========= ============ """ if interval <= 0: raise ValueError("Interval must be greater than 0 seconds.") cycle = functools.partial(function, *args, **kwargs) timer = _Timer(self, cycle, True, interval, self.time + interval) bisect.insort(self._deferreds, timer) return timer
def __get_rsync_backups (self): # get rsync backup dir self.rsyncsmf = rsyncsmf.RsyncSMF("%s:rsync" %(plugin.PLUGINBASEFMRI)) rsyncBaseDir = self.rsyncsmf.get_target_dir() sysName,nodeName,rel,ver,arch = os.uname() self.rsyncDir = os.path.join(rsyncBaseDir, rsyncsmf.RSYNCDIRPREFIX, nodeName) if not os.path.exists(self.rsyncDir): return rootBackupDirs = [] for root, dirs, files in os.walk(self.rsyncDir): if '.time-slider' in dirs: dirs.remove('.time-slider') backupDir = os.path.join(root, rsyncsmf.RSYNCDIRSUFFIX) if os.path.exists(backupDir): insort(rootBackupDirs, os.path.abspath(backupDir)) for dirName in rootBackupDirs: os.chdir(dirName) for d in os.listdir(dirName): if os.path.isdir(d) and not os.path.islink(d): s1 = dirName.split ("%s/" % self.rsyncDir, 1) s2 = s1[1].split ("/%s" % rsyncsmf.RSYNCDIRSUFFIX, 1) fs = s2[0] rb = RsyncBackup ("%s/%s" %(dirName, d), self.rsyncDir, fs, d, os.stat(d).st_mtime) self.rsynced_backups.append (rb)
def defer(self, delay, function, *args, **kwargs): """ Schedule a deferred. A deferred is a function (or other callable) that is executed after a certain amount of time has passed. Returns a callable which can be used to cancel the deferred. ========= ===================================================== Argument Description ========= ===================================================== delay The delay, in seconds, after which the deferred should be run. function The callable to be executed when the deferred is run. args The positional arguments to be passed to the callable. kwargs The keyword arguments to be passed to the callable. ========= ===================================================== """ if delay <= 0: raise ValueError("Delay must be greater than 0 seconds.") deferred = functools.partial(function, *args, **kwargs) timer = _Timer(self, deferred, False, delay, self.time + delay) bisect.insort(self._deferreds, timer) return timer
def find_shortest_path(graph, start, end, parent, visited, distance): import bisect current = start candidates = list() while current and current != end: neighbours = graph[current] for neighbour, neighbour_dist in neighbours: if visited.has_key(neighbour): continue if distance[current] + neighbour_dist < distance[neighbour]: if ((distance[neighbour], neighbour) in candidates): candidates.remove((distance[neighbour], neighbour)) distance[neighbour] = distance[current] + neighbour_dist bisect.insort(candidates, (distance[neighbour], neighbour)) parent[neighbour] = current visited[current] = True current = None if len(candidates) > 0: _, current = candidates.pop(0)
def scan_commands(self): self._commands = [] if self.mod == None: return dic = self.mod.__dict__ if '__root__' in dic: root = dic['__root__'] else: root = [] for k in dic: if k.startswith('_') or k in root: continue item = dic[k] if type(item) == types.FunctionType: bisect.insort(self._commands, method.Method(item, k, self)) elif type(item) == types.ModuleType and utils.is_commander_module(item): mod = Module(k, item, self) bisect.insort(self._commands, mod) # Insert root functions into this module for r in mod.roots(): bisect.insert(self._commands, r)
def update(self,record,**kw): """Update the record with new keys and values and update indices""" # validate all the keys and values before updating for k,v in kw.iteritems(): self._validate(k,v) # update record values for k,v in kw.iteritems(): record[k] = v # if there is no index to update, stop here if not self.indices.keys(): return # update index # get previous version of the record (same __id__) _id = record['__id__'] try: old_rec = self.records[_id] except KeyError: raise KeyError,"No record with __id__ %s" %_id # change indices for indx in self.indices.keys(): if old_rec[indx] == record[indx]: continue # remove id for the old value old_pos = bisect.bisect(self.indices[indx][old_rec[indx]],_id)-1 del self.indices[indx][old_rec[indx]][old_pos] # insert new value bisect.insort(self.indices[indx].setdefault(record[indx],[]),_id)
def add(self, child, z=0, name=None ): """Adds a child to the container :Parameters: `child` : CocosNode object to be added `z` : float the z index of self `name` : str Name of the child :rtype: `CocosNode` instance :return: self """ # child must be a subclass of supported_classes #if not isinstance( child, self.supported_classes ): # raise TypeError("%s is not instance of: %s" % (type(child), self.supported_classes) ) if name: if name in self.children_names: raise Exception("Name already exists: %s" % name ) self.children_names[ name ] = child child.parent = self elem = z, child bisect.insort( self.children, elem ) if self.is_running: child.on_enter() return self
def add_many(self, edges): """Add multiple edges.""" for src,dest in edges: if dest not in self._outgoing[src]: insort(self._outgoing[src], dest) insort(self._incoming[dest], src)
def add(self, aCard: Card) -> None: bisect.insort(self.cards, aCard)
def add_row(self, member): if not self.have_member(member): bisect.insort(self.items, member) self.refresh_collisions() self.modelReset.emit()
def _initializeLocationCache(self): """ CGD uses Faldo ontology for locations, it's a bit complicated. This function sets up an in memory cache of all locations, which can be queried via: locationMap[build][chromosome][begin][end] = location["_id"] """ # cache of locations self._locationMap = {} locationMap = self._locationMap triples = self._rdfGraph.triples Ref = rdflib.URIRef associations = [] for subj, _, _ in triples((None, RDF.type, Ref(ASSOCIATION))): associations.append(subj.toPython()) locationIds = [] for association in associations: for _, _, obj in triples((Ref(association), Ref(HAS_SUBJECT), None)): locationIds.append(obj.toPython()) locations = [] for _id in locationIds: location = {} location["_id"] = _id for subj, predicate, obj in triples((Ref(location["_id"]), None, None)): if not predicate.toPython() in location: location[predicate.toPython()] = [] bisect.insort(location[predicate.toPython()], obj.toPython()) if FALDO_LOCATION in location: locations.append(location) for location in locations: for _id in location[FALDO_LOCATION]: # lookup faldo region, ensure positions are sorted faldoLocation = {} faldoLocation["_id"] = _id for subj, predicate, obj in triples((Ref(faldoLocation["_id"]), None, None)): if not predicate.toPython() in faldoLocation: faldoLocation[predicate.toPython()] = [] bisect.insort(faldoLocation[predicate.toPython()], obj.toPython()) faldoBegins = [] for _id in faldoLocation[FALDO_BEGIN]: faldoBegin = {} faldoBegin["_id"] = _id for subj, predicate, obj in triples( (Ref(faldoBegin["_id"]), None, None)): faldoBegin[predicate.toPython()] = obj.toPython() faldoBegins.append(faldoBegin) faldoReferences = [] for _id in faldoLocation[FALDO_BEGIN]: faldoReference = {} faldoReference["_id"] = faldoBegin[FALDO_REFERENCE] for subj, predicate, obj in triples( (Ref(faldoReference["_id"]), None, None)): faldoReference[predicate.toPython()] = obj.toPython() faldoReferences.append(faldoReference) faldoEnds = [] for _id in faldoLocation[FALDO_END]: faldoEnd = {} faldoEnd["_id"] = _id for subj, predicate, obj in triples((Ref(faldoEnd["_id"]), None, None)): faldoEnd[predicate.toPython()] = obj.toPython() faldoEnds.append(faldoEnd) for idx, faldoReference in enumerate(faldoReferences): if MEMBER_OF in faldoReference: build = faldoReference[MEMBER_OF].split('/')[-1] chromosome = faldoReference[LABEL].split(' ')[0] begin = faldoBegins[idx][FALDO_POSITION] end = faldoEnds[idx][FALDO_POSITION] if build not in locationMap: locationMap[build] = {} if chromosome not in locationMap[build]: locationMap[build][chromosome] = {} if begin not in locationMap[build][chromosome]: locationMap[build][chromosome][begin] = {} if end not in locationMap[build][chromosome][begin]: locationMap[build][chromosome][begin][end] = {} locationMap[build][chromosome][begin][end] = \ location["_id"] locationMap[location["_id"]] = { "build": build, "chromosome": chromosome, "begin": begin, "end": end, }
def append(self, item): bisect.insort(self.A, (self.f(item), item))
output_file.write(CMTE_ID + '|' + ZIP_CODE + '|' + transaction_year + '|' + str(int(round(TRANSACTION_AMT))) + '|' + str(int(round(TRANSACTION_AMT))) + '|' + '1\n') else: ''' donation_array = stores all donations from repeat donors with a given tuple = (CMTE_ID, ZIP_CODE, transaction_year) total_amount = sum of the donation array ''' donation_array, total_amount = repeat_donors[(CMTE_ID, ZIP_CODE, transaction_year)] total_amount += TRANSACTION_AMT #total amount of money donated is increased by the next donation bisect.insort( donation_array, TRANSACTION_AMT ) #a new value is inserted and the array is sorted again. repeat_donors[(CMTE_ID, ZIP_CODE, transaction_year)] = [donation_array, total_amount] percentile = donation_array[int( math.ceil(PERCENTILE_number * len(donation_array))) - 1] #percentile value is calculated output_file.write(CMTE_ID + '|' + ZIP_CODE + '|' + transaction_year + '|' + str(int(round(percentile))) + '|' + str(int(round(total_amount))) + '|' + str(len(donation_array)) + '\n') input_file.close() output_file.close()
""" heaps : running mean author : Woongwon Lee problem : https://www.hackerrank.com/challenges/ctci-find-the-running-median/problem output : After each new integer is added to the list, print the list's updated median on a new line as a single double-precision number scaled to 1 decimal place (i.e., 12.3 format). """ import bisect n = int(input().strip()) list_i = [] a_i = 0 for a_i in range(n): a_t = int(input().strip()) bisect.insort(list_i, a_t) if len(list_i) % 2 == 0: mid_left = len(list_i) // 2 - 1 mid_right = len(list_i) // 2 print('{:0.1f}'.format((list_i[mid_left] + list_i[mid_right]) / 2)) else: mid = len(list_i) // 2 print('{:0.1f}'.format(list_i[mid]))
lib_dict0[name_dict0.get(name, name)].append(lib_dict[name]) p_mz_rt = [] for name, dat in all_dat0.items(): if name.startswith('ISF of'): pmz, rt = [float(x) for x in re.findall("\d+\.\d+", name)[:2]] else: pmz = dat[0][2] rt = statistics.median(rt for _, _, _, rt, _, _, _, _ in dat) pos0 = bisect_left(p_mz_rt, (pmz - .01, )) pos1 = bisect_left(p_mz_rt, (pmz + .01, ), lo=pos0) for x in p_mz_rt[pos0:pos1]: if abs(rt - x[1]) < RT_shift: break else: bisect.insort(p_mz_rt, (pmz, rt)) mz_rt_name = collections.defaultdict(list) for name, dat in all_dat0.items(): if name.startswith('ISF of'): pmz, rt = [float(x) for x in re.findall("\d+\.\d+", name)[:2]] else: pmz = dat[0][2] rt = statistics.median(rt for _, _, _, rt, _, _, _, _ in dat) pos0 = bisect_left(p_mz_rt, (pmz - .01, )) pos1 = bisect_left(p_mz_rt, (pmz + .01, ), lo=pos0) for n, x in enumerate(p_mz_rt[pos0:pos1], pos0): if abs(rt - x[1]) < RT_shift: mz_rt_name[n].append(name) break else:
def add(self, album): bisect.insort(self.list, album)
list(reversed(weekdays)) # sort a list in place (modifies but does not return the list) simpsons.sort() simpsons.sort(reverse=True) # sort in reverse simpsons.sort(key=len) # sort by a key # return a sorted list (does not modify the original list) sorted(simpsons) sorted(simpsons, reverse=True) sorted(simpsons, key=len) # insert into an already sorted list, and keep it sorted num = [10, 20, 40, 50] from bisect import insort insort(num, 30) # create a second reference to the same list same_num = num same_num[0] = 0 # modifies both 'num' and 'same_num' # copy a list (two ways) new_num = num[:] new_num = list(num) # examine objects num is same_num # returns True (checks whether they are the same object) num is new_num # returns False num == same_num # returns True (checks whether they have the same contents) num == new_num # returns True
def schedule_slot(self, time_slot): if self.check_availability(time_slot): raise ScheduleError('DERP! We messed up the scheduling!') bisect.insort(self.time_slots, time_slot)
def run(self): socket = QtNetwork.QTcpSocket() if not socket.setSocketDescriptor(self.socketId): self.error.emit(socket.error()) return while socket.state() == QtNetwork.QAbstractSocket.ConnectedState: nextBlockSize = 0 stream = QtCore.QDataStream(socket) stream.setVersion(QtCore.QDataStream.Qt_4_2) if (socket.waitForReadyRead() and socket.bytesAvailable() >= SIZEOF_UINT16): nextBlockSize = stream.readUInt16() else: self.sendError(socket, "Cannot read client request") return if socket.bytesAvailable() < nextBlockSize: if (not socket.waitForReadyRead(60000) or socket.bytesAvailable() < nextBlockSize): self.sendError(socket, "Cannot read client data") return action = stream.readQString() date = QtCore.QDate() if action in ("BOOK", "UNBOOK"): room = stream.readQString() stream >> date try: Thread.lock.lockForRead() bookings = Bookings.get(date.toPython()) finally: Thread.lock.unlock() uroom = room if action == "BOOK": newlist = False try: Thread.lock.lockForRead() if bookings is None: newlist = True finally: Thread.lock.unlock() if newlist: try: Thread.lock.lockForWrite() bookings = Bookings[date.toPython()] finally: Thread.lock.unlock() error = None insert = False try: Thread.lock.lockForRead() if len(bookings) < MAX_BOOKINGS_PER_DAY: if uroom in bookings: error = "Cannot accept duplicate booking" else: insert = True else: error = "{} is fully booked".format( date.toString(QtCore.Qt.ISODate)) finally: Thread.lock.unlock() if insert: try: Thread.lock.lockForWrite() bisect.insort(bookings, uroom) finally: Thread.lock.unlock() self.sendReply(socket, action, room, date) else: self.sendError(socket, error) elif action == "UNBOOK": error = None remove = False try: Thread.lock.lockForRead() if bookings is None or uroom not in bookings: error = "Cannot unbook nonexistent booking" else: remove = True finally: Thread.lock.unlock() if remove: try: Thread.lock.lockForWrite() bookings.remove(uroom) finally: Thread.lock.unlock() self.sendReply(socket, action, room, date) else: self.sendError(socket, error) else: self.sendError(socket, "Unrecognized request") socket.waitForDisconnected() try: Thread.lock.lockForRead() printBookings() finally: Thread.lock.unlock()
def add_result(sm): if -sm not in res: insort(res, -sm) if len(res) > 3: res.pop()
import bisect import random # Sorting is expensive, so once you have a sorted sequence, it's good to keep it that way. That is why bisect.insort was created. # insort(seq, item) inserts item into seq so as to keep seq in ascending order. SIZE = 7 random.seed(1729) my_list = [] for i in range(SIZE): new_item = random.randrange(SIZE * 2) bisect.insort(my_list, new_item) print('%2d ->' % new_item, my_list)
def _push_entry(backend, entry): insort(backend, entry)
print("") from array import array a = array('H', [4000, 10, 700, 22222]) print(sum(a)) print(a[1:3]) from collections import deque d = deque(["task1", "task2", "task3"]) d.append("task4") print("Handling", d.popleft()) import bisect scores = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')] bisect.insort(scores, (300, 'ruby')) print(scores) from heapq import heapify, heappop, heappush data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0] heapify(data) # rearrange the list into heap order heappush(data, -5) # add a new entry print([heappop(data) for i in range(3)]) # fetch the three smallest entries print('') from decimal import * print(round(.70 * 1.05, 2)) print(round(Decimal('0.70') * Decimal('1.05'), 2)) getcontext().prec = 36
def step(self, policy_action=None): assert not self.done, 'Trying to step on an exhausted environment!' if self.normalise_action and policy_action is not None: np.multiply(policy_action, self.data_stats['a_std'], policy_action) # multiply by the std np.add(policy_action, self.data_stats['a_mean'], policy_action) # add the mean df = self.df now = df['Frame ID'] == self.frame vehicles = set( df[now]['Vehicle ID']) - self.vehicles_history - self._black_list[ self._t_slot] if vehicles: now_and_on = df['Frame ID'] >= self.frame for vehicle_id in vehicles: this_vehicle = df['Vehicle ID'] == vehicle_id car_df = df[this_vehicle & now_and_on] if len(car_df) < self.smoothing_window + 1: continue f = self.font[20] if self.display else None car = self.EnvCar(car_df, self.offset, self.look_ahead, self.screen_size[0], f, self.smoothing_window, dt=self.delta_t) self.vehicles.append(car) if self.controlled_car and \ not self.controlled_car['locked'] and \ self.frame >= self.controlled_car['frame'] and \ (self.controlled_car['v_id'] is None or vehicle_id == self.controlled_car['v_id']): self.controlled_car['locked'] = car car.is_controlled = True car.buffer_size = self.nb_states car.lanes = self.lanes car.look_ahead = self.look_ahead # print(f'Controlling car {car.id}') # self.dump_folder = f'{self._t_slot}_{car.id}' # print(f'Creating folder {self.dump_folder}') # system(f'mkdir -p screen-dumps/{self.dump_folder}') if self.store_sim_video: self.ghost = self.EnvCar(car_df, self.offset, self.look_ahead, self.screen_size[0], f, self.smoothing_window, dt=self.delta_t) self.vehicles_history |= vehicles # union set operation self.lane_occupancy = [[] for _ in range(7)] if self.show_frame_count: print(f'\r[t={self.frame}]', end='') for v in self.vehicles[:]: if v.off_screen: # print(f'vehicle {v.id} [off screen]') if self.state_image and self.store: file_name = os.path.join(self.data_dir, self.DUMP_NAME, os.path.basename(self._t_slot)) print(f'[dumping {v} in {file_name}]') v.dump_state_image(file_name, 'tensor') self.vehicles.remove(v) else: # Insort it in my vehicle list lane_idx = v.current_lane assert v.current_lane < self.nb_lanes, f'{v} is in lane {v.current_lane} at frame {self.frame}' bisect.insort(self.lane_occupancy[lane_idx], v) if self.state_image or self.controlled_car and self.controlled_car[ 'locked']: # How much to look far ahead look_ahead = MAX_SPEED * 1000 / 3600 * self.SCALE look_sideways = 2 * self.LANE_W self.render(mode='machine', width_height=(2 * look_ahead, 2 * look_sideways), scale=0.25) for v in self.vehicles: # Generate symbolic state lane_idx = v.current_lane left_vehicles = self._get_neighbours(lane_idx, -1, v) \ if 0 < lane_idx < 6 or lane_idx == 6 and v.front[0] > 18 * LANE_W else None mid_vehicles = self._get_neighbours(lane_idx, 0, v) right_vehicles = self._get_neighbours(lane_idx, + 1, v) \ if lane_idx < 5 or lane_idx == 5 and v.front[0] > 18 * LANE_W else None state = left_vehicles, mid_vehicles, right_vehicles # Sample an action based on the current state action = v.policy() if not v.is_autonomous else policy_action # Perform such action v.step(action) # Store state and action pair if (self.store or v.is_controlled) and v.valid: v.store('state', state) v.store('action', action) if v.is_controlled and v.valid: v.count_collisions(state) if v.collisions_per_frame > 0: self.collision = True # # Create set of off track vehicles # if v._colour[0] > 128: # one lane away # if v.id not in self.off_track: # print(f'Adding {v} to off_track set and saving it to disk') # self.off_track.add(v.id) # with open('off_track.pkl', 'wb') as f: # pickle.dump(self.off_track, f) # # Point out accidents (as in tracking bugs) in original trajectories # if self.frame == self.accident['frame']: # if v.id in self.accident['cars']: # v.collisions_per_frame = 1 # self.collision = True # if self.frame == self.accident['frame']: # print('Colliding vehicles:', self.accident['cars']) # self.accident = self.get_next_accident() # Keep the ghost updated if self.store_sim_video: if self.ghost and self.ghost.off_screen: self.ghost = None if self.ghost: self.ghost.step(self.ghost.policy()) self.frame += int(self.delta_t * 10) # Run out of frames? self.done = self.frame >= self.max_frame or self.user_is_done if self.controlled_car and self.controlled_car['locked']: return_ = self.controlled_car['locked'].get_last( n=self.nb_states, done=self.done, norm_state=self.normalise_state and self.data_stats, return_reward=self.return_reward, gamma=self.gamma, ) if return_: return return_ # return observation, reward, done, info return None, None, self.done, None
next_is_unicode = False for entry in line.split('"'): if next_is_glyph_name: glyph_name = entry.replace('-', '_') next_is_glyph_name = False if next_is_unicode: code = entry.replace(';', '').replace('&', '').replace( '#', '').replace('x', '') next_is_unicode = False if 'glyph-name=' in entry: next_is_glyph_name = True if 'unicode=' in entry: next_is_unicode = True if code != '' and glyph_name != '': t = (glyph_name, code, svg) bisect.insort(glyphs, t) in_file.close() # read fontawesomehash.cpp and write updated version to fontawesomehash.cpp_ cpp_file = os.path.join(project_path, 'src/lib/fontawesomehash.cpp') cpp_file_tmp = cpp_file + '_' in_file = open(cpp_file, 'r') out_file = open(cpp_file_tmp, 'w') in_auto = False glyph_names_added = [] fa_var_prefix = 'fa_' print('Upgrading %s...' % cpp_file, end='') for line in in_file.readlines(): if '// START AUTO-GENERATED' in line: in_auto = True
def write(self, entry, filename): self.out = StringIO() super(SortedCDXWriter, self).write(entry, filename) line = self.out.getvalue() if line: insort(self.sortlist, line)
def schedule(self, ticks, callable): if ticks > 0: bisect.insort(mae.event_q, Event(mae.tick + ticks, callable)) else: callable()
def _provides_inject(self, pkg): index = self._provides_index for atom in pkg.provides: # Use bisect.insort for ordered match results. bisect.insort(index[atom], pkg)
def insertChild(self, child): child.parent = self bisect.insort(self.children, (child.orderKey(), child))
def test_start_alignment(): dst_dir = '../aligned' tsc_dir_name = 'transcriptions' img_dir_name = 'images' map_dir_name = 'mapping' fnms = set(f.split('.')[0] for f in os.listdir(IMG_DIR)) fnms = sorted(fnms - set(os.listdir(dst_dir))) print("aligned so far: ", os.listdir(dst_dir)) # # this is the output data structure # { # filename: { # row_row_index: { # bbx: 'transcription' # ... # } # } # } # # for fnm in fnms: print('\n###### {} ######'.format(fnm)) stop = input("STOP alignment? [y/n] ") if stop == "y": break else: # output data structure bboxes2transcript = rec_defaultdict() images_path = os.path.join(dst_dir, fnm, img_dir_name) transcriptions_path = os.path.join(dst_dir, fnm, tsc_dir_name) mapping_path = os.path.join(dst_dir, fnm, map_dir_name) # load page image page_img_og = cv2.imread(os.path.join(IMG_DIR, fnm + IMG_EXT), cv2.IMREAD_GRAYSCALE) # cut capital letters at margin page_img, left_margin = remove_left_margin(page_img_og) # segment page image into lines img_lines = page_to_lines(page_img) # load GT transcription with open(os.path.join(TSC_DIR, fnm.split('_')[0] + TSC_EXT), 'r') as tsc_file: tsc_lines = tsc_file.readlines() if len(img_lines) != len(tsc_lines): raise AlignmentException( "Line mismatch: {} lines segmented, but transcription has {} lines" .format(len(img_lines), len(tsc_lines))) # # alignment begins # # for each line: transcription of line L, image of line L transcr2img = zip(tsc_lines[:], img_lines[:]) # testing specific lines try: lines_to_test = list( map(int, input("choose lines to test ").strip().split(','))) print(lines_to_test) except ValueError as v: print(v) lines_to_test = [] for row_ind, (tsc_line, (img_line, top_y)) in enumerate(transcr2img): if row_ind in lines_to_test or not lines_to_test: # # original: no dilatation or erosion # # spaces, center = spaces_in_line(img_line) (spaces, (first, last)), center = spaces_in_line_simple(img_line) num_spaces = len(tsc_line.split()) - 1 print('\n', " • ".join(tsc_line.split()), '\n') other_spaces = min((len(spaces) - num_spaces) // 2, 4) biggest_spaces = group_nearest_spaces( sorted(spaces, key=lambda e: -e[1] + e[0]))[:num_spaces + other_spaces] image_spaces = highlight_spaces_line(img_line, biggest_spaces, "red") # # manipulated: dilatation and erosion # (spaces_m, (first_m, last_m)), center_m = spaces_in_line_manipulated(img_line, discount=10) other_spaces_m = min((len(spaces_m) - num_spaces) // 2, 3) biggest_spaces_m = group_nearest_spaces( sorted(spaces_m, key=lambda e: -e[1] + e[0]))[:num_spaces + other_spaces_m] # image_spaces_m = highlight_spaces_line(img_line, biggest_spaces_m, "green") spaces_m_flatten = [ el for rng in intervals_to_ranges(biggest_spaces_m) for el in rng ] spaces_orig_flatten = [ el for rng in intervals_to_ranges(biggest_spaces) for el in rng ] # start of the line whitest_pnt_start = min( [(np.argmax(np.count_nonzero(img_line[:, 0:first] == 0, axis=0), axis=0), 0), (np.argmax(np.count_nonzero(img_line[:, 0:first_m] == 0, axis=0), axis=0), 1)], key=lambda e: e[0]) start_text = (0, whitest_pnt_start[0]) # end of the line end_left_pt = min(last_m, last) white_count_rev = np.count_nonzero(img_line[:, end_left_pt:], axis=0)[::-1] whitest_pnt_end = len(white_count_rev) - 1 - np.argmax( white_count_rev) + end_left_pt end_text = (whitest_pnt_end, img_line.shape[1]) #### # show_image(img_line[:, 0:first], name=str(whitest_pnt_start[1] == 0)[0] + ' ' + str(row_ind)) # show_image(img_line[:, 0:first_m], name=str(whitest_pnt_start[1] == 1)[0] + ' manip ' + str(row_ind)) # show_image(img_line[:, 0:max(start_text[1], 1)]) # show_image(img_line[:, end_text[0]:]) # # intersection # spaces_intersection = intersect1d(spaces_m_flatten, spaces_orig_flatten) spaces_intersect_intervals = [ (sp[0], sp[-1]) for sp in group_consecutive_values(spaces_intersection, threshold=1) if sp[-1] - sp[0] > 5 ] # spaces_intersect_intervals = group_nearest_spaces(sorted(spaces_intersect_intervals)) spaces_intersect_intervals_sorted = sorted( spaces_intersect_intervals, key=lambda e: -log(e[1] - e[0]) - count_white_ratio( image=img_line, interval_x=e)) spaces_intersect_intervals_sorted = remove_trailing_spaces( spaces_intersect_intervals_sorted, from_x=start_text[1] + 25, to_x=end_text[0] - 25) othersp = min( (len(spaces_intersect_intervals_sorted) - num_spaces) // 2, 3) spaces_intersect_intervals = sorted( spaces_intersect_intervals_sorted[:num_spaces + othersp]) # # difference # considering the interval as a hole not just set of consecutive pixels, so if part of an interval # is in difference then it is discarded # spaces_difference = setxor1d(spaces_m_flatten, spaces_orig_flatten) spaces_diff_intervals = [ (sp[0], sp[-1]) for row_ind, sp in enumerate( group_consecutive_values(spaces_difference, threshold=1)) if sp[0] - 1 not in spaces_orig_flatten and sp[0] - 1 not in spaces_m_flatten and sp[-1] + 1 not in spaces_orig_flatten and sp[-1] + 1 not in spaces_m_flatten ] spaces_diff_intervals.extend( spaces_intersect_intervals_sorted[num_spaces + othersp:]) spaces_diff_intervals = sorted(spaces_diff_intervals) # # transcriptions # # the biggest ones + starting and ending spaces_list = sorted([start_text] + spaces_intersect_intervals + [end_text]) # each word of this line found in the transcription words = tsc_line.split() words_widths_estimate = [] for ix, w in enumerate(words): previous_w = "" if ix == 0 else words[ix - 1] words_widths_estimate.append( estimate_word_width(w, previous_word=previous_w)) # # checking that intersection picked the right spaces # c = 0 while True: word_diffs = [] has_anomalous_width = False c += 1 # print(len(spaces_list)-1 == len(words)) for si in range(1, len(spaces_list)): try: left_word_estimate = words_widths_estimate[si - 1] except IndexError: # last word reached pass left_word_width = spaces_list[si][0] - spaces_list[ si - 1][1] left_word_diff = (left_word_estimate - left_word_width) / left_word_estimate word_diffs.append(left_word_diff) if abs(left_word_diff) >= 0.5: has_anomalous_width = True # print(si, "/", num_spaces, " •• ", left_word_diff, words[si-1]) # assert not has_anomalous_width if not has_anomalous_width: break # each space in space_list is associated with the word at its RIGHT (except the last one) words_widths_diffs = sorted( range(len(word_diffs)), key=lambda row_ind_w: word_diffs[row_ind_w]) widest = words_widths_diffs[0] narrowest = words_widths_diffs[-1] # any space to insert? eval_insertion = word_diffs[widest] best_candidate_insertion = None if eval_insertion < -0.5: sp_left = spaces_list[ widest] # spaces_list[widest - 1] sp_right = spaces_list[widest + 1] # spaces_list[widest] # between sp_left/right candidate_spaces = [ (s_start, s_end) for s_start, s_end in spaces_diff_intervals if sp_left[1] <= s_start and s_end <= sp_right[0] ] if candidate_spaces: # choosing the space that minimizes the difference between calculated and expected width for cand in candidate_spaces: diff_cand = abs((cand[0] - sp_left[1]) - words_widths_estimate[widest - 1]) diff_no_cand = abs( (sp_right[0] - sp_left[1]) - words_widths_estimate[widest - 1]) if diff_cand < diff_no_cand: best_candidate_insertion = cand # any space to remove? eval_removal = word_diffs[narrowest] eval_space_row_index = narrowest + 1 if eval_removal > 0.5 and eval_space_row_index + 1 < len( spaces_list): # narrowest/cand is between sp_left/right sp_left = spaces_list[eval_space_row_index - 1] sp_right = spaces_list[eval_space_row_index + 1] cand = spaces_list[eval_space_row_index] try: left_word_estimate = words_widths_estimate[ eval_space_row_index] except IndexError: pass # if minimizes the error (difference) if eval_removal > abs( (sp_right[0] - sp_left[1] - left_word_estimate)) / left_word_estimate: spaces_list.remove(cand) spaces_intersect_intervals.remove(cand) if best_candidate_insertion: insort(spaces_intersect_intervals, best_candidate_insertion) insort(spaces_list, best_candidate_insertion) spaces_diff_intervals.remove(best_candidate_insertion) # ensure no infinite loop if c > 5: break has_anomalous_width = False # END WHILE spaces_intersect_intervals = sorted(spaces_intersect_intervals) spaces_diff_intervals = sorted(spaces_diff_intervals) # # Second processing step evaluates weather a space in diff_intervals should be taken or not # take_spaces = spaces_intersect_intervals missings = num_spaces - len(take_spaces) if len(spaces_intersect_intervals) != num_spaces: # row_indexes of the nearest spaces in space_intersect to the ones in spaces_diff # if new spaces must be taken, these are placed in nearest_spaces nearest_spaces = [ argmin([ abs(center_space(its) - center_space(d)) for its in sorted(spaces_intersect_intervals) ]) for d in spaces_diff_intervals ] candidate_spaces = [] for candidate, near in zip(spaces_diff_intervals, nearest_spaces): left, right = None, None # candidate = tuple(map(np.int, candidate)) near_space = spaces_intersect_intervals[near] # candidate space is at the left of his nearest space (already taken) if candidate[1] <= near_space[0]: right = near_space[0] if near > 0: left = spaces_intersect_intervals[near - 1][1] else: left = start_text[1] # width of the next word if candidate space is taken # candidate_next_word_width = near_space[0] - candidate[1] estimated_width = words_widths_estimate[ near] # +1? # print("word ", words[near]) else: # candidate space is at the right of his nearest space (already taken) left = near_space[1] try: right = spaces_intersect_intervals[near + 1][0] except IndexError: right = end_text[0] assert right > left candidate_next_word_width = candidate[ 0] - near_space[1] try: estimated_width = words_widths_estimate[near + 1] except IndexError: print("## no near +1 ", near + 1) pass # keeps the last assignment # try: # estimated_next_word_width = words_widths_estimate[near + 2] # except IndexError: # estimated_next_word_width = 0 candidate_word_width = candidate[0] - left # current_word_width = right - left difference = abs(candidate_word_width - estimated_width) / estimated_width # print("estimated_next ", estimated_next_word_width) candidate_area = (candidate[1] - candidate[0]) * img_line.shape[0] / 2 white = count_white_in_interval(img_line, interval_x=candidate) candidate_spaces.append( (difference, white / candidate_area)) # END FOR candidate_spaces = sorted( [(idx, (csp, white)) for idx, (csp, white) in enumerate(candidate_spaces) if csp <= 0.5 and white >= 1.8], key=lambda e: e[1][0])[:missings] take_spaces.extend([ spaces_diff_intervals[c_row_index] for c_row_index, _ in candidate_spaces ]) image_spaces_taken = highlight_spaces_line( img_line, take_spaces, "magenta") take_spaces = sorted(take_spaces) # SOME INFO print( row_ind, ") words: {}, spaces found/expected: {}/{}\n".format( len(words), len(take_spaces), num_spaces)) # row_indexes of the spaces selected by the user selected_row_indexes = show_image_ask_spaces( image_spaces_taken, tot_spaces=len(take_spaces)) image_selected_spaces = highlight_spaces_line( img_line, [take_spaces[i] for i in selected_row_indexes], "blue") # draw missing spaces if any has_missing_spaces = input( "draw spaces? (empty = NO else int): ") selected_spaces = [] if has_missing_spaces: # valid input while not isinstance(eval(has_missing_spaces), int): has_missing_spaces = input( "insert number of spaces to insert: ") has_drawn = False # ask until the number of input spaces is correct while not has_drawn: print("draw and press 'q' to exit\n") try: num_missings = eval( has_missing_spaces) # to be inserted draw_missing_spaces(image_selected_spaces) drawn = get_drawn_spaces() # drawn spaces assert len(drawn) == num_missings for d_lft, d_rt in drawn: # inserted spaces overlaps start_text or end_text? if start_text[0] < d_lft <= start_text[1]: print("### inserted starting space") start_text = (start_text[0], np.argmax(np.count_nonzero( img_line[:, :d_lft], axis=0), axis=0)) elif end_text[0] <= d_rt < end_text[1]: print("### inserted ending space ", end_text) white_count_rev = np.count_nonzero( img_line[:, d_rt:], axis=0)[::-1] left_end = len( white_count_rev) - 1 - np.argmax( white_count_rev, axis=0) end_text = (left_end, end_text[1]) """ # the correct cutting columns is likely to be at the end of the line (and of the # selected sub-image) guard = min(end_text[1] - d_rt, 10) # argmax take the "first" max, so start scanning from the right white_count_rev = np.count_nonzero(img_line[:, d_rt + guard:], axis=0)[::-1] left_end = len(white_count_rev) - 1 - np.argmax(white_count_rev, axis=0)\ + d_rt + guard end_text = (left_end, end_text[1]) """ selected_spaces = sorted( [start_text] + [take_spaces[i] for i in selected_row_indexes] + drawn + [end_text]) # exit has_drawn = True except AssertionError: print( "\nERROR: number of drawn spaces != number of spaces requested, {} {}" .format(len(drawn), num_missings)) cv2.destroyAllWindows() else: selected_spaces = sorted( [start_text] + [take_spaces[i] for i in selected_row_indexes] + [end_text]) image_select_draw_spaces = highlight_spaces_line( img_line, selected_spaces, "red") show_image(image_select_draw_spaces, name="selected + drawn") #### # show_image(img_line[:, start_text[0]:start_text[1]], name="space before text") for sp in range(1, len(selected_spaces)): space_left = selected_spaces[sp - 1] space_right = selected_spaces[sp] # whitest column left try: left = np.argmax( np.count_nonzero( img_line[:, space_left[0]:space_left[1]], axis=0)) except ValueError: print(space_left[0], space_left[1], " attempt to get argmin of an empty sequence") left = 0 left += space_left[0] # whitest column right """ white_count_rev = np.count_nonzero(img_line[:, d_rt + guard:], axis=0)[::-1] left_end = len(white_count_rev) - 1 - np.argmax(white_count_rev, axis=0)\ + d_rt + guard end_text = (left_end, end_text[1]) """ try: if sp == len(selected_spaces) - 1: # last space? print("###### cutting the last space") white_count_rev = np.count_nonzero( img_line[:, space_right[0]:], axis=0)[::-1] right = len(white_count_rev) - 1 - np.argmax( white_count_rev) else: right = np.argmax( np.count_nonzero( img_line[:, space_right[0]:space_right[1]], axis=0)) except ValueError: # attempt to get argmin of an empty sequence print(space_right[0], space_right[1], " attempt to get argmax of an empty sequence") right = space_right[1] right += space_right[0] # left (start bbx x), top_y (start bbx y), width, height bbx_name = "{}_{}_{}_{}".format(left + left_margin, top_y, right - left, img_line.shape[0]) try: bboxes2transcript[row_ind][bbx_name] = words[sp - 1] show_image(img_line[:, left:right], name=words[sp - 1]) # print(words[sp - 1], '\n') except IndexError: print("words and index = ", sp - 1, " len(words) ", len(words)) print( "\n ••••••••••••••••••••••••••••••••••••••••••••••••••••••\n\n" )
# Like bisect, insort takes optional lo, hi arguments to limit the search to a sub-sequence. # There is also an insort_left variation that uses bisect_left to find insertion points. import bisect import random SIZE = 7 random.seed(1729) my_list = [] for i in range(SIZE): new_item = random.randrange(SIZE * 2) bisect.insort(my_list, new_item) # Insert x in a in sorted order. # This is equivalent to a.insert(bisect.bisect_left(a, x, lo, hi), x) assuming that # a is already sorted. Keep in mind that the O(log n) search is dominated by the slow O(n) insertion step. print('%2d ->' % new_item, my_list)
def addNum(self, num: int) -> None: insort(self.nums, num)
def generate_assignee_workloads(self, input_paths, output_paths): assigned_issues_timelines = {} unassigned_issues_timelines = {} workload_timelines = {} worklogs = self.generate_assignee_worklogs(input_paths, output_paths) for assignee, worklog in worklogs.items(): assigned_dates, issues_assigned_on, assigned_issues_timeline = ( self.extract_assigned_issues(assignee, worklog)) timeline_entry = { "assigned_dates": assigned_dates, "issues_assigned_on": issues_assigned_on, "assigned_issues_timeline": assigned_issues_timeline } # noqa assigned_issues_timelines[assignee] = timeline_entry unassigned_dates, issues_unassigned_on, unassigned_issues_timeline = ( # noqa self.extract_unassigned_issues(assignee, worklog)) timeline_entry = { "unassigned_dates": unassigned_dates, "issues_unassigned_on": issues_unassigned_on, "unassigned_issues_timeline": unassigned_issues_timeline } # noqa unassigned_issues_timelines[assignee] = timeline_entry workload_timeline = {} workload_dates = [] for date in assigned_dates: if workload_timeline.get(date) is None: bisect.insort(workload_dates, date) workload_timeline[date] = -1 for date in unassigned_dates: if workload_timeline.get(date) is None: bisect.insort(workload_dates, date) workload_timeline[date] = -1 assigned = 0 unassigned = 0 for date in workload_dates: if assigned_issues_timeline.get(date): assigned = assigned_issues_timeline[date] if unassigned_issues_timeline.get(date): unassigned = unassigned_issues_timeline[date] workload_timeline[date] = assigned - unassigned timeline_entry = { "workload_dates": workload_dates, "workload_timeline": workload_timeline } workload_timelines[assignee] = timeline_entry output_path = os.path.join(output_paths["cross_issue"], "workload_timelines.pickle") with open(output_path, 'wb') as fp: pickle.dump(workload_timelines, fp) output_path = os.path.join(output_paths["cross_issue"], "assigned_issues_timelines.json") self.save_dict_as_json(output_path, assigned_issues_timelines) output_path = os.path.join(output_paths["cross_issue"], "unassigned_issues_timelines.json") self.save_dict_as_json(output_path, unassigned_issues_timelines) output_path = os.path.join(output_paths["cross_issue"], "workloads_timelines.json") self.save_dict_as_json(output_path, workload_timelines) return workload_timelines
# -*- coding: utf-8 -*- # author:xls """ bisect模块实现二分查找和插入算法. """ import bisect x1= 200 x2= 500 list1 = [1, 3, 6, 24, 55, 78, 454, 555, 1234, 6900] list2 = [1, 3, 6, 24, 55, 78, 454, 555, 1234, 6900] ret1 = bisect.bisect(list1, x1) #获取插入位置 ret2 = bisect.insort(list2, x2) #返回插入结果 print("返回值:", ret1) print("list1 = ", list1) print("返回值:", ret2) print("list1 = ", list2)
import bisect list = [10, 20, 30] bisect.insort(list, 25) bisect.insort(list, 15) print list
def generate_reporter_reputations(self, input_paths, output_paths): open_issues_timelines = {} close_issues_timelines = {} reputation_timelines = {} worklogs = self.generate_reporter_worklogs(input_paths, output_paths) for reporter, worklog in worklogs.items(): open_dates, issues_opened_on, open_issues_timeline = ( self.extract_opened_issues(reporter, worklog)) timeline_entry = { "open_dates": open_dates, "issues_opened_on": issues_opened_on, "open_issues_timeline": open_issues_timeline } open_issues_timelines[reporter] = timeline_entry close_dates, issues_closed_on, close_issues_timeline = ( self.extract_closed_issues(reporter, worklog)) timeline_entry = { "close_dates": close_dates, "issues_closed_on": issues_closed_on, "close_issues_timeline": close_issues_timeline } close_issues_timelines[reporter] = timeline_entry reputation_timeline = {} reputation_dates = [] for date in open_dates: if reputation_timeline.get(date) is None: bisect.insort(reputation_dates, date) reputation_timeline[date] = -1 for date in close_dates: if reputation_timeline.get(date) is None: bisect.insort(reputation_dates, date) reputation_timeline[date] = -1 opened = 0 fixed = 0 for date in reputation_dates: if open_issues_timeline.get(date): opened = open_issues_timeline[date] if close_issues_timeline.get(date): fixed = close_issues_timeline[date] reputation_timeline[date] = (fixed / (opened + 1)) timeline_entry = { "reputation_dates": reputation_dates, "reputation_timeline": reputation_timeline } reputation_timelines[reporter] = timeline_entry output_path = os.path.join(output_paths["cross_issue"], "reputation_timelines.pickle") with open(output_path, 'wb') as fp: pickle.dump(reputation_timelines, fp) output_path = os.path.join(output_paths["cross_issue"], "open_issues_timelines.json") self.save_dict_as_json(output_path, open_issues_timelines) output_path = os.path.join(output_paths["cross_issue"], "close_issues_timelines.json") self.save_dict_as_json(output_path, close_issues_timelines) output_path = os.path.join(output_paths["cross_issue"], "reputation_timelines.json") self.save_dict_as_json(output_path, reputation_timelines) return reputation_timelines
from bisect import insort n = int(input()) k = int(input()) arr = [] for _ in range(n): #Insort is for when we insert new element we kept the array in the sorting order value = int(input()) insort(arr, value) minfairnes = 10**10 for i in range(n - k + 1): currentfairnes = arr[i + k - 1] - arr[i] if (currentfairnes < minfairnes): minfairnes = currentfairnes print(minfairnes)
def get_new_balancing_breakpoints(instance, active_hx, inactive_hx, weaken): new_th_breakpoints = {} new_thx_breakpoints = {} new_tc_breakpoints = {} new_tcx_breakpoints = {} active_th_indices = list(set((i, k) for i, _, k in active_hx[stream_hx])) active_tc_indices = list(set((j, k+1) for _, j, k in active_hx[stream_hx])) for index in active_th_indices: breakpoint = instance.th[index].value if breakpoint not in th_breakpoints[index]: bisect.insort(th_breakpoints[index], breakpoint) new_th_breakpoints[index] = breakpoint for index in active_hx[stream_hx]: breakpoint = instance.thx[index].value if breakpoint not in thx_breakpoints[index]: bisect.insort(thx_breakpoints[index], breakpoint) new_thx_breakpoints[index] = breakpoint for index in active_tc_indices: breakpoint = instance.tc[index].value if breakpoint not in tc_breakpoints[index]: bisect.insort(tc_breakpoints[index], breakpoint) new_tc_breakpoints[index] = breakpoint for index in active_hx[stream_hx]: breakpoint = instance.tcx[index].value if breakpoint not in tcx_breakpoints[index]: bisect.insort(tcx_breakpoints[index], breakpoint) new_tcx_breakpoints[index] = breakpoint if not weaken: for index in inactive_hx[stream_hx]: if instance.bh_out[index].value > 0.000001: breakpoint = instance.thx[index].value if breakpoint not in thx_breakpoints[index]: bisect.insort(thx_breakpoints[index], breakpoint) new_thx_breakpoints[index] = breakpoint if instance.bc_out[index].value > 0.000001: breakpoint = instance.tcx[index].value if breakpoint not in tcx_breakpoints[index]: bisect.insort(tcx_breakpoints[index], breakpoint) new_tcx_breakpoints[index] = breakpoint new_balancing_breakpoints = {} if not len(new_th_breakpoints) == 0: new_balancing_breakpoints['th'] = new_th_breakpoints if not len(new_thx_breakpoints) == 0: new_balancing_breakpoints['thx'] = new_thx_breakpoints if not len(new_tc_breakpoints) == 0: new_balancing_breakpoints['tc'] = new_tc_breakpoints if not len(new_tcx_breakpoints) == 0: new_balancing_breakpoints['tcx'] = new_tcx_breakpoints return new_balancing_breakpoints