def match_query(self, query): '''Given a search query, return a tuple containing a regex match and trigger object that matches the given query. If no match can be found, return a tuple of (None, None).''' sink = LifoQueue() while not self.triggers.empty(): trigger = self.triggers.get() match = trigger.pattern.match(query) if match: break else: sink.put(trigger) trigger = None while not sink.empty(): self.triggers.put(sink.get()) if trigger: self.triggers.put(trigger) return (match, trigger) return (None, None)
class AbstractMessageSender(metaclass=ABCMeta): #delegate this to a different class def __init__(self): self.message_q = LifoQueue() def send_message(self, message, sock): self.add_message(message) sock.sendall(message.message) def add_message(self, message): self.message_q.put(message)
def inorder_walk(a_root_node: BSTreeNode): node_stack = LifoQueue() current_item = a_root_node while True: while current_item: node_stack.put(current_item) current_item = current_item.left_child if node_stack.empty(): break tmp_item = node_stack.get() yield tmp_item current_item = tmp_item.right_child
def get_friends(inlist, output_path, subpath): ########## # task assignment ########## global lock lock = Lock() global q q = LifoQueue() # screen_name queue global friend_list friend_list = dict() with open("./twitter_api_keys.pydict", "r") as f: keys = eval(f.read()) # initiate task for crawler() for input in inlist: friend_list[input] = set() q.put({input_type: input, "count": 5000, "cursor": -1}) for key in keys: t = Thread(target=uid_crawler, kwargs={"key": key, "name": keys.index(key), "rest_url": "friends/ids"}) # t.daemon = True # time.sleep(2) t.start() q.join() # # RUN THIS AFTER FINISHED. try: mkdir("{}/{}".format(output_path, subpath)) except OSError: pass print("writing to disk.", end=".", flush=True) if subpath == 0: for key, vals in list(friend_list.items()): print(".", end="", flush=True) with BZ2File("{}/{}/{}.bz2".format(output_path, subpath, key), "w") as f: f.writelines(map(lambda item: (str(item) + "\n").encode("utf-8"), vals)) else: for key, vals in list(friend_list.items()): print(".", end="", flush=True) with ZipFile("{}/{}/{}.zip".format(output_path, subpath, str(key)[:3]), "a") as zf: zf.writestr(str(key), "\n".join([str(item) for item in vals]).encode("utf-8"), ZIP_LZMA) print("Done. Waiting remaining threads to quit", end=".", flush=True) while activeCount() > 1: print(activeCount(), end=".", flush=True) time.sleep(2) return friend_list
class ThreadedNormalWorker(object): def __init__(self, print_errors=False): self.print_errors = print_errors self.queue = LifoQueue() def get_url_bulk(self): normals = Normals.objects(access_success=False) for i in normals: self.queue.put(item=i) def grab_from_queue(self): while not self.queue.empty(): url = self.queue.get() normals_finder = NormalsSpider(url=url.url, print_errors=self.print_errors) normals_finder.update_normals_data() print(url.url) self.queue.task_done() def start(self, n_threads): self.get_url_bulk() for i in range(n_threads): thread = Thread(target=self.grab_from_queue()) thread.start() self.queue.join()
def __init__(self, name, start_url, list_of_urls, number_of_threads, delayed_request=False, max_allowed_error=10): super().__init__(name, start_url, number_of_threads, delay_request=delayed_request, max_err=max_allowed_error) self.url_list = list_of_urls self.task_queue = LifoQueue()
def __init__(self, size, **kwargs): if not isinstance(size, int): raise TypeError("Pool 'size' arg must be an integer") if not size > 0: raise ValueError("Pool 'size' arg must be greater than zero") logger.debug( "Initializing connection pool with %d connections", size) self._lock = threading.Lock() self._queue = LifoQueue(maxsize=size) self._thread_connections = threading.local() connection_kwargs = kwargs connection_kwargs['autoconnect'] = False for i in xrange(size): connection = Connection(**connection_kwargs) self._queue.put(connection) # The first connection is made immediately so that trivial # mistakes like unresolvable host names are raised immediately. # Subsequent connections are connected lazily. with self.connection(): pass
def __init__(self): QMainWindow.__init__(self) rec = QApplication.desktop().screenGeometry() self.w = rec.width() self.h = rec.height() self.kv = config.get('Settings', 'keys').split(' ') self.ki = 0 self.keys = self.kv[self.ki] self.rect = QRectF(0, 0, self.w, self.h) self.shortcuts = [] self.rects = LifoQueue() self.query = '' self.resize(self.w, self.h) self.setStyleSheet("background:rgba(0,0,0,%s)" % config.getfloat('Settings', 'background_opacity')) self.setAttribute(Qt.WA_TranslucentBackground); self.setWindowFlags(Qt.FramelessWindowHint); view = QGraphicsView(self) scene = QGraphicsScene() scene.setSceneRect(0, 0, self.w, self.h) view.setScene(scene) view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff); view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff); self.setCentralWidget(view) self.scene = scene self.drawLines() self.esc = QShortcut(QKeySequence('Esc'), self) self.esc.activated.connect(lambda: move(*config.get('Settings', 'mouse_home_coords').split(' '))) self.back = QShortcut(QKeySequence('Backspace'), self) self.back.activated.connect(self.goBack)
def __init__(self, conf, connection_class, **connection_kwargs): self.pid = os.getpid() self.conf = {"max": 0, "min": 1, "timeout": 0.1, "idle_timeout": 60, "max_lifetime": 30 * 60} if conf: self.conf.update(conf) self.connection_class = connection_class self.connection_kwargs = connection_kwargs self.pool = LifoQueue(self.conf["max"]) self.diet()
def breadth_first_search(start, goal): visited = [[False for x in range(500)] for y in range(500)] dad = [[None for x in range(500)] for y in range(500)] queue = Queue() visited[start.first()][start.second()] = True dad[start.first()][start.second()] = start current_node = start neighbours_ = neighbours(current_node) if not goal.first() - 10 <= current_node.first() <= goal.first() + 10 \ or not \ goal.second() - 10 <= current_node.second() <= goal.second() + 10: for i in range(neighbours_.__len__()): if visited[neighbours_[i].first()][neighbours_[i].second()] \ is False: queue.put(neighbours_[i]) visited[neighbours_[i].first()][neighbours_[i].second()] \ = True dad[neighbours_[i].first()][neighbours_[i].second()] \ = current_node while (not goal.first() - 10 <= current_node.first() <= goal.first() + 10 or not goal.second() - 10 <= current_node.second() <= goal.second() + 10) and not queue.empty(): current_node = queue.get_nowait() neighbours_ = neighbours(current_node) for i in range(neighbours_.__len__()): if visited[neighbours_[i].first()][neighbours_[i].second()] \ is False: queue.put(neighbours_[i]) visited[neighbours_[i].first()][neighbours_[i].second()] \ = True dad[neighbours_[i].first()][neighbours_[i].second()] \ = current_node path = LifoQueue() while not current_node.first() == start.first() \ or not current_node.second() == start.second(): path.put(current_node) current_node = dad[current_node.first()][current_node.second()] return path
class QueryQueue: def __init__(self): self.queue = LifoQueue() self.comm_sender = CommSender() th = threading.Thread(target=self.send_require) th.start() def put(self, item): self.queue.put(item) def send_require(self): while True: time.sleep(1) c = ConnInfo.objects.all()[0] q = QueryInfo.objects.all()[0] r = RoomInfo.objects.all()[0] # if is logout or unconnected, only flush queue if c.is_log == "False" or c.is_conn == "False": while not self.queue.empty(): self.queue.get() continue # else get last item and flush queue if not self.queue.empty(): query = self.queue.get() while not self.queue.empty(): self.queue.get() # m = ModeInfo.objects.all()[0] s = SensorInfo.objects.all()[0] ss = SettingInfo.objects.all()[0] if m.mode == 'cold' and ss.target_temp > s.current_temp: query = 'standby' elif m.mode == 'hot' and ss.target_temp < s.current_temp: query = 'standby' # q.query_speed = query q.save() r = self.comm_sender.send_msg(data={'type': 'require', 'source': r.room_number, 'speed': query}) # if query is standby, we should change to standby immediately if query == 'standby' and r.json()['ack_nak'] == 'ACK': q.current_speed = 'standby' q.query_speed = 'None' q.save()
def __init__(self, columns=2, rows=2, allowed_paths=[Path.up, Path.right, Path.down, Path.left], verbose=False): self._columns = columns self._rows = rows self._allowed_paths = allowed_paths self._verbose = verbose self._pos_x = 0 self._pos_y = 0 self._move_history = LifoQueue() self._last_move = None self._create_grid_matrix()
def benchmark_iterator(components: List[str], max_builds: int) -> Iterator: for component, category in showfast_iterator(components=components): curr_metric, curr_release = None, None queue = LifoQueue(maxsize=max_builds) for benchmark in get_benchmarks(component, category): if not benchmark['hidden']: release = parse_release(benchmark['build']) if curr_metric != benchmark['metric']: curr_metric, curr_release = benchmark['metric'], release queue.queue.clear() if release != curr_release: curr_release = release queue.queue.clear() if queue.full(): yield benchmark else: queue.put(benchmark)
def __init__(self): super().__init__() self._handling_lock = Lock() self._teardown_callback_stack = LifoQueue() # we execute callbacks in the reverse order that they were added self._logger = log.get_logger(__name__) self._handled_exceptions = Queue() # Set up a handler to be called when process receives SIGTERM. # Note: this will raise if called on a non-main thread, but we should NOT work around that here. (That could # prevent the teardown handler from ever being registered!) Calling code should be organized so that this # singleton is only ever initialized on the main thread. signal.signal(signal.SIGTERM, self._application_teardown_signal_handler) signal.signal(signal.SIGINT, self._application_teardown_signal_handler)
def __init__(self, name, start_url, list_of_url, number_of_threads, max_err=10, delay_request=False): # Constructor for BaseCrawler """ Crawler for the websites of type 0. :param list_of_url: List of URLs to start with. """ super().__init__(name, start_url, number_of_threads, max_err, delay_request) # Initialize data members self.task_queue = LifoQueue() self.url_list = list_of_url
class LifoExecutor: def __init__(self, executor, max_workers=None): self.executor = executor self.max_workers = max_workers or executor._max_workers self.queue = LifoQueue() self.loop = asyncio.get_event_loop() self.sem = asyncio.Semaphore(self.max_workers) def submit(self, f, *args): future = self.loop.create_future() self.queue.put((future, f, args)) self.loop.create_task(self.run_task()) return future async def run_task(self): await self.sem.acquire() future, f, args = self.queue.get() executor_future = self.loop.run_in_executor(self.executor, f, *args) executor_future.add_done_callback(lambda f, ff=future: self.done_callback(future, f)) def done_callback(self, future, executor_future): self.sem.release() future.set_result(executor_future.result())
def __init__(self, socket, maxrequests=1024): """ :param socket: connection to the server. The socket will be closed by the marshall on shutdown. :param maxrequests: sets an upper limit on the number of requests that can be sent to the server without receiving a response. Requests made beyond the limit will not be dropped but will instead wait for an earlier request to finish. Maximum possible value is 65535. :type maxrequests: unsigned 16bit integer (0 <= maxtag <= 65535) """ # the maximum length of a packet, including headers, that can be sent # by the marshall. Should be set after receiving a version response self.max_message_size = 0xffffffff self._socket = socket # queue of ``(type, request, on_error, on_success, sequential)`` tuples # for passing requests to the send thread. Adding false to the queue # will cause the send loop to exit self._send_queue = Queue() # queue of booleans used as a counter for the number of remaining # responses and stop the receive loop blocking on recv if no message is # expected # True indicates that a request has been sent and to expect a reply # False indicates that the receive loop should quit immediately self._recv_queue = Queue() # stack of available transaction tags that can be assigned to new # requests. # tags are used to identify the request that a response corresponds to. self._tags = LifoQueue(maxsize=maxrequests) for tag in range(1, maxrequests): self._tags.put(tag) # map from transaction tags (uint16) to completion callbacks self._callbacks = {} # responses to callbacks without tags are dispatched in the same order # the as the requests were submitted self._sequential_callbacks = Queue() self._send_thread = Thread(target=self._send_loop, daemon=True) self._send_thread.start() self._recv_thread = Thread(target=self._recv_loop, daemon=True) self._recv_thread.start()
def __init__(self, name, start_url, list_of_url, number_of_threads, delay_request=False, max_allowed_errors=3): """ :param name: As usual :param start_url: As usual :param list_of_url: As usual :param number_of_threads: As usual :param delay_request: As usual :param max_allowed_errors: As usual """ super().__init__(name, start_url, number_of_threads=number_of_threads, delay_request=delay_request, max_err=max_allowed_errors) self.url_list = list_of_url self.task_queue = LifoQueue()
def __init__(self, subscriptions, publications): # Create queues for communication with the rlpy world self.observations_queue = LifoQueue(1) # ROS updates constantly, keep only the last observation self.actions_queue = Queue() # Create the list of subscriptions so that the states can be # constructed from observations self.subscriptions = [] self.last_state = [] for subscription in subscriptions: self.last_state.append(0.0) sub = {} sub['index'] = len(self.subscriptions) # Index in the state vector sub['subscriber'] = rospy.topics.Subscriber( subscription['path'], subscription['type'], self.subscription_callback, sub ) sub['f'] = subscription.get('f', lambda x: x) self.subscriptions.append(sub) # Create the list of publications so that actions can be mapped to # publications self.publications = [] self.actions = [] for publication in publications: pub = {} pub['type'] = publication['type'] pub['publisher'] = rospy.topics.Publisher( publication['path'], publication['type'], queue_size=10 ) # Add an action descriptor so that actions can be taken for value in publication['values']: self.actions.append((pub, value)) self.publications.append(pub)
def __init__(self, com, port, maxlength = 100): self.maxlength = maxlength self._ring_buffer = deque([], maxlength) self._in_queue = LifoQueue() self._out_queue = Queue() self.com = com self.port = port # First, connect to the stream port self.com.connect(port, self._in_queue, self._out_queue, self._ring_buffer, self.on_data) self.lock = Lock() # lock for concurrent access to self.subscribers self.subscribers = []
def __init__(self, min_size, max_size=None): if not isinstance(min_size, int): raise TypeError('min_size should be int.') if max_size and not isinstance(max_size, int): raise TypeError('max_size should be int.') if min_size < 0: raise ValueError('min_size should be greater than 0.') if max_size and max_size < min_size: raise ValueError('max_size should be greater or equal to min_size.') self.__min_size = min_size self.__max_size = max_size or -1 self.__size = 0 self.__size_lock = threading.Lock() self.__closed = False self.__pool = LifoQueue()
def __init__(self): super().__init__() self._handling_lock = Lock() self._teardown_callback_stack = LifoQueue() # we execute callbacks in the reverse order that they were added self._logger = log.get_logger(__name__) self._handled_exceptions = Queue() self._teardown_callback_raised_exception = False # Set up handlers to be called when the application process receives certain signals. # Note: this will raise if called on a non-main thread, but we should NOT work around that here. (That could # prevent the teardown handler from ever being registered!) Calling code should be organized so that this # singleton is only ever initialized on the main thread. signal.signal(signal.SIGTERM, self._application_teardown_signal_handler) signal.signal(signal.SIGINT, self._application_teardown_signal_handler) try: signal.signal(self.SIGINFO, self._application_info_dump_signal_handler) except ValueError: self._logger.warning('Failed at registering signal handler for SIGINFO. This is expected if ClusterRunner' 'is running on Windows.')
def __init__(self): data_dir = player_get_data_dir() self.db_path = os.path.join(data_dir, "similarity.db") self.gaia_db_path = os.path.join(data_dir, "gaia.db") self.db_queue = PriorityQueue() self._db_wrapper = DatabaseWrapper() self._db_wrapper.daemon = True self._db_wrapper.set_path(self.db_path) self._db_wrapper.set_queue(self.db_queue) self._db_wrapper.start() self.create_db() self.network = LastFMNetwork(api_key=API_KEY) self.cache_time = 90 if GAIA: self.gaia_queue = LifoQueue() self.gaia_analyser = GaiaAnalysis( self.gaia_db_path, self.gaia_queue) self.gaia_analyser.daemon = True self.gaia_analyser.start()
def index(self, conf): session = requests.session() urls = LifoQueue() allowed_domains = conf['allowed_domains'].split(',') start = conf['url'] ignore = re.compile(conf['ignore']) found = set([start]) urls.put(start) while not urls.empty(): url = urls.get() r = session.get(url) for link in BeautifulSoup(r.content, 'lxml').find_all('a'): link_href = link.get('href') if not link_href: continue if link_href.startswith('/'): link_href = urljoin(url, link_href) parsed = urlparse(link_href) if parsed.hostname not in allowed_domains: continue if conf['ignore'] and ignore.match(link_href): continue if link_href not in found: found.add(link_href) urls.put(link_href) file = MemoryFile(r.content) file.url = url file.mimetype = 'text/html' file.size = 0 file.modified = None yield file
def __init__(self, parent, function, arguments, *, globals_=None, interfaces=()): self.parent = parent if globals_ is None: globals_ = {} if parent: self.stack = parent.stack self.blocks = parent.blocks self.frames = parent.frames self.globals = parent.globals self.interfaces = parent.interfaces else: self.stack = LifoQueue() self.blocks = LifoQueue() self.frames = LifoQueue() self.globals = globals_ self.interfaces = interfaces self.local_variables = {} self.function = function self.arguments = arguments self.index = 0
def load_triggers(self): '''Read from all the trigger definition files listed in config value TRIGGER_PATHS, and add them all to a LIFO queue.''' self.fallback = Trigger(url=app.config['DEFAULT_SEARCH'], pattern='') self.triggers = LifoQueue() count = 0 for filepath in app.config['TRIGGER_PATHS']: if not path.isfile(filepath): app.logger.warning('trigger path %s not found', filepath) continue with open(filepath) as f: triggers = json.loads(f.read()) if not isinstance(triggers, dict): app.logger.warning('trigger path %s has invalid structure', filepath) continue for pattern, value in triggers.items(): if isinstance(value, basestring): trigger = Trigger(url=value, pattern=pattern) elif isinstance(value, dict): trigger = Trigger(data=value, pattern=pattern) else: # don't know what to do with anything else atm continue self.triggers.put(trigger) count += 1 app.logger.info('loaded %d triggers', count)
class VideoAnalyzer: def __init__(self, config): self.q = LifoQueue() self.config = config self.photo_url = config["camera_settings"]["photo_url"] self.shape_detector = Detector(config) self.last_frame_data = None def load_video(self): while True: img_resp = requests.get(url=self.photo_url) im_arr = np.array(bytearray(img_resp.content), dtype=np.uint8) img = cv2.imdecode(im_arr, -1) # newX, newY = img.shape[1], img.shape[0] # img = cv2.resize(img, (int(newX), int(newY))) # cv2.imshow("AndroidCam", img) self.analyze(img) if cv2.waitKey(1) == 27: break def start_image_getting(self): t_imget = threading.Thread(target=self.image_get_thread, args=[self.q]) t_imget.start() def image_get_thread(self, q: LifoQueue): while True: img_resp = requests.get(url=self.photo_url) if q.full(): q.get() q.put(img_resp) def load_photo_once(self, path=None): if path is None: img_resp = requests.get(url=self.photo_url) # img_resp = self.q.get() im_arr = np.array(bytearray(img_resp.content), dtype=np.uint8) img = cv2.imdecode(im_arr, -1) else: img = cv2.imread(path) return self.analyze(img) def load_photo(self, path=None): if path is None: # img_resp = requests.get(url=self.photo_url) img_resp = self.q.get() im_arr = np.array(bytearray(img_resp.content), dtype=np.uint8) img = cv2.imdecode(im_arr, -1) else: img = cv2.imread(path) return self.analyze(img) def analyze(self, frame): # sd = ShapeDetector() try: frame_data = self.shape_detector.analyze_image( frame, self.config["camera_settings"]["resize"]) # print("board: " + str(frame_data[0]) + "\nmarker: " + str(frame_data[1]) + "\ntriangle: " + str(frame_data[2])) self.last_frame_data = frame_data return frame_data except ValueError as e: print("IMAGE ERROR") print(e) return self.last_frame_data
#Implementation of stack #Method 1 from queue import LifoQueue maxsize=4 stack=LifoQueue() i=1 #push while stack.qsize()<maxsize: stack.put(i) i+=1 print("Size:",stack.qsize()) #pop while stack.qsize()>0: print(stack.get()) print("Size:",stack.qsize()) #Method 2 from collections import deque stack = deque() #push stack.append('a') stack.append(2) print('Initial stack:',stack) #pop print(stack.pop()) print(stack.pop())
#Python Program to demostrate stack implementation #Using queue module from queue import LifoQueue #Initializing a stack stack = LifoQueue(maxsize=3) # qsize() show the number of element in the stack print(stack.qsize()) #push() function to push the elements to the stack stack.put('a') stack.put('b') stack.put('c') print(stack.qsize()) print(stack.full()) print(stack.empty()) #POP from stack print(stack.get()) print(stack.get()) print(stack.full()) stack.put('e') print(stack.full()) print(stack.qsize()) stack.get()
def __init__(self, manager, session): super().__init__() self.manager = manager self.api = YandexMusicApi(session) self.requests_queue = LifoQueue()
def pos_order_un_recur(root): """ stack_1: left right parent stack_2: parent right left need O(1) extra space :param root: :return: """ if root is None: return print('pos-ordered without recur: ', end='') stack_1 = LifoQueue() stack_2 = LifoQueue() stack_1.put(root) while not stack_1.empty(): root = stack_1.get() stack_2.put(root) if root.left is not None: stack_1.put(root.left) if root.right is not None: stack_1.put(root.right) while not stack_2.empty(): print(stack_2.get().data, end=' ')
class ImapConnectionPool(object): def __init__( self, account, host, port, username, password=None, ssl=True, timeout=DEFAULT_TIMEOUT, max_connections=DEFAULT_CONNECTIONS, max_attempts=DEFAULT_ATTEMPTS, ): self.account = account self.host = host self.port = port self.username = username self.password = password self.ssl = ssl self.timeout = timeout self.max_attempts = max_attempts self.pool = LifoQueue() # Push/start all the connections for _ in range(max_connections): self.pool.put(ImapConnectionWrapper(self)) def log(self, method, message): func = getattr(logger, method) func(f'[Account: {self.account}]: {message}') @contextmanager def get_connection(self, selected_folder=None): if not self.password: self.password = get_password('account', self.host, self.username) if not self.password: raise ConnectionSettingsError( self.account, 'Missing IMAP password! Please re-enter your password in settings.', ) connection = self.pool.get() self.log('debug', f'Got connection from pool: {self.pool.qsize()} (-1)') try: if selected_folder: connection.set_selected_folder(selected_folder) yield connection finally: try: if selected_folder: connection.unset_selected_folder() except Exception: self.log('warning', 'Failed to unselect folder!') self.pool.put(connection) self.log('debug', f'Returned connection to pool: {self.pool.qsize()} (+1)')
class CameraService(Service): """ Starts the OpenCV capturing and puts the frame in order in the FIFO queue """ def __init__(self, service_name=None, cam_id=0): super().__init__(service_name) _queue_size = 20 self._queue = LifoQueue(_queue_size) # self._queue_size = 20 # self._queue = Queue(self._queue_size) self.cam_id = cam_id self._capture = None self._open_capture() self._stop_event = threading.Event() self._do_capture = False def _open_capture(self): if isar.PLATFORM == "Windows": self._capture = cv2.VideoCapture(self.cam_id, cv2.CAP_DSHOW) width = 1920 height = 1080 self._capture.set(cv2.CAP_PROP_FRAME_WIDTH, width) self._capture.set(cv2.CAP_PROP_FRAME_HEIGHT, height) elif isar.PLATFORM == "Linux": self._capture = cv2.VideoCapture(self.cam_id, cv2.CAP_V4L2) self._capture.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc('M', 'J', 'P', 'G')) width = 1920 height = 1080 self._capture.set(cv2.CAP_PROP_FRAME_WIDTH, width) self._capture.set(cv2.CAP_PROP_FRAME_HEIGHT, height) else: # Darwin self._capture = cv2.VideoCapture(self.cam_id) # TODO: possibly for later # width = 1920 # height = 1080 # self._capture.set(cv2.CAP_PROP_FRAME_WIDTH, width) # self._capture.set(cv2.CAP_PROP_FRAME_HEIGHT, height) # self.capture.set(cv2.CAP_PROP_FPS, 24) if not self._capture.isOpened(): message = "Could not open camera {}".format(self.cam_id) raise Exception(message) def start(self): t = threading.Thread(name="CameraThread", target=self._start_capture) t.daemon = True t.start() def _start_capture(self): """ Read OpenCV frames and put them in the Queue. It blocks if the queue is full. """ if not self._capture.isOpened(): self._open_capture() frame_number = -1 while not self._stop_event.is_set(): if not self._do_capture: continue if self._queue.full(): # logger.warning("Camera _queue is full! continue.") continue # time.sleep(0.05) ret, frame = self._capture.read() if ret: frame_number += 1 camera_frame = CameraFrame(frame, frame_number) self._queue.put(camera_frame) else: logger.error("Capture was unsuccessful.") def stop(self): """ Stop capturing :return: """ self._stop_event.set() for i in range(100): try: self._queue.get_nowait() except: pass for i in range(100): try: self._queue.put_nowait(isar.POISON_PILL) except: pass # TODO: this hangs on stop! why? I don't know # self._capture.release() def release_capture(self): self._capture.release() def start_capture(self): self._do_capture = True def stop_capture(self): self._do_capture = False def get_frame(self, flipped_x=False, flipped_y=False): """ Return the frame from FIFO queue It blocks if the queue is empty. :return: """ if not self._do_capture: raise RuntimeError( "_do_capture is False. Have you forgotten to call start_capture() first?" ) if self._queue.empty(): # logger.warning("Camera _queue is empty! Return None.") return None camera_frame = self._queue.get() if flipped_x: camera_frame.flip(0) if flipped_y: camera_frame.flip(1) return camera_frame def get_camera_capture_size(self): if self._capture: width = int(self._capture.get(cv2.CAP_PROP_FRAME_WIDTH)) # float height = int(self._capture.get(cv2.CAP_PROP_FRAME_HEIGHT)) return width, height else: return None
class ScreenManagement(ScreenManager): pass # Config.set('kivy','window_icon','path/to/icon.ico') game = Builder.load_file("uno.kv") class MainGame(App): def build(self): return game MainGame().run() #SOCKET PART client = socket.socket() client.connect(('127.0.0.1', 8443)) message = LifoQueue() game_status = None client.send(username.encode('utf-8')) player_id = client.recv(2048).decode('utf-8') def send_to_server(): while True: while message.not_empty: send_message = { 'username' : username, 'action' : message.get() } client.send(json.dumps(send_message).encode('utf-8')) time.sleep(1) if tanda: break
if (home not in n) and (totalDist + streetDist < runDistance): route.put(n) print( "-------------------------route: ------------------------------" ) print(route.qsize()) '''temp = route i=0 while i < temp.qsize(): print(temp.get()) i = i+1''' adjacent.pop(0) totalDist += streetDist router(current, adjacent, runDistance) elif (home in n) and (totalDist + streetDist == runDistance): route.put(n) allRoutes.put(route) route.get() if __name__ == "__main__": app.run(debug=False) home = (40.006066, -83.009263) route = LifoQueue() allRoutes = LifoQueue() totalDist = 0 streetDist = 1 runDistance = 4 adjStreet = sweep(home, 0.00005) router(adjStreet)
def __init__(self): self.stack = Stack() self.top = None
class Sudoku: def __init__(self, data): # 数据初始化(二维的object数组) self.value = np.array([[0] * 9] * 9, dtype=object) # 数独的值,包括未解决和已解决的 self.new_points = Queue() # 先进先出,新解(已解决值)的坐标 self.recorder = LifoQueue() # 先进后出,回溯器 self.guess_times = 0 # 猜测次数 # 九宫格的基准列表 self.base_points = [[0, 0], [0, 3], [0, 6], [3, 0], [3, 3], [3, 6], [6, 0], [6, 3], [6, 6]] # 整理数据 _data = np.array(data).reshape(9, -1) for r in range(0, 9): for c in range(0, 9): if _data[r, c]: # if not Zero # numpy default is int32, convert to int self.value[r, c] = int(_data[r, c]) # 新的确认的值添加到列表中,以便遍历 self.new_points.put((r, c)) # logger.debug(f'init: answer={self.value[r, c]} at {(r, c)}') else: # if Zero, guess no. is 1-9 self.value[r, c] = [1, 2, 3, 4, 5, 6, 7, 8, 9] # 剔除数字 def _cut_num(self, point): r, c = point val = self.value[r, c] # 行 for i, item in enumerate(self.value[r]): if isinstance(item, list): if item.count(val): item.remove(val) # 判断移除后,是否剩下一个元素 if len(item) == 1: self.new_points.put((r, i)) # 添加坐标到“已解决”列表 # logger.debug(f'only one in row: answer={self.value[r, i]} at {(r, i)}') self.value[r, i] = item[0] # 列 for i, item in enumerate(self.value[:, c]): if isinstance(item, list): if item.count(val): item.remove(val) # 判断移除后,是否剩下一个元素 if len(item) == 1: self.new_points.put((i, c)) # logger.debug(f'only one in col: answer={self.value[i, c]} at {(i, c)}') self.value[i, c] = item[0] # 所在九宫格(3x3的数组) b_r, b_c = map(lambda x: x // 3 * 3, point) # 九宫格基准点 for m_r, row in enumerate(self.value[b_r:b_r + 3, b_c:b_c + 3]): for m_c, item in enumerate(row): if isinstance(item, list): if item.count(val): item.remove(val) # 判断移除后,是否剩下一个元素 if len(item) == 1: r = b_r + m_r c = b_c + m_c self.new_points.put((r, c)) # logger.debug(f'only one in block: answer={self.value[r, c]} at {(r, c)}') self.value[r, c] = item[0] # 同一行、列或九宫格中, List里,可能性只有一个的情况 def _check_one_possbile(self): # 同一行只有一个数字的情况 for r in range(0, 9): # 只取出是这一行是List的格子 values = list(filter(lambda x: isinstance(x, list), self.value[r])) for c, item in enumerate(self.value[r]): if isinstance(item, list): for value in item: if sum(map(lambda x: x.count(value), values)) == 1: self.value[r, c] = value self.new_points.put((r, c)) # logger.debug(f'list val is only one in row: answer={self.value[r, c]} at {(r, c)}') return True # 同一列只有一个数字的情况 for c in range(0, 9): values = list( filter(lambda x: isinstance(x, list), self.value[:, c])) for r, item in enumerate(self.value[:, c]): if isinstance(item, list): for value in item: if sum(map(lambda x: x.count(value), values)) == 1: self.value[r, c] = value self.new_points.put((r, c)) # logger.debug(f'list val is only one in col: answer={self.value[r, c]} at {(r, c)}') return True # 九宫格内的单元格只有一个数字的情况 for r, c in self.base_points: # reshape: 3x3 改为1维数组 values = list( filter(lambda x: isinstance(x, list), self.value[r:r + 3, c:c + 3].reshape(1, -1)[0])) for m_r, row in enumerate(self.value[r:r + 3, c:c + 3]): for m_c, item in enumerate(row): if isinstance(item, list): for value in item: if sum(map(lambda x: x.count(value), values)) == 1: self.value[r + m_r, c + m_c] = value self.new_points.put((r + m_r, c + m_c)) return True # 同一个九宫格内数字在同一行或同一列处理(同行列隐性排除) def _check_same_num(self): for b_r, b_c in self.base_points: block = self.value[b_r:b_r + 3, b_c:b_c + 3] # 判断数字1~9在该九宫格的分布情况 _data = block.reshape(1, -1)[0] for i in range(1, 10): result = map( lambda x: 0 if not isinstance(x[1], list) else x[0] + 1 if x[1].count(i) else 0, enumerate(_data)) result = list(filter(lambda x: x > 0, result)) r_count = len(result) if r_count in [2, 3]: # 2或3个元素才有可能同一行或同一列 rows = list(map(lambda x: (x - 1) // 3, result)) cols = list(map(lambda x: (x - 1) % 3, result)) if len(set(rows)) == 1: # 同一行,去掉其他行的数字 result = list(map(lambda x: b_c + (x - 1) % 3, result)) row = b_r + rows[0] for col in range(0, 9): if not col in result: item = self.value[row, col] if isinstance(item, list): if item.count(i): item.remove(i) # 判断移除后,是否剩下一个元素 if len(item) == 1: self.new_points.put((row, col)) self.value[row, col] = item[0] return True elif len(set(cols)) == 1: # 同一列 result = list(map(lambda x: b_r + (x - 1) // 3, result)) col = b_c + cols[0] for row in range(0, 9): if not row in result: item = self.value[row, col] if isinstance(item, list): if item.count(i): item.remove(i) # 判断移除后,是否剩下一个元素 if len(item) == 1: self.new_points.put((row, col)) self.value[row, col] = item[0] return True # 排除法解题 def sudo_exclude(self): is_run_same = True is_run_one = True while is_run_same: while is_run_one: # 剔除数字 while not self.new_points.empty(): point = self.new_points.get() # 先进先出 self._cut_num(point) # 检查List里值为单个数字的情况,如有新answer则加入new_points Queue,立即_cut_num is_run_one = self._check_one_possbile() # 检查同行或列的情况 is_run_same = self._check_same_num() is_run_one = True # 得到有多少个确定的数字 def get_num_count(self): return sum( map(lambda x: 1 if isinstance(x, int) else 0, self.value.reshape(1, -1)[0])) # 评分,找到最佳的猜测坐标 def get_best_point(self): best_score = 0 best_point = (0, 0) for r, row in enumerate(self.value): for c, item in enumerate(row): point_score = self._get_point_score((r, c)) if best_score < point_score: best_score = point_score best_point = (r, c) return best_point # 计算某坐标的评分 def _get_point_score(self, point): # 评分标准 (10-候选个数) + 同行确定数字个数 + 同列确定数字个数 r, c = point item = self.value[r, c] if isinstance(item, list): score = 10 - len(item) score += sum( map(lambda x: 1 if isinstance(x, int) else 0, self.value[r])) score += sum( map(lambda x: 1 if isinstance(x, int) else 0, self.value[:, c])) return score else: return 0 # 验证有没错误 def check_value(self): # 行 r = 0 for row in self.value: nums = [] lists = [] for item in row: (lists if isinstance(item, list) else nums).append(item) if len(set(nums)) != len(nums): return False # 数字要不重复 if len(list(filter(lambda x: len(x) == 0, lists))): return False # 候选列表不能为空集 r += 1 # 列 for c in range(0, 9): nums = [] lists = [] col = self.value[:, c] for item in col: (lists if isinstance(item, list) else nums).append(item) if len(set(nums)) != len(nums): return False # 数字要不重复 if len(list(filter(lambda x: len(x) == 0, lists))): return False # 候选列表不能为空集 # 九宫格 for b_r, b_c in self.base_points: nums = [] lists = [] block = self.value[b_r:b_r + 3, b_c:b_c + 3].reshape(1, -1)[0] for item in block: (lists if isinstance(item, list) else nums).append(item) if len(set(nums)) != len(nums): logger.debug(f'verify failed. dup in block {b_r, b_c}') return False # 数字要不重复 if len(list(filter(lambda x: len(x) == 0, lists))): return False # 候选列表不能为空集 return True # 猜测记录 def record_guess(self, point, index=0): # 记录 recorder = Recorder() recorder.point = point recorder.point_index = index # recorder.value = self.value.copy() #numpy的copy不行 recorder.value = copy.deepcopy(self.value) self.recorder.put(recorder) self.guess_times += 1 # 记录猜测次数 # 新一轮的排除处理 item = self.value[point] # assume only 1 in this point self.value[point] = item[index] self.new_points.put(point) self.sudo_exclude() # 回溯,需要先进后出 def recall(self): while True: if self.recorder.empty(): raise Exception('Sudo is wrong, no answer!') else: recorder = self.recorder.get() point = recorder.point index = recorder.point_index + 1 item = recorder.value[point] # 判断索引是否超出范围 # if not exceed,则再回溯一次 if index < len(item): break self.value = recorder.value self.record_guess(point, index) # Main function 解题 def sudo_solve(self): self.sudo_exclude() # 检查有没错误的,有错误的则回溯;没错误却未解开题目,则再猜测 while True: if self.check_value(): fixed_answer = self.get_num_count() if fixed_answer == 81: break else: # 获取最佳猜测点 point = self.get_best_point() # 记录并处理 self.record_guess(point) else: # 出错,则回溯,尝试下一个猜测 self.recall()
def tputs(out, str_, *args): """Print the given terminal capabilities :param out: Output stream :type out: _io._TextIOBase :param str_: the capability to output :type str_: str :param args: optional parameters :raises IOError: if an error occurs """ index = 0 length = len(str_) ifte = IFTE_NONE do_exec = True stack = LifoQueue() params = list(args) # unfreeze args while index < length: ch = str_[index] index += 1 if ch == '\\': ch = str_[index] index += 1 if '0' <= ch <= '9': raise Exception('Unsupported operation %s' % ch) # TODO: define UnsupportedOperationException else: if ch == 'e' or ch == 'E': # or ch.lower() == 'e', it's not important if do_exec: out.write(unichr(27)) elif ch == 'n': out.write('\n') elif ch == 'r': if do_exec: out.write('\r') elif ch == 't': if do_exec: out.write('\t') elif ch == 'b': if do_exec: out.write('\b') elif ch == 'f': if do_exec: out.write('\f') elif ch == 's': if do_exec: out.write(' ') elif ch == ':' or ch == '^' or ch == '\\': if do_exec: out.write(ch) else: raise Exception('Illegal argument %s at ind %d' % (ch, index)) elif ch == '^': ch = str_[index] index += 1 if do_exec: out.write(unichr(ord(ch) - ord('@'))) elif ch == '%': ch = str_[index] index += 1 if ch == '%': if do_exec: out.write('%') elif ch == 'p': ch = str_[index] index += 1 if do_exec: stack.put(params[ord(ch) - ord('1')]) elif ch == 'P': ch = str_[index] index += 1 if 'a' <= ch <= 'z': if do_exec: Curses.__dv[ord(ch) - ord('a')] = stack.get() elif 'A' <= ch <= 'Z': if do_exec: Curses.__sv[ord(ch) - ord('A')] = stack.get() else: raise Exception('Illegal argument %s at ind %d' % (ch, index)) elif ch == 'g': ch = str_[index] index += 1 if 'a' <= ch <= 'z': if do_exec: stack.put(Curses.__dv[ord(ch) - ord('a')]) elif 'A' <= ch <= 'Z': if do_exec: stack.put(Curses.__sv[ord(ch) - ord('A')]) else: raise Exception('Illegal argument %s at ind %d' % (ch, index)) elif ch == '\'': ch = str_[index] index += 1 if do_exec: stack.put(ord(ch)) ch = str_[index] index += 1 if do_exec: raise Exception('Illegal argument %s at ind %d' % (ch, index)) elif ch == '{': start = index while str_[index] != '}': index += 1 if do_exec: v = int(str_[start:index-1]) stack.put(v) elif ch == 'l': if do_exec: stack.put(len(text_type(stack.get()))) elif ch == '+': if do_exec: v2 = int(stack.get()) v1 = int(stack.get()) stack.put(v1 + v2) elif ch == '-': if do_exec: v2 = int(stack.get()) v1 = int(stack.get()) stack.put(v1 - v2) elif ch == '*': if do_exec: v2 = int(stack.get()) v1 = int(stack.get()) stack.put(v1 * v2) elif ch == '/': if do_exec: v2 = int(stack.get()) v1 = int(stack.get()) stack.put(v1 / v2) elif ch == 'm': if do_exec: v2 = int(stack.get()) v1 = int(stack.get()) stack.put(v1 % v2) elif ch == '&': if do_exec: v2 = int(stack.get()) v1 = int(stack.get()) stack.put(v1 & v2) elif ch == '|': if do_exec: v2 = int(stack.get()) v1 = int(stack.get()) stack.put(v1 | v2) elif ch == '^': if do_exec: v2 = int(stack.get()) v1 = int(stack.get()) stack.put(v1 ^ v2) elif ch == '=': if do_exec: v2 = int(stack.get()) v1 = int(stack.get()) stack.put(v1 == v2) elif ch == '>': if do_exec: v2 = int(stack.get()) v1 = int(stack.get()) stack.put(v1 > v2) elif ch == '<': if do_exec: v2 = int(stack.get()) v1 = int(stack.get()) stack.put(v1 < v2) elif ch == 'A': if do_exec: v2 = int(stack.get()) v1 = int(stack.get()) stack.put(v1 != 0 and v2 != 0) elif ch == 'O': if do_exec: v2 = int(stack.get()) v1 = int(stack.get()) stack.put(v1 != 0 or v2 != 0) elif ch == '!': if do_exec: v1 = int(stack.get()) stack.put(v1 == 0) elif ch == '~': if do_exec: v1 = int(stack.get()) stack.put(~v1) elif ch == '?': if ifte != IFTE_NONE: raise Exception('Illegal argument %s at ind %d' % (ch, index)) else: ifte = IFTE_IF elif ch == 't': if ifte != IFTE_IF and ifte != IFTE_ELSE: raise Exception('Illegal argument %s at ind %d' % (ch, index)) else: ifte = IFTE_THEN do_exec = int(stack.get()) != 0 elif ch == 'e': if ifte != IFTE_THEN: raise Exception('Illegal argument %s at ind %d' % (ch, index)) else: ifte = IFTE_ELSE do_exec = not do_exec elif ch == ';': if ifte == IFTE_NONE or ifte == IFTE_IF: raise Exception('Illegal argument %s at ind %d' % (ch, index)) else: ifte = IFTE_NONE do_exec = True elif ch == 'i': if len(params) >= 1: params[0] = int(params[0]) + 1 if len(params) >= 2: params[1] = int(params[1]) + 1 elif ch == 'd': out.write(text_type(int(stack.get()))) else: raise Exception('Illegal argument %s at ind %d' % (ch, index)) elif ch == '$': if str_[index] == '<': while str_[index] != '>': index += 1 else: if do_exec: out.write(ch) else: if do_exec: out.write(ch)
class MainApp(ttk.Frame): def __init__(self, parent): ttk.Frame.__init__(self, parent) self.queue = LifoQueue() self.grid(column = 0, row = 0) self.dirbutton = ttk.Button(self, text='開啟資料夾', command=self.askdirectory) self.dirbutton.grid(column = 0, row = 0, sticky = (tkinter.W, tkinter.E)) ttk.Label(self, text="路徑:").grid(column = 1, row = 0, sticky = (tkinter.W, tkinter.E)) self.dirinput = ttk.Entry(self, width=60) self.dirinput.grid(column = 2, row = 0, sticky = (tkinter.W,tkinter.E)) self.runbutton = ttk.Button(self, text="執行", command = self.analysisrun) self.runbutton.grid(column = 0, row = 1, sticky = (tkinter.W, tkinter.E)) self.actionlabel = ttk.Label(self) self.actionlabel.grid(column = 1, row = 1, sticky=(tkinter.W, tkinter.E)) self.filelabel = ttk.Label(self) self.filelabel.grid(column = 2, row = 1, sticky=(tkinter.W, tkinter.E)) self.outputarea = scrolledtext.ScrolledText(self, height = 15, width = 80) self.outputarea.grid(column = 0, row = 2, columnspan = 3) self.maindic = {} self.filedic = {} def analysisrun(self): maindir = self.dirinput.get() resultdirpath = pathlib.Path(maindir + "\\result") if not resultdirpath.is_dir(): resultdirpath.mkdir() self.setactionlabel("讀取檔案中....") beforefileread = time.time() self.update_idletasks() self.fill_dic_with_refresh(maindir) afterfileread = time.time() #write crude data self.setactionlabel("尋找breast cancer:") self.update() for k in self.maindic.keys(): self.update() invfname = maindir + "\\result" + "\\" + k + "inv.json" cisfname = maindir+ "\\result" + "\\" + k + "cis.json" invasive_raw = [] cis_raw = [] for item in self.maindic[k]: if not item[0].isdigit(): continue else: self.update() self.setfilelabel(item) self.outputarea.see(tkinter.END) currentreport = reportreader.read_report_text(self.filedic[item]) currentclass = breastanalysis.breast_classify(currentreport) ihcresult = breastanalysis.find_erprher(currentreport) if not currentclass: continue if currentclass[0] == breastmacro.BREAST and currentclass[1] == breastmacro.INVASIVE_CARCINOMA: invdic = {} if ihcresult[breastmacro.ER]: invdic[breastmacro.ER] = list(ihcresult[breastmacro.ER]) else: invdic[breastmacro.ER] = None if ihcresult[breastmacro.PR]: invdic[breastmacro.PR] = list(ihcresult[breastmacro.PR]) else: invdic[breastmacro.PR] = None if ihcresult[breastmacro.AR]: invdic[breastmacro.AR] = list(ihcresult[breastmacro.AR]) else: invdic[breastmacro.AR] = None invdic[breastmacro.HERTWO] = ihcresult[breastmacro.HERTWO] invdic[reportreader.ORGANNAME] = breastmacro.BREAST invdic[breastmacro.BREASTCLASS] = breastmacro.INVASIVE_CARCINOMA invdic[reportreader.DIAGNOSIS] = currentclass[2] invdic[reportreader.PATHOLOGYNO] = item invasive_raw.append(invdic) outputstr = "找到乳癌: {0}, cell type: {5}, ER: {1}, PR: {2}, AR: {3}, Her-2: {4}\n".format(item, invdic[breastmacro.ER], invdic[breastmacro.PR], invdic[breastmacro.AR], invdic[breastmacro.HERTWO], currentclass[2]) self.tooutput(outputstr) self.update() if currentclass[0] == breastmacro.BREAST and currentclass[1] == breastmacro.CIS: cisdic = {} if ihcresult[breastmacro.ER]: cisdic[breastmacro.ER] = list(ihcresult[breastmacro.ER]) else: cisdic[breastmacro.ER] = None if ihcresult[breastmacro.PR]: cisdic[breastmacro.PR] = list(ihcresult[breastmacro.PR]) else: cisdic[breastmacro.PR] = None cisdic[reportreader.ORGANNAME] = breastmacro.BREAST cisdic[breastmacro.BREASTCLASS] = breastmacro.CIS cisdic[reportreader.DIAGNOSIS] = currentclass[2] cisdic[reportreader.PATHOLOGYNO] = item cis_raw.append(cisdic) self.update() with open(invfname, encoding="utf-8", mode="w") as f: json.dump(invasive_raw, f) with open(cisfname, encoding="utf-8", mode="w") as f: json.dump(cis_raw, f) self.update() afteranalysis = time.time() self.setactionlabel("統計結果中") self.update_idletasks() listrawinv = list(resultdirpath.glob("*inv.json")) csvpath = maindir + "\\result\\result.csv" with open(csvpath, mode = "w", encoding = "utf-8", newline="") as csvfile: spamwriter = csv.writer(csvfile) spamwriter.writerow(["月份", "total invasive", "ER positive", "PR positive", "AR positive", "HER2 score 0", "HER2 score 1+", "HER2 score 2+", "HER2 score 3+"]) for item in listrawinv: itemcsv = maindir + "\\result\\" + item.name[:5] + "invlist.csv" currentmonth = item.name[:5] with item.open(mode = "r", encoding="utf-8") as f: itemdata = json.load(f) #print(item) with open(itemcsv, mode = "w", encoding = "utf-8", newline="") as itemcsvfile: secondspamwriter = csv.writer(itemcsvfile) for data in itemdata: secondspamwriter.writerow([data[reportreader.PATHOLOGYNO], data[reportreader.DIAGNOSIS], "ER:{0}".format(data[breastmacro.ER]), "PR:{0}".format(data[breastmacro.PR]), "AR:{0}".format(data[breastmacro.AR]), "Her-2:{}".format(data[breastmacro.HERTWO])]) ihcdata = take_monthlist_data_inv(itemdata) spamwriter.writerow([currentmonth] + list(ihcdata)) resultrow = ["total invasive", "ER positive", "PR positive", "AR positive", "HER2 score 0", "HER2 score 1+", "HER2 score 2+", "HER2 score 3+"] outputstr = "Month: {0}".format(currentmonth) for (k,v) in enumerate(resultrow): try: outputstr = outputstr + " {0}:{1}\n".format(v, ihcdata[k]) except IndexError: continue self.tooutput(outputstr) self.update_idletasks() self.outputarea.see(tkinter.END) outputstr = "讀檔案總共花:{0}秒,分析總共花: {1}秒".format(afterfileread-beforefileread, afteranalysis-afterfileread) self.tooutput(outputstr) self.update_idletasks() self.outputarea.see(tkinter.END) def askdirectory(self): self.dirinput.delete(0, "end") self.dirinput.insert(0, filedialog.askdirectory()) def setfilelabel(self, txt): self.filelabel.config(text = txt) def setactionlabel(self, txt): self.actionlabel.config(text = txt) def tooutput(self, txt): self.outputarea.insert(tkinter.INSERT, txt) def refresh(self): self.update() print("refresh") if not self.queue.empty(): txt = self.queue.qsize() print(txt) self.setfilelabel(txt) self.update() self.after(500, self.refresh) def fill_dic_with_refresh(self, maindir): t = Thread(target = self.fill_dic, args=[maindir]) t.start() while True: txt = self.queue.get() self.setfilelabel(txt) self.update() self.update_idletasks() if not t.is_alive(): break def fill_dic(self, maindir): self.maindic, self.filedic = readlist.make_dic_from_folder(maindir, self.queue)
def __init__(self, config): self.q = LifoQueue() self.config = config self.photo_url = config["camera_settings"]["photo_url"] self.shape_detector = Detector(config) self.last_frame_data = None
def image_get_thread(self, q: LifoQueue): while True: img_resp = requests.get(url=self.photo_url) if q.full(): q.get() q.put(img_resp)
# print(q.get_nowait()) #queue.Empty # Queue(3) => 指定队列长度, 元素个数只能是3个; q2 = Queue(3) q2.put(1000) q2.put(2000) q2.put(3000) # q2.put(4000) #阻塞 # q2.put_nowait(6000) 报错 # (2) LifoQueue # """先进后出,后进先出(栈的特点)""" from queue import LifoQueue lq = LifoQueue() lq.put(100) lq.put(101) lq.put(102) print(lq.get()) #102 print(lq.get()) #101 print(lq.get()) #100 print('-----------------1') # (3) PriorityQueue # """按照优先级顺序进行排序存放(默认从小到大)""" # """在一个优先级队列中,要放同一类型的数据,不能混合使用""" from queue import PriorityQueue pq = PriorityQueue()
def val_rpn(self, tokens): if not tokens: return 0 q = LifoQueue() for i in tokens: for i in ['+', '-', '*', '/']: o2 = q.get() o1 = q.get() if i == '+': q.put(o1 + o2) elif i == '-': q.put(o1 - o2) elif i == '*': q.put(o1 * o2) elif i == '/': q.put(-(-o1 // o2) if o1 * o2 < 0 else o1 // o2) else: q.put(int(i)) return q.get()
import sys import random import numpy as np from queue import LifoQueue # from playsound import playsound as ps bst_fst_sucStack_h1 = LifoQueue() bst_fst_sucStack_h2 = LifoQueue() bst_fst_sucStack_h3 = LifoQueue() arg_err_msg = 'Sorry, your input puzzle wasn\'t formatted correcty. It should be a permutation of the form: 1 2 3 4 5 6 7 8 _' mhtn = { 1: [0, 1, 2, 1, 2, 3, 2, 3, 4], 2: [1, 0, 1, 2, 1, 2, 2, 2, 3], 3: [2, 1, 0, 3, 2, 1, 4, 3, 2], 4: [1, 2, 3, 0, 1, 2, 1, 2, 3], 5: [2, 1, 2, 1, 0, 1, 2, 1, 2], 6: [3, 2, 1, 2, 1, 0, 3, 2, 1], 7: [2, 3, 4, 1, 2, 3, 0, 1, 2], 8: [3, 2, 3, 2, 1, 2, 1, 0, 1], 9: [4, 3, 2, 3, 2, 1, 2, 1, 0] } goal = [1, 2, 3, 4, 5, 6, 7, 8, 9] move_dict = {'U': -3, 'R': 1, 'D': 3, 'L': -1} def get_successors_with_memory(puzz, move_options, blank, heuristic):
class Stream(): def __init__(self, com, port, maxlength = 100): self.maxlength = maxlength self._ring_buffer = deque([], maxlength) self._in_queue = LifoQueue() self._out_queue = Queue() self.com = com self.port = port # First, connect to the stream port self.com.connect(port, self._in_queue, self._out_queue, self._ring_buffer, self.on_data) self.lock = Lock() # lock for concurrent access to self.subscribers self.subscribers = [] def last(self, n = None): """ Returns the latest or the n latest data records read from the data stream. If called without parameter, returns a single record, as a Python object. If no record has been received yet, returns None. If called with a parameter n, returns the n latest ones or less if less records have been received (in older to most recent order). Returns None only if no data has been ever published on the stream. """ # No data yet? if not self._ring_buffer: return None if not n: res = self._ring_buffer[0] else: n = min(n, self.maxlength) res = list(self._ring_buffer)[:n] #TODO: optimize that! currently, the whole queue is copied :-/ res.reverse() return res def get(self, timeout = None): """ Blocks until a record is available from the data stream, and returns it. If records are already available, returns the most recent one. :param timeout: (default: None) If timeout is a positive number, it blocks at most timeout seconds and raises the Empty exception if no item was available within that time. If timeout is None, block indefinitely. """ # in_queue is a LIFO: get() returns the last inserted element, # ie the most recent record. res = self._in_queue.get(True, timeout) # Clear the queue: we do not need to stack older result. pymorselogger.debug("Clearing stream incoming queue") with self._in_queue.mutex: self._in_queue.queue = [] # Note that we may loose one records between the get() and the clear() # if the other thread reacquires the mutex. It is however not a big # issue to loose a record here. return res def on_data(self, data): # Since this method can takes some time (invoking all callback # on the new incoming data), we copy the list of callbacks # to release quickly the lock on self.subscribers with self.lock: cbs = self.subscribers[:] for cb in cbs: cb(data) def subscribe(self, cb): with self.lock: self.subscribers.append(cb) def unsubscribe(self, cb): with self.lock: self.subscribers.remove(cb) def publish(self, msg): self._out_queue.put(msg)
class ShipComputer: def __init__(self, initial_memory, inputs=None): self.opcodes = {} self.memory = [int(i) for i in initial_memory] self.instruction_pointer = 0 if (isinstance(inputs, int)): inputs = [inputs] self.inputs = SimpleQueue() if inputs != None: for input in inputs: self.inputs.put(input) self.output = LifoQueue() self.relative_base = 0 self.status = Status.IDLE self.addOpCode( 1, 'add', lambda memory, params: (params[2], memory[params[0]] + memory[params[1]], None), 3) self.addOpCode( 2, 'mul', lambda memory, params: (params[2], memory[params[0]] * memory[params[1]], None), 3) self.addOpCode(3, 'input', self.get_input, 1) # SimpleQueue.get blocks self.addOpCode( 4, 'output', lambda memory, params: (None, self.output.put(memory[params[0]]), None), 1) self.addOpCode( 5, 'jump-if-true', lambda memory, params: (None, None, None if memory[params[0]] == 0 else memory[params[1]]), 2, 0) self.addOpCode( 6, 'jump-if-false', lambda memory, params: (None, None, None if memory[params[0]] != 0 else memory[params[1]]), 2, 0) self.addOpCode( 7, 'less-than', lambda memory, params: (params[2], 1 if memory[params[0]] < memory[params[1]] else 0, None), 3) self.addOpCode( 8, 'equals', lambda memory, params: (params[2], 1 if memory[params[0]] == memory[params[1]] else 0, None), 3) self.addOpCode(9, 'rel_base', self.update_rel_base, 1) self.addOpCode(98, 'seti', lambda memory, params: (params[1], params[0], None), 2) self.addOpCode(99, 'halt', lambda memory, params: (None, None, None), 0) def update_rel_base(self, memory, params): self.relative_base += memory[params[0]] return (None, None, None) def get_memory(self): return self.memory def get_input(self, memory, params): if self.inputs.qsize() == 0: self.status = Status.WAITING_FOR_INPUT return (None, None, self.instruction_pointer) input = self.inputs.get() # SimpleQueue.get blocks self.status = Status.RUNNING return (params[0], input, None) def get_output(self): return self.output.get() def get_all_outputs(self): outputs = [] while (not self.output.empty()): outputs.append(self.get_output()) outputs.reverse() # LIFO -> FIFO queue return outputs def put_input(self, value): return self.inputs.put(value) def addOpCode(self, opcode, name, run_function, parmLength, ip_offset=None): self.opcodes[opcode] = self.createIntCode(name, run_function, parmLength, ip_offset) def execute_until_blocked(self): while self.tick(): pass def tick(self): self.status = Status.RUNNING instruction = self.memory[self.instruction_pointer] opcode = instruction % 100 param_modes = [(instruction // 100) % 10, (instruction // 1000) % 10, (instruction // 10000) % 10] if opcode in self.opcodes.keys(): curr_inst = self.opcodes[opcode] parm_length = curr_inst.parameterLength parm_addresses = [] for i in range(0, curr_inst.parameterLength): memory_address = self.instruction_pointer + 1 + i if param_modes[ i] == 0: # position, not immediate, so dereference memory_address = self.memory[memory_address] if param_modes[i] == 2: # relative memory_address = self.relative_base + self.memory[ memory_address] parm_addresses.append(memory_address) curr_inst.run(parm_addresses) if opcode == 99: # halt self.status = Status.FINISHED return False else: sys.stderr.write("Error - IP opcode" + str(opcode)) return self.status == Status.RUNNING def execute(self): try: while True: next(self.execute_concurrent()) except StopIteration: return def execute_concurrent(self, concurrent_mode=False): while True: instruction = self.memory[self.instruction_pointer] opcode = instruction % 100 param_modes = [(instruction // 100) % 10, (instruction // 1000) % 10, (instruction // 10000) % 10] if opcode in self.opcodes.keys(): curr_inst = self.opcodes[opcode] parm_length = curr_inst.parameterLength parm_addresses = [] for i in range(0, curr_inst.parameterLength): memory_address = self.instruction_pointer + 1 + i if param_modes[ i] == 0: # position, not immediate, so dereference memory_address = self.memory[memory_address] if param_modes[i] == 2: # relative memory_address = self.relative_base + self.memory[ memory_address] parm_addresses.append(memory_address) curr_inst.run(parm_addresses) if opcode == 99: # halt return False if opcode == 4 and concurrent_mode: #output yield self.get_output() else: sys.stderr.write("Error - IP opcode" + str(opcode)) def createIntCode(self, name, run_function, parameterLength, ip_offset=None): return ShipComputer.IntCode(self, name, run_function, parameterLength, ip_offset) class IntCode: def __init__(self, outer, name, run_function, parameterLength, ip_offset=None): self.computer = outer self.name = name self.run_function = run_function self.parameterLength = parameterLength self.ip_offset = ip_offset if ip_offset != None else parameterLength + 1 def run(self, params): for address in params[:-1]: if address >= len(self.computer.memory): self.computer.memory += [0] * (10 + address - len(self.computer.memory)) output, result, new_ip = self.run_function(self.computer.memory, params) if (output != None): if output >= len(self.computer.memory): self.computer.memory += [0] * (10 + output - len(self.computer.memory)) self.computer.memory[output] = result if (new_ip != None): self.computer.instruction_pointer = new_ip else: self.computer.instruction_pointer += self.parameterLength + 1
def pnl_lifo(self): """ 使用后进先出法配对成交记录 """ X = dict( zip( self.target.code, [{'buy': LifoQueue(), 'sell': LifoQueue()} for i in range(len(self.target.code))] ) ) pair_table = [] for _, data in self.target.history_table_min.iterrows(): while True: if data.direction in[1, 2, -2]: if data.direction in [1, 2]: X[data.code]['buy'].append( (data.datetime, data.amount, data.price, data.direction) ) elif data.direction in [-2]: X[data.code]['sell'].append( (data.datetime, data.amount, data.price, data.direction) ) break elif data.direction in[-1, 3, -3]: rawoffset = 'buy' if data.direction in [-1, -3] else 'sell' l = X[data.code][rawoffset].get() if abs(l[1]) > abs(data.amount): """ if raw> new_close: """ temp = (l[0], l[1] + data.amount, l[2]) X[data.code][rawoffset].put_nowait(temp) if data.amount < 0: pair_table.append( [ data.code, data.datetime, l[0], abs(data.amount), data.price, l[2], rawoffset ] ) break else: pair_table.append( [ data.code, l[0], data.datetime, abs(data.amount), l[2], data.price, rawoffset ] ) break elif abs(l[1]) < abs(data.amount): data.amount = data.amount + l[1] if data.amount < 0: pair_table.append( [ data.code, data.datetime, l[0], l[1], data.price, l[2], rawoffset ] ) else: pair_table.append( [ data.code, l[0], data.datetime, l[1], l[2], data.price, rawoffset ] ) else: if data.amount < 0: pair_table.append( [ data.code, data.datetime, l[0], abs(data.amount), data.price, l[2], rawoffset ] ) break else: pair_table.append( [ data.code, l[0], data.datetime, abs(data.amount), l[2], data.price, rawoffset ] ) break pair_title = [ 'code', 'sell_date', 'buy_date', 'amount', 'sell_price', 'buy_price', 'rawdirection' ] pnl = pd.DataFrame(pair_table, columns=pair_title) pnl = pnl.assign( unit=pnl.code.apply(lambda x: self.market_preset.get_unit(x)), pnl_ratio=(pnl.sell_price / pnl.buy_price) - 1, sell_date=pd.to_datetime(pnl.sell_date), buy_date=pd.to_datetime(pnl.buy_date) ) pnl = pnl.assign( pnl_money=(pnl.sell_price - pnl.buy_price) * pnl.amount * pnl.unit, hold_gap=abs(pnl.sell_date - pnl.buy_date), if_buyopen=pnl.rawdirection == 'buy' ) pnl = pnl.assign( openprice=pnl.if_buyopen.apply(lambda pnl: 1 if pnl else 0) * pnl.buy_price + pnl.if_buyopen.apply(lambda pnl: 0 if pnl else 1) * pnl.sell_price, opendate=pnl.if_buyopen.apply(lambda pnl: 1 if pnl else 0) * pnl.buy_date.map(str) + pnl.if_buyopen.apply(lambda pnl: 0 if pnl else 1) * pnl.sell_date.map(str), closeprice=pnl.if_buyopen.apply(lambda pnl: 0 if pnl else 1) * pnl.buy_price + pnl.if_buyopen.apply(lambda pnl: 1 if pnl else 0) * pnl.sell_price, closedate=pnl.if_buyopen.apply(lambda pnl: 0 if pnl else 1) * pnl.buy_date.map(str) + pnl.if_buyopen.apply(lambda pnl: 1 if pnl else 0) * pnl.sell_date.map(str) ) return pnl.set_index('code')
class CrawlerType2(BaseCrawler): def __init__(self, name, start_url, list_of_urls, number_of_threads, delayed_request=False, max_allowed_error=10): super().__init__(name, start_url, number_of_threads, delay_request=delayed_request, max_err=max_allowed_error) self.url_list = list_of_urls self.task_queue = LifoQueue() def run(self): """ Function to be called by subclasses to start crawler """ while True: # Crawl cycle starts print_util.print_info( 'Starting crawl with {0}'.format( self.name ), Colors.BLACK ) # Add URLs to task queue for url in self.url_list: self.task_queue.put( { 'type': 0, 'url': url, 'n_errors': 0 } ) # Start all threads threads = [] for n in range(1, self.number_of_threads + 1): temp_thread = Thread( target=self.threader, args=(n,) ) threads.append(temp_thread) temp_thread.start() # Wait for threads to finish for temp_thread in threads: temp_thread.join() # Crawl cycle ends def threader(self, thread_id): """ Worker function :param thread_id: Ass usual """ while not self.task_queue.empty(): task = self.task_queue.get() if task['n_errors'] >= self.max_allowed_errors: print_util.print_warning( '{0} --> Too many errors in task {1}. Skipping.'.format( thread_id, task ) ) continue print_util.print_info( '{0} --> New task : {1}'.format( thread_id, task ) ) try: if task['type'] == 0: self.get_artists( thread_id, task['url'] ) elif task['type'] == 1: self.get_artist( thread_id, task['url'], task['artist'] ) elif task['type'] == 2: self.get_songs_from_page( thread_id, task['url'], task['artist'] ) elif task['type'] == 3: self.get_song( thread_id, task['url'], task['song'], task['artist'] ) print_util.print_info( '{0} --> Task complete : {1}'.format( thread_id, task ), Colors.GREEN ) except Exception as e: print_util.print_error( '{0} --> Error : {1}'.format( thread_id, e ) ) task['n_errors'] += 1 self.task_queue.put(task) def get_artists(self, thread_id, url): """ Method to get artists from a URL :param thread_id: As usual :param url: As usual """ complete_url = self.start_url + url raw_html = open_request(complete_url, delayed=self.delay_request) artists_with_url = self.get_artist_with_url(raw_html) for artist_url, artist in artists_with_url: self.task_queue.put( { 'type': 1, 'url': artist_url, 'artist': artist, 'n_errors': 0 } ) def get_artist(self, thread_id, url, artist): """ Get songs for artist from URL in two parts: 1. Get songs from first page (:param url) 2. Add all other pages to task queue :param thread_id: :param url: :param artist: """ complete_url = self.start_url + url raw_html = open_request(complete_url, delayed=self.delay_request) pages = self.get_pages_for_artist(raw_html) # Add all songs from current page for song_url, song in self.get_songs(raw_html): self.task_queue.put( { 'type': 3, 'url': song_url, 'song': song, 'artist': artist, 'n_errors': 0 } ) # Add rest of pages in task queue for page in pages[1:]: self.task_queue.put( { 'type': 2, 'url': page, 'artist': artist, 'n_errors': 0 } ) def get_songs_from_page(self, thread_id, url, artist): """ Get songs from other pages of artist :param thread_id: As usual :param url: As usual :param artist: As usual """ complete_url = self.start_url + url raw_html = open_request(complete_url, delayed=self.delay_request) for song_url, song in self.get_songs(raw_html): self.task_queue.put( { 'type': 3, 'url': song_url, 'song': song, 'artist': artist, 'n_errors': 0 } ) def get_song(self, thread_id, url, song, artist): """ Get song from a URL :param thread_id: As usual :param url: As usual :param song: As usual :param artist: Artist of song """ if db_operations.exists_song(self.start_url, url): print_util.print_warning( '{0} --> Song {1} already exists. Skipping.'.format( thread_id, song ) ) complete_url = self.start_url + url raw_html = open_request(complete_url, delayed=self.delay_request) album, lyrics, lyricist, additional_artists = self.get_song_details( raw_html ) # Note: additional_artists are artist(s) featured in the song db_operations.save( song, url, album, url, self.start_url, lyrics, additional_artists + [artist, ], [artist, ], lyricist ) def get_song_details(self, raw_html): """ User overrides this method to get details about a song :param raw_html: HTML code of web page :return: Song details """ return ( 'album', 'lyrics', [ 'lyricist1', 'lyricist2' ], [ 'additional_artist1', 'additional_artist2', ] ) def get_artist_with_url(self, raw_html): """ User overrides this method to get all artists with URL from a web page :param raw_html: HTML code of web page :return: Artists with URLs """ return [ ('url1', 'artist1'), ('url2', 'artist2') ] def get_pages_for_artist(self, raw_html): """ Get a list of pages for an artist from given HTML code :param raw_html: HTML code of web page :return: List of URLs """ return [ 'url1', 'url2' ] def get_songs(self, raw_html): """ User overrides this function to get songs with URL from page's HTML :param raw_html: HTML code for web page :return: Songs with URLs """ return [ ('url1', 'song1'), ('url2', 'song2') ]
start_url = sys.argv[1] max_levels = sys.argv[2] keyword = sys.argv[3] search_type = sys.argv[4] # use lock to visited links so only one thread can update at a time visited_lock = threading.Lock() unvisited_lock = threading.Lock() # make visited links a hashed set so there are not duplicates # a bloom filter may improve performance with less memory visited_links = set() # create a queue of unvisited links added by threads as they scrape single_path = False if int(search_type) == 0: # DFS unvisited_links = LifoQueue() elif int(search_type) == 1: # BFS unvisited_links = Queue() elif int(search_type) == 2: # DFS NUM_THREADS = 1 unvisited_links = LifoQueue() single_path = True threads = list() first_link = dict() first_link['url'] = start_url first_link['parent_url'] = None first_link['level'] = 0
class Breakout(Game): def __init__(self): Game.__init__(self, 'Breakout', c.screen_width, c.screen_height, os.path.abspath(c.background_image), c.frame_rate) self.reset_effect = None self.effect_start_time = None self.score = 0 self.lives = c.initial_lives self.start_level = False self.paddle = None self.bricks = None self.ball = None self.menu_buttons = [] self.is_game_running = False self.create_objects() self.points_per_brick = 1 self.fo = open(os.path.abspath("../score.txt"), "w") self.q = LifoQueue() self.t = Thread(target=enqueue_output, args=(sys.stdin, self.q)) self.t.daemon = True # thread dies with the program self.t.start() self.padhit = False self.wallhit = False def tricky_life(self): if self.score < c.row_count * c.screen_width // (c.brick_width + 1) // 4: if self.lives > 1: self.lives -= 1 elif self.score > 3 * c.row_count * c.screen_width // (c.brick_width + 1) // 4: self.lives += 1 def change_paddle(self, rate): if rate is not 0: self.paddle.bounds.inflate_ip(-self.paddle.width // rate, 0) else: self.paddle.bounds.inflate_ip(self.paddle.width, 0) def slow_paddle(self, indicator): if indicator > 0: self.paddle.offset = self.paddle.offset * 3 // 4 else: self.paddle.offset = c.paddle_speed def set_points_per_brick(self, points): self.points_per_brick = points def change_ball_speed(self, dy): self.ball.speed = (self.ball.speed[0], int(self.ball.speed[1] * dy)) def create_menu(self): self.is_game_running = True self.start_level = True def create_objects(self): self.create_bricks() self.create_labels() self.create_menu() self.create_paddle() self.create_ball(c.screen_width // 2) def create_labels(self): self.score_label = TextObject(c.score_offset, c.status_offset_y, lambda: 'SCORE: {0}'.format(self.score), c.text_color, c.font_name, c.font_size) self.objects.append(self.score_label) self.lives_label = TextObject(c.lives_offset, c.status_offset_y, lambda: 'LIVES: {0}'.format(self.lives), c.text_color, c.font_name, c.font_size) self.objects.append(self.lives_label) def create_ball(self, x): speed = (4 if random.random() > 0.5 else -4, c.ball_speed) self.ball = Ball(x, c.screen_height // 2, c.ball_radius, c.ball_color, speed) self.objects.append(self.ball) def create_paddle(self): paddle = Paddle((c.screen_width - c.paddle_width) // 2, c.screen_height - c.paddle_height * 2, c.paddle_width, c.paddle_height, c.paddle_color, c.paddle_speed) self.keydown_handlers[pygame.K_LEFT].append(paddle.handle) self.keydown_handlers[pygame.K_RIGHT].append(paddle.handle) self.keyup_handlers[pygame.K_LEFT].append(paddle.handle) self.keyup_handlers[pygame.K_RIGHT].append(paddle.handle) self.paddle = paddle self.objects.append(self.paddle) def create_bricks(self): w = c.brick_width h = c.brick_height brick_count = c.screen_width // (w + 1) offset_x = (c.screen_width - brick_count * (w + 1)) // 2 bricks = [] effects = random.sample([i for i in range(c.row_count * brick_count)], 24) random.shuffle(effects) for row in range(c.row_count): for col in range(brick_count): index = row * brick_count + col effect = None brick_color = c.brick_color if index in effects: brick_color, start_effect_func, reset_effect_func = list( special_effects.values())[effects.index(index) // 4] effect = start_effect_func, reset_effect_func brick = Brick(offset_x + col * (w + 1), c.offset_y + row * (h + 1), w, h, brick_color, effect) bricks.append(brick) self.objects.append(brick) self.bricks = bricks def handle_ball_collisions(self): # Hit paddle s = self.ball.speed edge = intersect(self.paddle, self.ball) if edge != 0: speedy = int(math.copysign(s[1], -1)) if edge // 3 == 1 else s[1] speedx = -s[0] if edge % 3 != 0 or (edge // 3 == 1 and ( self.paddle.moving_left or self.paddle.moving_right)) else s[0] self.ball.speed = (speedx, speedy) # Hit floor if self.ball.top >= c.screen_height: x = self.ball.centerx self.lives -= 1 if self.reset_effect is not None: self.reset_effect(self) self.reset_effect = None if self.lives <= 0: self.game_over = True else: self.objects.remove(self.ball) # Delete old ball self.create_ball(x) # Hit brick for brick in self.bricks: edge = intersect(brick, self.ball) if not edge: continue self.bricks.remove(brick) self.objects.remove(brick) self.score += self.points_per_brick self.ball.speed = (-s[0] if edge % 3 != 0 and ((edge % 3) - 1.5) * s[0] < 0 else s[0], -s[1] if edge // 3 != 0 and (edge // 3 - 1.5) * s[1] < 0 else s[1]) if brick.special_effect is not None: # Reset previous effect if any if self.reset_effect is not None: self.reset_effect(self) # Trigger special effect self.effect_start_time = datetime.now() brick.special_effect[0](self) # Set current reset effect function self.reset_effect = brick.special_effect[1] # Hit ceiling if self.ball.top <= 0: self.ball.speed = (s[0], -s[1] if s[1] < 0 else s[1]) # Hit wall if self.ball.left <= 0: self.ball.speed = (-s[0] if s[0] < 0 else s[0], s[1]) if self.ball.right >= c.screen_width: self.ball.speed = (-s[0] if s[0] > 0 else s[0], s[1]) def update(self): if not self.is_game_running: return if self.start_level: self.start_level = False self.show_message('GET READY!', centralized=True) if not self.bricks: print("{0} {1}".format(self.score, self.lives)) self.is_game_running = False self.game_over = True return # Reset special effect if needed if self.reset_effect: if datetime.now() - self.effect_start_time >= timedelta( seconds=c.effect_duration): self.reset_effect(self) self.reset_effect = None self.handle_ball_collisions() # Return location information to agent infor = " ".join((str(self.ball.centerx), str(self.ball.centery), str(self.paddle.centerx), str(self.paddle.width), str(self.lives), str(self.score))) for brick in self.bricks: infor += " " + str(brick.centerx) infor += " " + str(brick.centery) infor += " " + str(color2index(brick.color)) print(infor) sys.stdout.flush() # Pre-Update paddle self.paddle.moving_left = 0 self.paddle.moving_right = 0 try: line = self.q.get_nowait() # or q.get(timeout=.1) except Empty: line = [] for i in range(len(line)): if line[i] == "R": self.paddle.moving_left = 0 self.paddle.moving_right = 1 elif line[i] == "L": self.paddle.moving_left = 1 self.paddle.moving_right = 0 if self.paddle.moving_left: dx = -(min(self.paddle.offset, self.paddle.left)) if dx == 0: self.paddle.moving_left = 0 elif self.paddle.moving_right: dx = min(self.paddle.offset, c.screen_width - self.paddle.right) if dx == 0: self.paddle.moving_right = 0 else: dx = 0 #Update paddle and ball(truncated) speedx, speedy = self.objects[-1].speed[0], self.objects[-1].speed[1] n_step = max(abs(speedx), abs(speedy)) n_start = min(abs(speedx), abs(speedy)) tmp_ball = copy.deepcopy(self.ball) tmp_paddle = copy.deepcopy(self.paddle) end = False hit = False wall = False for i in range(1, n_step + 1): if end: break tmp_ball = copy.deepcopy(self.ball) tmp_paddle = copy.deepcopy(self.paddle) if math.copysign(i * abs(speedy) // n_step, speedy) == 0: continue tmp_ball.move(math.copysign(i * abs(speedx) // n_step, speedx), math.copysign(i * abs(speedy) // n_step, speedy)) tmp_paddle.move(math.copysign(i * abs(dx) // n_step, dx), 0) if tmp_ball.top >= c.screen_height or\ tmp_ball.top <= 0: end = True if tmp_ball.left <= 0 or\ tmp_ball.right >= c.screen_width: if self.wallhit == True: continue end = True wall = True for brick in self.bricks: if intersect(brick, tmp_ball) != 0: end = True break if intersect(tmp_paddle, tmp_ball) != 0: if self.padhit == True: continue end = True self.padhit = True hit = True self.padhit = hit self.wallhit = wall self.ball = copy.deepcopy(tmp_ball) self.objects[-1] = self.ball self.paddle = copy.deepcopy(tmp_paddle) self.objects[-2] = self.paddle super().update() if self.game_over: self.fo.write("{0} {1}\n".format(self.score, self.lives)) self.fo.close() return def show_message(self, text, color=colors.WHITE, font_name='Arial', font_size=20, centralized=False): message = TextObject(c.screen_width // 2, c.screen_height // 2, lambda: text, color, font_name, font_size) self.draw() message.draw(self.surface, centralized) pygame.display.update() time.sleep(c.message_duration)
from queue import LifoQueue pilha = LifoQueue() keys = {'(': ')', '{': '}', '[': ']'} strings = input("Entre com um conjunto de ({[]}): ") controle = 0 for j in strings: if j == '(' or j == '{' or j == '[': pilha.put(keys[j]) else: if pilha.empty() == True or j != pilha.get(): controle = 1 break if controle == 0 and pilha.empty() == True: print("Caracteres validos!") else: print("Caracteres invalidos!")
from tkinter import * from tkinter import ttk import time import controller.client_controller as controller from queue import LifoQueue queue = LifoQueue() class QuizWindow: root = None frame = None display_data = [] your_info = None opp_info = None def set_root(self): # Create the window itself self.root = Tk() # Create title for the window self.root.title('Quiz Wars') # Set window size self.root.geometry('350x200') def welcome_window(self): # Create frame inside window (root) to hold all widgets self.frame = ttk.Frame(self.root, padding="10 10 10 10") # Create grid layout inside the frame self.frame.grid(column=0, row=0, sticky=(N, W, E, S))
def pnl_lifo(self): """ 使用后进先出法配对成交记录 """ X = dict( zip(self.target.code, [LifoQueue() for i in range(len(self.target.code))])) pair_table = [] for _, data in self.target.history_table.iterrows(): while True: if X[data.code].qsize() == 0: X[data.code].put((data.datetime, data.amount, data.price)) break else: l = X[data.code].get() if (l[1] * data.amount) < 0: # 原有多仓/ 平仓 或者原有空仓/平仓 if abs(l[1]) > abs(data.amount): temp = (l[0], l[1] + data.amount, l[2]) X[data.code].put_nowait(temp) if data.amount < 0: pair_table.append([ data.code, data.datetime, l[0], abs(data.amount), data.price, l[2] ]) break else: pair_table.append([ data.code, l[0], data.datetime, abs(data.amount), data.price, l[2] ]) break elif abs(l[1]) < abs(data.amount): data.amount = data.amount + l[1] if data.amount < 0: pair_table.append([ data.code, data.datetime, l[0], l[1], data.price, l[2] ]) else: pair_table.append([ data.code, l[0], data.datetime, l[1], data.price, l[2] ]) else: if data.amount < 0: pair_table.append([ data.code, data.datetime, l[0], abs(data.amount), data.price, l[2] ]) break else: pair_table.append([ data.code, l[0], data.datetime, abs(data.amount), data.price, l[2] ]) break else: X[data.code].put_nowait(l) X[data.code].put_nowait( (data.datetime, data.amount, data.price)) break pair_title = [ 'code', 'sell_date', 'buy_date', 'amount', 'sell_price', 'buy_price' ] pnl = pd.DataFrame(pair_table, columns=pair_title).set_index('code') pnl = pnl.assign(pnl_ratio=(pnl.sell_price / pnl.buy_price) - 1, sell_date=pd.to_datetime(pnl.sell_date), buy_date=pd.to_datetime(pnl.buy_date)) pnl = pnl.assign(pnl_money=pnl.pnl_ratio * pnl.amount, hold_gap=abs(pnl.sell_date - pnl.buy_date)) return pnl
from queue import LifoQueue T = int(input()) for i in range(T): N = int(input()) stack = LifoQueue() for j in range(N): s = input() if s.startswith('place'): l = s.split(' ') x = l[1] print(x) stack.put(x) elif stack.qsize(): print("remove: ", end=' ') print(stack.get(), end= ' ') else: print("-1", end=' ') print()
#implemented using list stack = [] stack.append(100) stack.append(200) print(stack.pop()) #using collections.deque from collections import deque stack = deque() stack.append(200) stack.append("opop") print(stack) print(stack.pop()) #using Queue from queue import LifoQueue stack = LifoQueue(maxsize=3) print(stack.qsize()) stack.put(30) stack.put(80) print(stack.get()) print(stack.qsize())
class DepthFirstSearchSampler(Sampler): r"""An implementation of node sampling by depth first search. The starting node is selected randomly and neighbors are added to the last in first out queue by shuffling them randomly. Args: number_of_nodes (int): Number of nodes. Default is 100. seed (int): Random seed. Default is 42. """ def __init__(self, number_of_nodes: int = 100, seed: int = 42): self.number_of_nodes = number_of_nodes self.seed = seed self._set_seed() def _create_seed_set(self, graph, start_node): """ Creating a visited node set and a traversal path list. """ self._queue = LifoQueue() if start_node is not None: if start_node >= 0 and start_node < self.backend.get_number_of_nodes( graph): self._queue.put(start_node) else: raise ValueError("Starting node index is out of range.") else: start_node = random.choice( range(self.backend.get_number_of_nodes(graph))) self._queue.put(start_node) self._nodes = set() self._path = [] def _extract_edges(self): """ Extracting edges from the depth first search tree. """ self._edges = [[self._path[i], self._path[i + 1]] for i in range(len(self._path) - 1)] def sample(self, graph: Union[NXGraph, NKGraph], start_node: int = None) -> Union[NXGraph, NKGraph]: """ Sampling a graph with randomized depth first search. Arg types: * **graph** *(NetworkX or NetworKit graph)* - The graph to be sampled from. * **start_node** *(int, optional)* - The start node. Return types: * **new_graph** *(NetworkX or NetworKit graph)* - The graph of sampled nodes. """ self._deploy_backend(graph) self._check_number_of_nodes(graph) self._create_seed_set(graph, start_node) while len(self._nodes) < self.number_of_nodes: source = self._queue.get() if source not in self._nodes: neighbors = self.backend.get_neighbors(graph, source) random.shuffle(neighbors) for neighbor in neighbors: self._queue.put(neighbor) self._nodes.add(source) self._path.append(source) self._extract_edges() new_graph = self.backend.graph_from_edgelist(self._edges) new_graph = self.backend.get_subgraph(new_graph, self._nodes) return new_graph
class ConnectionPool(object): def __init__(self, conf, connection_class, **connection_kwargs): self.pid = os.getpid() self.conf = {"max": 0, "min": 1, "timeout": 0.1, "idle_timeout": 60, "max_lifetime": 30 * 60} if conf: self.conf.update(conf) self.connection_class = connection_class self.connection_kwargs = connection_kwargs self.pool = LifoQueue(self.conf["max"]) self.diet() def _checkpid(self): if self.pid != os.getpid(): logger.info("This pool is created by other process.") self.dispose() self.__init__(self.conf, self.connection_class, **self.connection_kwargs) def dispose(self): self.clear() def clear(self): while True: try: conn = self.pool.get(block=False) if conn: self.abandon(conn) except Empty: break def diet(self): for i in range(self.conf["min"]): try: self.pool.put(None, block=False) except Full: break def acquire(self): conn = None try: conn = self.pool.get(block=True, timeout=self.conf["timeout"]) except Empty: logger.warning("No idle connection, create one more.") if conn: now = time.time() idle_time = now - conn.access_time life_time = now - conn.open_time if (idle_time > self.conf["idle_timeout"]) or (life_time > self.conf["max_lifetime"]): logger.debug("Discard obsolete connection %s. idle: %d, life: %d" % (conn, idle_time, life_time)) conn.close() conn = None return conn or self.connection_class(**self.connection_kwargs) def release(self, conn): try: conn.touch() self.pool.put(conn, block=False) except Full: logger.warning("The pool is full, discard connection %s." % conn) conn.close() def abandon(self, conn): conn.close() self.clear() self.diet() def connection(self): self._checkpid() return ConnectionGuard(self)
def dfs_search(initial_state): from queue import LifoQueue """DFS search""" init_time = time.time() process = psutil.Process(os.getpid()) i = 0 fringe = LifoQueue() fringe.put(initial_state.config) n = initial_state.n g = Graph() root = Node(initial_state.config, type="dfs") g.add_node(root) while not fringe.empty(): state = fringe.get() node = Node(state, "dfs") # visited.append(state) node_g = g.get_node(node.key) # check if node is in fringe or visited if node_g: node_g.update_visited() node_g.infringe = False else: g.add_node(node) node_g = g.get_node(node.key) node_g.update_visited() node_g.infringe = False state = PuzzleState(state, n) reached = test_goal(state) if reached: final_time = time.time() delta = final_time - init_time ram_usage = process.memory_info().rss * 1e-6 print("Optimal Found") writeOutput(state) print("FINSHED") path, path_cost = g.get_path(node.key) nodes_expanded = i max_depth = g.get_max_depth() sol = "path_to_goal: %s \n" % path + \ "cost_of_path: %s \n" % path_cost + \ "nodes_expanded: %i \n" % nodes_expanded + \ "search_depth: %i \n" % path_cost + \ "max_search_depth: %i \n" % max_depth + \ "running_time: %f \n" % delta + \ "max_ram_usage: %f \n" % ram_usage print(sol) with open("output.txt", "wb") as file: file.write(sol.encode("utf-8")) return path, path_cost, nodes_expanded, max_depth elif state is not None: expand = state.expand() # EXPAND STATES keys_reversed = [*expand.keys()][::-1] for exp in keys_reversed: # print(exp) child_node = Node(expand[exp].config, type="dfs") ingraph = g.get_node(child_node.key) if ingraph: node_visit = ingraph.visited infringe = ingraph.infringe else: # print("ADDING EXPANDED NODE") g.add_node(child_node) node_visit = False infringe = False if not node_visit and not infringe: fringe.put(expand[exp].config) child_node.infringe = True g.add_child(node_g.key, exp, child_node.key) # quit() i += 1
#4. task_done()/join(): join就是在等多线程所有task_done结束 str="abcdefghijk" import random #Queue q=Queue(10) for i in range(10): q.put(random.choice(str)) print("size=",q.qsize()) while not q.empty(): print(q.get()) q.task_done() #Lifo Queue print("-"*10,"lifo_queue","-"*10) lifoq=LifoQueue(10) for i in range(10): lifoq.put_nowait(random.choice(str)) while not lifoq.empty(): print(lifoq.get_nowait()) lifoq.task_done() #Priority Queue print("-"*10,"priority queue","-"*10) pq=PriorityQueue(10) for i in range(10): pq.put_nowait(random.choice(str)) while not pq.empty(): print(pq.get_nowait()) pq.task_done()
def quick_sort(arr): """ 模拟栈操作实现非递归的快速排序 :param arr: :return: """ if len(arr) < 2: return arr qu = LifoQueue() qu.put(len(arr) - 1) qu.put(0) while not qu.empty(): left = qu.get() right = qu.get() index = part(arr, left, right) if left < index - 1: qu.put(index - 1) qu.put(left) if right > index + 1: qu.put(right) qu.put(index + 1)