except socket.timeout: if lector_thread.isAlive(): pass else: break except socket.error: break if mensaje == 'exit\n': break i = mensaje.find('\n') numero = mensaje[:i] mensaje = mensaje[i + 1:] lista_numeros.append(str(numero)) cola = Queue() lista_oraciones = [] lista_numeros = [] mensaje = s.recv(1024) print(mensaje.decode('utf-8')) lector_thread = threading.Thread(target=lector, args=( cola, lista_oraciones, lista_numeros, )) lector_thread.start() receptor_thread = threading.Thread(target=receptor, args=( cola, lista_numeros,
from threading import Thread from queue import Queue import random q = Queue(5) class Producer(Thread): def __init__(self, queue): super().__init__() self.queue = queue def run(self): while True: item = random.randint(0, 99) self.queue.put(item) # 队列未满,向队列中存入数据 print('生产者生产%s' % item) class Consumer(Thread): def __init__(self, queue): super().__init__() self.queue = queue def run(self): while True: item = self.queue.get() # 只要列表不为空,就从列表中取出数据 print('消费者消费%s' % item) # self.queue.task_done() # 告诉队列,这个任务执行完成了 p = Producer(q) c = Consumer(q) p.start() c.start()
#Queue from queue import Queue q = Queue(maxsize=3) print(q.qsize()) print(q.queue) print(q.empty()) print(q.full()) q.put('A') q.put('B') q.put('C') q.put_nowait('D') print(q.qsize()) print(q.queue) print(q.empty()) print(q.full()) #var = q.get() #print(var) #print(q.queue) #var = q.get() #var = q.get() #var = q.get() #print('処理終了')
def __init__(self): mpv_config = conffile.get(APP_NAME,"mpv.conf", True) input_config = conffile.get(APP_NAME,"input.conf", True) extra_options = {} self._video = None self._lock = RLock() self._finished_lock = Lock() self.last_update = Timer() self.__part = 1 self.timeline_trigger = None self.action_trigger = None self.external_subtitles = {} self.external_subtitles_rev = {} self.url = None self.evt_queue = Queue() self.is_in_intro = False self.intro_has_triggered = False if is_using_ext_mpv: extra_options = { "start_mpv": settings.mpv_ext_start, "ipc_socket": settings.mpv_ext_ipc, "mpv_location": settings.mpv_ext_path, "player-operation-mode": "cplayer" } # todo figure out how to put these in a file extra_options = { 'script-opts': 'osc-layout=slimbox,osc-deadzonesize=.9,osc-valign=1.05', } self._player = mpv.MPV(input_default_bindings=True, input_vo_keyboard=True, input_media_keys=True, include=mpv_config, input_conf=input_config, log_handler=mpv_log_handler, loglevel=settings.mpv_log_level, **extra_options) self.menu = OSDMenu(self) self.auto_insert = False def on_new_sub(name, text): if not self.auto_insert: return if not text or not text.strip(): return pyperclip.copy(text.replace('\n', ' ')) self._player.observe_property('sub-text', on_new_sub) if hasattr(self._player, 'osc'): self._player.osc = settings.enable_osc else: log.warning("This mpv version doesn't support on-screen controller.") # Wrapper for on_key_press that ignores None. def keypress(key): def wrapper(func): if key is not None: self._player.on_key_press(key)(func) return func return wrapper @self._player.on_key_press('CLOSE_WIN') @self._player.on_key_press('STOP') @keypress(settings.kb_stop) def handle_stop(): self.stop() self.timeline_handle() @keypress(settings.kb_prev) def handle_prev(): self.put_task(self.play_prev) @keypress(settings.kb_next) def handle_next(): self.put_task(self.play_next) @self._player.on_key_press('PREV') @self._player.on_key_press('XF86_PREV') def handle_media_prev(): if settings.media_key_seek: self._player.command("seek", -15) else: self.put_task(self.play_prev) @self._player.on_key_press('NEXT') @self._player.on_key_press('XF86_NEXT') def handle_media_next(): if settings.media_key_seek: if self.is_in_intro: self.skip_intro() else: self._player.command("seek", 30) else: self.put_task(self.play_next) @keypress(settings.kb_watched) def handle_watched(): self.put_task(self.watched_skip) @keypress(settings.kb_unwatched) def handle_unwatched(): self.put_task(self.unwatched_quit) @keypress(settings.kb_menu) def menu_open(): if not self.menu.is_menu_shown: self.menu.show_menu() else: self.menu.hide_menu() @keypress(settings.kb_menu_esc) def menu_back(): if self.menu.is_menu_shown: self.menu.menu_action('back') else: self._player.command('set', 'fullscreen', 'no') @keypress(settings.kb_menu_ok) def menu_ok(): self.menu.menu_action('ok') @keypress(settings.kb_menu_left) def menu_left(): if self.menu.is_menu_shown: self.menu.menu_action('left') else: self._player.command("seek", settings.seek_left) @keypress(settings.kb_menu_right) def menu_right(): if self.menu.is_menu_shown: self.menu.menu_action('right') else: if self.is_in_intro: self.skip_intro() else: self._player.command("seek", settings.seek_right) @keypress(settings.kb_menu_up) def menu_up(): if self.menu.is_menu_shown: self.menu.menu_action('up') else: if self.is_in_intro: self.skip_intro() else: self._player.command("seek", settings.seek_up) @keypress(settings.kb_menu_down) def menu_down(): if self.menu.is_menu_shown: self.menu.menu_action('down') else: self._player.command("seek", settings.seek_down) @keypress(settings.kb_pause) def handle_pause(): if self.menu.is_menu_shown: self.menu.menu_action('ok') else: self.toggle_pause() # This gives you an interactive python debugger prompt. @keypress(settings.kb_debug) def handle_debug(): import pdb pdb.set_trace() @self._player.on_key_press('ctrl+c') def copy_current_sub(): try: sub = self._player.sub_text pyperclip.copy(sub) except AttributeError: pass # no subtitle available. def copy_screenshot(subtitles=True): includes = 'subtitles' if subtitles else 'video' from io import BytesIO import win32clipboard image = self._player.screenshot_raw(includes=includes) output = BytesIO() image.convert("RGB").save(output, "BMP") data = output.getvalue()[14:] output.close() win32clipboard.OpenClipboard() win32clipboard.EmptyClipboard() win32clipboard.SetClipboardData(win32clipboard.CF_DIB, data) win32clipboard.CloseClipboard() @self._player.on_key_press('ctrl+s') def copy_current_image(): copy_screenshot(subtitles=True) @self._player.on_key_press('ctrl+shift+s') def copy_current_image(): copy_screenshot(subtitles=False) @self._player.on_key_press('ctrl+v') def output_audio(): import subprocess import string import unicodedata sub_delay = round(self._player.sub_delay, 4) # round b/c of weird mpv precision sub_start = self._player.sub_start + sub_delay if sub_start: print("Outputting current subtitle...") valid_fn_chars = "-_.() %s%s" % (string.ascii_letters, string.digits) fn_dirty = "%s - %s" % (self._player.media_title, str(int(sub_start * 1000))) fn = unicodedata.normalize('NFKD', fn_dirty).encode('ASCII', 'ignore') fn = ''.join(chr(c) for c in fn if chr(c) in valid_fn_chars) aid = [x for x in self._player.track_list if x.get("type") == "audio" and x.get("selected")][0].get("id") subprocess.Popen([ 'mpv', self.url, '-o', '%s.mp3' % fn, '--no-video', '--start=%s' % sub_start, '--end=%s' % (self._player.sub_end + sub_delay), '--aid=%s' % aid, ]) self._player.screenshot_to_file("%s.png" % fn, includes='video') with open('%s.txt' % fn, 'w+', encoding='utf-8') as f: f.write(self._player.sub_text) @self._player.on_key_press('ctrl+a') def toggle_auto_insert(): self.auto_insert = not self.auto_insert self._player.show_text('Auto insert %s' % ("on" if self.auto_insert else "off")) # Fires between episodes. @self._player.property_observer('eof-reached') def handle_end(_name, reached_end): if self._video and reached_end: has_lock = self._finished_lock.acquire(False) self.put_task(self.finished_callback, has_lock) # Fires at the end. @self._player.event_callback('idle') def handle_end_idle(event): if self._video: has_lock = self._finished_lock.acquire(False) self.put_task(self.finished_callback, has_lock)
# num_pass: 초기화가 성공한 모듈 갯수 # num_fail: 초기화가 실패한 모듈 갯수 num_pass, num_fail = pygame.init() # 화면의 크기는 640x480 world_width, world_height = 640, 480 screen = pygame.display.set_mode((world_width, world_height)) # 키 정보 [W, A, S, D] keys = [False, False, False, False] # 플레이어 위치 정보 player_pos = [100, 100] # 화살 정보 arrow_infos = Queue() # 화살 명중률 [명중한 갯수, 발사한 갯수] accuracy = [0, 0] # 적들의 출현 시간 timer = 0 badguy_appear = 100 # 적들의 출현 위치 badguy_infos = Queue() badguy_infos.put([640, 100]) # 플레이어 생명력 player_health = 194
class GuiView(ABC): primary: bool name: str = None log = logging.getLogger(__name__) permissive_handler_names: bool = True allow_no_handler: bool = True active_view: Optional['GuiView'] = None window: Optional[Window] = None pending_prompts = Queue() config = GuiConfig(auto_save=True, defaults=DEFAULT_SETTINGS) default_handler: Optional[Callable] = None wildcard_handlers: dict[str, dict[Callable, Callable]] = {} event_handlers = {} _event_handlers = {} _primary_kwargs = {} _counter = count() _ele_event_match = re.compile(r'^(.*?):::([a-zA-Z_]+)$').match _window_size: tuple[Optional[int], Optional[int]] = (None, None) # width, height _window_pos: tuple[Optional[int], Optional[int]] = (None, None) # x, y _log_clicks: bool = False # noinspection PyMethodOverriding def __init_subclass__( cls, view_name: str, primary: bool = True, defaults: Mapping[str, Any] = None, permissive_handler_names: bool = None, allow_no_handler: bool = None, config_path: Union[str, 'Path'] = None, ): cls.name = view_name cls.log = ViewLoggerAdapter(cls) cls.primary = primary cls.event_handlers = cls.event_handlers.copy() | {k: v[0] for k, v in cls._event_handlers.items()} cls._event_handlers.clear() cls.default_handler = getattr(cls, '_default_handler', None) if cls.default_handler is not None: del cls._default_handler # noqa if config_path: # The latest class to set this wins - does not support multiple paths within the same run cls.config.path = config_path if defaults: cls.config.defaults.update(defaults) if permissive_handler_names is not None: cls.permissive_handler_names = permissive_handler_names if allow_no_handler is not None: cls.allow_no_handler = allow_no_handler # print(f'Initialized subclass={cls.__name__!r}') def __init__(self, binds: Mapping[str, str] = None, read_timeout_ms: int = None, **kwargs): self._init_event = kwargs.get('init_event') self.parent: Optional[GuiView] = None if self.primary else GuiView.active_view self._monitor = None self._view_num = next(self._counter) self.binds = binds or {} self.read_timeout_ms = read_timeout_ms # self.log.debug(f'{self} initialized with handlers: {", ".join(sorted(self.event_handlers))}') if self.name not in self.wildcard_handlers: # Populate/compile wildcard patterns once per class self.wildcard_handlers[self.name] = wildcard_handlers = {} for key, handler in self.event_handlers.items(): if isinstance(key, str) and any(c in key for c in '*?[]'): wildcard_handlers[_compile_pattern(key)] = handler def __repr__(self): return f'<{self.__class__.__name__}[{self.name}][{self.primary=!r}][handlers: {len(self.event_handlers)}]>' def __iter__(self): return self def __next__(self) -> tuple[Event, EventData]: # self.log.debug(f'[View#{self._view_num}] Calling self.window.read...', extra={'color': 11}) event, data = self.window.read(self.read_timeout_ms) # self.log.debug(f'[View#{self._view_num}] Read {event=}', extra={'color': 10}) if event == 'Exit' or event == WIN_CLOSED: raise StopIteration return event, data def run(self): for event, data in self: try: self.handle_event(event, data) except StopIteration: break self.window.close() @classmethod def start(cls, cls_kwargs=None, init_event: tuple[Event, EventData] = None, interactive: bool = False, **kwargs): if cls.active_view is not None: raise RuntimeError(f'{cls.active_view!r} is already active - only one view may be active at a time') theme(cls.config['theme']) cls._primary_kwargs.update(kwargs) if size := kwargs.get('size'): GuiView._window_size = size obj = cls(init_event=init_event, **(cls_kwargs or {})) obj.render() if init_event: obj.window.write_event_value(*init_event) # Note: data[event] => the EventData value passed here if not interactive: while True: try: event, data = next(cls.active_view) # noqa cls.active_view.handle_event(event, data) # noqa except StopIteration: break cls.window.close() else: Window.unregister_sigint_handler()
def __init__(self, token=None, base_url=None, workers=4, bot=None, private_key=None, private_key_password=None, user_sig_handler=None, request_kwargs=None, persistence=None, defaults=None, use_context=False, dispatcher=None, base_file_url=None): if dispatcher is None: if (token is None) and (bot is None): raise ValueError('`token` or `bot` must be passed') if (token is not None) and (bot is not None): raise ValueError('`token` and `bot` are mutually exclusive') if (private_key is not None) and (bot is not None): raise ValueError('`bot` and `private_key` are mutually exclusive') else: if bot is not None: raise ValueError('`dispatcher` and `bot` are mutually exclusive') if persistence is not None: raise ValueError('`dispatcher` and `persistence` are mutually exclusive') if workers is not None: raise ValueError('`dispatcher` and `workers` are mutually exclusive') if use_context != dispatcher.use_context: raise ValueError('`dispatcher` and `use_context` are mutually exclusive') self.logger = logging.getLogger(__name__) if dispatcher is None: con_pool_size = workers + 4 if bot is not None: self.bot = bot if bot.request.con_pool_size < con_pool_size: self.logger.warning( 'Connection pool of Request object is smaller than optimal value (%s)', con_pool_size) else: # we need a connection pool the size of: # * for each of the workers # * 1 for Dispatcher # * 1 for polling Updater (even if webhook is used, we can spare a connection) # * 1 for JobQueue # * 1 for main thread if request_kwargs is None: request_kwargs = {} if 'con_pool_size' not in request_kwargs: request_kwargs['con_pool_size'] = con_pool_size self._request = Request(**request_kwargs) self.bot = Bot(token, base_url, base_file_url=base_file_url, request=self._request, private_key=private_key, private_key_password=private_key_password, defaults=defaults) self.update_queue = Queue() self.job_queue = JobQueue() self.__exception_event = Event() self.persistence = persistence self.dispatcher = Dispatcher(self.bot, self.update_queue, job_queue=self.job_queue, workers=workers, exception_event=self.__exception_event, persistence=persistence, use_context=use_context) self.job_queue.set_dispatcher(self.dispatcher) else: con_pool_size = dispatcher.workers + 4 self.bot = dispatcher.bot if self.bot.request.con_pool_size < con_pool_size: self.logger.warning( 'Connection pool of Request object is smaller than optimal value (%s)', con_pool_size) self.update_queue = dispatcher.update_queue self.__exception_event = dispatcher.exception_event self.persistence = dispatcher.persistence self.job_queue = dispatcher.job_queue self.dispatcher = dispatcher self.user_sig_handler = user_sig_handler self.last_update_id = 0 self.running = False self.is_idle = False self.httpd = None self.__lock = Lock() self.__threads = [] # Just for passing to WebhookAppClass self._default_quote = defaults.quote if defaults else None
def __init__(self): self.id = self.instance_id self.instance_id += 1 self.message_queue = Queue()
def use_queues(self): gui_queue = Queue() print(gui_queue) gui_queue.put('Message from a queue') print(gui_queue.get())
def __init__(self): self.__stream = Queue()
def register(self, signal_id): if signal_id not in self.signal_message_table: self.signal_message_table[signal_id] = Queue()
port = 80 else: port = opts.port if opts.turbo is None: thr = 135 else: thr = opts.turbo # reading headers global data headers = open("headers.txt", "r") data = headers.read() headers.close() #task queue are q,w q = Queue() w = Queue() if __name__ == '__main__': if len(sys.argv) < 2: usage() get_parameters() print("\033[92m", host, " port: ", str(port), " turbo: ", str(thr), "\033[0m") print("\033[94mPlease wait...\033[0m") user_agent() my_bots() time.sleep(5) try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((host, int(port)))
def test_get_completed_trackers(db_manager, gatekeeper, carrier, block_processor): responder = Responder(db_manager, gatekeeper, carrier, block_processor) chain_monitor = ChainMonitor(Queue(), responder.block_queue, block_processor, bitcoind_feed_params) chain_monitor.monitor_chain() # A complete tracker is a tracker which penalty transaction has been irrevocably resolved (i.e. has reached 100 # confirmations) # We'll create 3 type of txs: irrevocably resolved, confirmed but not irrevocably resolved, and unconfirmed trackers_ir_resolved = { uuid4().hex: create_dummy_tracker(penalty_rawtx=create_dummy_transaction().hex()) for _ in range(10) } trackers_confirmed = { uuid4().hex: create_dummy_tracker(penalty_rawtx=create_dummy_transaction().hex()) for _ in range(10) } trackers_unconfirmed = {} for _ in range(10): tracker = create_dummy_tracker( penalty_rawtx=create_dummy_transaction().hex()) responder.unconfirmed_txs.append(tracker.penalty_txid) trackers_unconfirmed[uuid4().hex] = tracker all_trackers = {} all_trackers.update(trackers_ir_resolved) all_trackers.update(trackers_confirmed) all_trackers.update(trackers_unconfirmed) # Let's add all to the Responder for uuid, tracker in all_trackers.items(): responder.trackers[uuid] = tracker.get_summary() for uuid, tracker in trackers_ir_resolved.items(): bitcoin_cli(bitcoind_connect_params).sendrawtransaction( tracker.penalty_rawtx) generate_block_w_delay() for uuid, tracker in trackers_confirmed.items(): bitcoin_cli(bitcoind_connect_params).sendrawtransaction( tracker.penalty_rawtx) # ir_resolved have 100 confirmations and confirmed have 99 generate_blocks_w_delay(99) # Let's check completed_trackers = responder.get_completed_trackers() ended_trackers_keys = list(trackers_ir_resolved.keys()) assert set(completed_trackers) == set(ended_trackers_keys) # Generating 1 additional blocks should also include confirmed generate_block_w_delay() completed_trackers = responder.get_completed_trackers() ended_trackers_keys.extend(list(trackers_confirmed.keys())) assert set(completed_trackers) == set(ended_trackers_keys)
def test_do_watch(temp_db_manager, gatekeeper, carrier, block_processor): # Create a fresh responder to simplify the test responder = Responder(temp_db_manager, gatekeeper, carrier, block_processor) chain_monitor = ChainMonitor(Queue(), responder.block_queue, block_processor, bitcoind_feed_params) chain_monitor.monitor_chain() trackers = [ create_dummy_tracker(penalty_rawtx=create_dummy_transaction().hex()) for _ in range(20) ] subscription_expiry = responder.block_processor.get_block_count() + 110 # Let's set up the trackers first for tracker in trackers: uuid = uuid4().hex # Simulate user registration so trackers can properly expire responder.gatekeeper.registered_users[tracker.user_id] = UserInfo( available_slots=10, subscription_expiry=subscription_expiry) # Add data to the Responder responder.trackers[uuid] = tracker.get_summary() responder.tx_tracker_map[tracker.penalty_txid] = [uuid] responder.missed_confirmations[tracker.penalty_txid] = 0 responder.unconfirmed_txs.append(tracker.penalty_txid) # Assuming the appointment only took a single slot responder.gatekeeper.registered_users[ tracker.user_id].appointments[uuid] = 1 # We also need to store the info in the db responder.db_manager.create_triggered_appointment_flag(uuid) responder.db_manager.store_responder_tracker(uuid, tracker.to_dict()) # Let's start to watch Thread(target=responder.do_watch, daemon=True).start() # And broadcast some of the transactions broadcast_txs = [] for tracker in trackers[:5]: bitcoin_cli(bitcoind_connect_params).sendrawtransaction( tracker.penalty_rawtx) broadcast_txs.append(tracker.penalty_txid) # Mine a block generate_block_w_delay() # The transactions we sent shouldn't be in the unconfirmed transaction list anymore assert not set(broadcast_txs).issubset(responder.unconfirmed_txs) # CONFIRMATIONS_BEFORE_RETRY+1 blocks after, the responder should rebroadcast the unconfirmed txs (15 remaining) generate_blocks_w_delay(CONFIRMATIONS_BEFORE_RETRY + 1) assert len(responder.unconfirmed_txs) == 0 assert len(responder.trackers) == 20 # Generating 100 - CONFIRMATIONS_BEFORE_RETRY -2 additional blocks should complete the first 5 trackers generate_blocks_w_delay(100 - CONFIRMATIONS_BEFORE_RETRY - 2) assert len(responder.unconfirmed_txs) == 0 assert len(responder.trackers) == 15 # Check they are not in the Gatekeeper either for tracker in trackers[:5]: assert len(responder.gatekeeper.registered_users[ tracker.user_id].appointments) == 0 # CONFIRMATIONS_BEFORE_RETRY additional blocks should complete the rest generate_blocks_w_delay(CONFIRMATIONS_BEFORE_RETRY) assert len(responder.unconfirmed_txs) == 0 assert len(responder.trackers) == 0 # Check they are not in the Gatekeeper either for tracker in trackers[5:]: assert len(responder.gatekeeper.registered_users[ tracker.user_id].appointments) == 0
from flask_socketio import SocketIO from queue import Queue from flask_cors import CORS app = Flask(__name__) cors = CORS(app, resources={r"/*": {"origins": "*"}}) postgres_DB = os.getenv('postgres_DB', None) postgres_DB_users = os.getenv('postgres_DB_users', None) PORT = os.getenv('PORT', 5000) socketio = SocketIO(app, async_mode="threading") thread = None logs_queue = Queue() def background_thread(): count = 0 while True: socketio.sleep(0.2) while(not logs_queue.empty()): message = logs_queue.get() print("emitting obj", message) socketio.emit(message[0], message[1]) socketio.start_background_task(background_thread) @app.route("/Test", methods=['POST', 'GET']) @requires_auth(["admin"]) def test():
def add_queue(self, qname): #queue_manager.add_queue(qname, 32) #queue = queue_manager.get_queue(qname) queue = Queue() self.IOqueue = queue
def __init__(self, args, pipelinecommit, startingtime, scriptpath): """ :param args: command line arguments :param pipelinecommit: pipeline commit or version :param startingtime: time the script was started :param scriptpath: home path of the script """ import multiprocessing from queue import Queue # Initialise variables self.commit = str(pipelinecommit) self.starttime = startingtime self.homepath = scriptpath self.analysistype = args.analysistype # Define variables based on supplied arguments self.path = os.path.join(args.path, '') assert os.path.isdir( self.path ), u'Supplied path is not a valid directory {0!r:s}'.format(self.path) self.sequencepath = os.path.join(args.sequencepath, '') assert os.path.isdir(self.sequencepath), u'Sequence path is not a valid directory {0!r:s}' \ .format(self.sequencepath) self.targetpath = os.path.join(args.targetpath, self.analysistype, '') try: self.reportpath = args.reportpath except AttributeError: self.reportpath = os.path.join(self.path, 'reports') assert os.path.isdir(self.targetpath), u'Target path is not a valid directory {0!r:s}' \ .format(self.targetpath) self.bcltofastq = args.bcltofastq self.miseqpath = args.miseqpath self.miseqfolder = args.miseqfolder self.fastqdestination = args.fastqdestination self.forwardlength = args.forwardlength self.reverselength = args.reverselength self.numreads = 2 if self.reverselength != 0 else 1 self.customsamplesheet = args.customsamplesheet # Set the custom cutoff value self.cutoff = args.cutoff # Use the argument for the number of threads to use, or default to the number of cpus in the system self.cpus = int( args.cpus if args.cpus else multiprocessing.cpu_count()) self.threads = int() self.runmetadata = args.runmetadata self.pipeline = args.pipeline self.copy = args.copy self.devnull = open(os.path.devnull, 'w') self.samplequeue = Queue(maxsize=self.cpus) self.fastaqueue = Queue(maxsize=self.cpus) self.blastqueue = Queue(maxsize=self.cpus) self.baitfile = str() self.taxonomy = { 'Escherichia': 'coli', 'Listeria': 'monocytogenes', 'Salmonella': 'enterica' } # Fields used for custom outfmt 6 BLAST output: self.fieldnames = [ 'query_id', 'subject_id', 'positives', 'mismatches', 'gaps', 'evalue', 'bit_score', 'subject_length', 'alignment_length', 'query_start', 'query_end', 'query_sequence', 'subject_start', 'subject_end', 'subject_sequence' ] # Run the analyses self.runner()
#!/usr/bin/env python3 # -*- coding: utf-8 -*- # Copyright (c) 2017-2019 Random.Zebra (https://github.com/random-zebra/) # Distributed under the MIT software license, see the accompanying # file LICENSE.txt or http://www.opensource.org/licenses/mit-license.php. import os from queue import Queue wqueue = Queue() # type: Queue[str] MPATH_LEDGER = "44'/77'/" MPATH_TREZOR = "44'/119'/" MPATH_TESTNET = "44'/1'/" WIF_PREFIX = 212 # 212 = d4 MAGIC_BYTE = 30 STAKE_MAGIC_BYTE = 63 TESTNET_WIF_PREFIX = 239 TESTNET_MAGIC_BYTE = 139 TESTNET_STAKE_MAGIC_BYTE = 73 DEFAULT_PROTOCOL_VERSION = 70915 MINIMUM_FEE = 0.0001 # minimum PIV/kB starting_width = 933 starting_height = 666 APPDATA_DIRNAME = ".SecurePivxMasternodeTool" home_dir = os.path.expanduser('~') user_dir = os.path.join(home_dir, APPDATA_DIRNAME) log_File = os.path.join(user_dir, 'debug.log') database_File = os.path.join(user_dir, 'application.db') NEW_SIGS_HEIGHT_MAINNET = 2153200 NEW_SIGS_HEIGHT_TESTNET = 1347000
# coding:utf-8 import time from queue import Queue, Empty from threading import Event, Thread import slavewg stoped = Event() tasks_queue = Queue() # 要执行的脚本 # ads = slavewg.Ads(stoped, tasks_queue) # ads.start() # lbl = slavewg.LootBlackLotus(stoped, tasks_queue) # lbl.start(lbl.position['东泉谷山顶黑花']) heal = slavewg.Tabinterval(stoped, tasks_queue) heal.start('9', 30) fw = slavewg.Tabinterval(stoped, tasks_queue) fw.start('2', 60 * 4) def run(): time.sleep(5) while not stoped.wait(0.1): try: func = tasks_queue.get(timeout=1) func() except Empty: pass
def fit(self): "Fit the data" # Create labels column initialized to -1 (unclassified) self.df = np.append(self.df, np.array([[-1]*len(self.df)]).reshape(-1,1), axis=1) for x in range(len(self.df)): # if the point is not labled already then search for neighbors if self.df[x,2] != -1: continue # find neighbors p = self.df[x,:2] neighbors = self.rangeQuery(p) # If less neighbors than min_points then label as noise and continue if len(neighbors) < self.min_points: self.df[x,2] = self.noise continue # increment cluster label self.cluster_label += 1 # set current row to new cluster label self.df[x,2] = self.cluster_label # create seed set to hold all neighbors of cluster including the neighbors already found found_neighbors = neighbors # create Queue to fold all neighbors of cluster q = Queue() # add original neighbors for x in neighbors: q.put(x) # While isnt empty label new neighbors to cluster while q.empty() == False: current = q.get() # if cur_row labled noise then change to cluster label (border point) if self.df[current,2] == 0: self.df[current,2] = self.cluster_label # If label is not -1(unclassified) then continue if self.df[current,2] != -1: continue # label the neighbor self.df[current,2] = self.cluster_label # look for neightbors of cur_row point = self.df[current,:2] neighbors2 = self.rangeQuery(point) # if neighbors2 >= min_points then add those neighbors to seed_set if len(neighbors2) >= self.min_points: for x in neighbors2: if x not in found_neighbors: q.put(x) found_neighbors.append(x)
def main(): position_queue = Queue(450) request_page(position_queue) parse_detail(position_queue)
def get_question_yggk(): # 院校咨询页url main_url = "https://gaokao.chsi.com.cn" file_path = "Data" university_formid = [] with open("university_info", "rb") as p_file: university_infos = pickle.load(p_file) for info in university_infos: if "985" in info["院校特性"] or "211" in info["院校特性"]: if info["forum_id"] != "": university_formid.append([info["院校名称"], info["forum_id"]]) print("共有%d所985、211大学" % len(university_formid)) for university in university_formid: begin = time.time() print("开始抓取" + university[0] + "的招生问题数据...") main_page_url = "https://gaokao.chsi.com.cn/zxdy/forum--method-listDefault,year-2005,forumid-" + university[ 1] + ",start-0.dhtml" try: main_page_source = request_url(main_page_url) main_page_source.encoding = main_page_source.apparent_encoding main_page_soup = BeautifulSoup(main_page_source.content, "lxml") # 获取页面总数,页面栏含有省略号、不含省略号两种查找方式 if main_page_soup.find("li", class_="lip dot"): page_count = main_page_soup.find( "li", class_="lip dot").next_sibling.a.string else: page_count = main_page_soup.find( "ul", class_="ch-page clearfix").find_all("li")[-2].a.string # 置顶问题个数 top_question_count = len( main_page_soup.find("table", class_="ch-table zx-table").find_all( "span", class_="question_top_txt")) print("页面总数:%d 置顶问题个数:%d" % (int(page_count), int(top_question_count))) except Exception as e: # 招生咨询页面没有数据(三个大学) print("%s咨询界面没有数据,页面链接为:%s" % (university[0], main_page_url)) print("错误信息:%s" % e) continue # 创建该学校的问题集收集表,并写好表头 table_head = ["标题", "来源", "时间", "问题", "回答"] csvfile = open(file_path + "/" + university[0] + "常用问题集.csv", "w", newline="", encoding='utf-8') csvfile.truncate() writer = csv.writer(csvfile) writer.writerow(table_head) record_queue = Queue() # 每次开启10个线程,进行数据下载和存储 start_index = 0 end_index = 10 while True: if start_index > int(page_count): break else: dThread = [ DownloadPageInfo(university[1], page_id, int(page_count), top_question_count, record_queue) for page_id in range(start_index, end_index) ] sThread = SavePageInfo(record_queue, writer) for d in dThread: d.start() sThread.start() for d in dThread: d.join() record_queue.put(-1) sThread.join() start_index += 10 end_index += 10 if end_index > int(page_count): end_index = int(page_count) csvfile.close() print("抓取%s的信息用时:%ds" % (university[0], time.time() - begin))
def load_from_xml(self, filename): xml = etree.parse(filename) # graph id text_id = xml.xpath('/arggraph')[0].get('id') self.graph['id'] = text_id # add all EDU for elm in xml.xpath('/arggraph/edu'): self.add_edu(elm.get('id'), elm.text) # add all EDU-JOINS for elm in xml.xpath('/arggraph/joint'): self.add_edu_joint(elm.get('id')) # add all ADU for elm in xml.xpath('/arggraph/adu'): self.add_adu(elm.get('id'), elm.get('type')) # add all edges q = Queue() for elm in xml.xpath('/arggraph/edge'): q.put(elm) while not q.empty(): # TODO: queue processing might not end for input elements with # malformed targets, cyclic relations elm = q.get() edge_src = elm.get('src') if edge_src not in self.nodes(): print("Error: source unknown\n", etree.tostring(elm)) edge_trg = elm.get('trg') if edge_trg not in self.nodes(): # target node (of 'und' or 'add' relations) not there yet. # postpone to later q.put(elm) continue edge_type = elm.get('type') edge_id = elm.get('id') if edge_type == 'seg': src_trg_type_pair = (self.node[edge_src]['type'], self.node[edge_trg]['type']) if src_trg_type_pair in [('edu', 'adu'), ('edu', 'joint'), ('joint', 'adu')]: self.add_seg_edge(edge_src, edge_trg) else: print("Error: malformed segmentation edge\n", \ etree.tostring(elm)) elif edge_type in ['sup', 'exa', 'reb']: if (self.node[edge_src]['type'] == 'adu' and self.node[edge_trg]['type'] == 'adu'): self.add_edge_with_relation_node(edge_id, edge_src, edge_trg, edge_type) else: print("Error: malformed direct edge\n", etree.tostring(elm)) elif edge_type == 'und': if (self.node[edge_src]['type'] == 'adu' and self.node[edge_trg]['type'] == 'rel'): self.add_edge_with_relation_node(edge_id, edge_src, edge_trg, edge_type) else: print(("Error: malformed undercutting edge\n", etree.tostring(elm))) elif edge_type == 'add': if (self.node[edge_src]['type'] == 'adu' and self.node[edge_trg]['type'] == 'rel'): self.add_edge(elm.get('src'), elm.get('trg'), type='src') else: print("Error: malformed adding edge\n", etree.tostring(elm)) else: print("Error: unknown edge type\n", etree.tostring(elm)) # update adu short names self.update_adu_labels()
import numpy from queue import Queue import re import requests import json import base64 from PyQt5.QtWidgets import * import threading,time,os from PyQt5.QtCore import QTimer carre = "^(京[A-HJ-NPQY]|沪[A-HJ-N]|津[A-HJ-NPQR]|渝[A-DFGHN]|冀[A-HJRST]|晋[A-FHJ-M]|蒙[A-HJKLM]|辽[A-HJ-NP]|吉[A-HJK]|黑[A-HJ-NPR]|苏[A-HJ-N]|浙[A-HJKL]|皖[A-HJ-NP-S]|闽[A-HJK]|赣[A-HJKLMS]|鲁[A-HJ-NP-SUVWY]|豫[A-HJ-NP-SU]|鄂[A-HJ-NP-S]|湘[A-HJ-NSU]|粤[A-HJ-NP-Y]|桂[A-HJ-NPR]|琼[A-F]|川[A-HJ-MQ-Z]|贵[A-HJ]|云[AC-HJ-NP-SV]|藏[A-HJ]|陕[A-HJKV]|甘[A-HJ-NP]|青[A-H]|宁[A-E]|新[A-HJ-NP-S])([0-9A-HJ-NP-Z]{4}[0-9A-HJ-NP-Z挂试]|[0-9]{4}学|[A-D0-9][0-9]{3}警|[DF][0-9A-HJ-NP-Z][0-9]{4}|[0-9]{5}[DF])$|^WJ[京沪津渝冀晋蒙辽吉黑苏浙皖闽赣鲁豫鄂湘粤桂琼川贵云藏陕甘青宁新]?[0-9]{4}[0-9JBXTHSD]$|^(V[A-GKMORTV]|K[A-HJ-NORUZ]|H[A-GLOR]|[BCGJLNS][A-DKMNORVY]|G[JS])[0-9]{5}$|^[0-9]{6}使$|^([沪粤川渝辽云桂鄂湘陕藏黑]A|闽D|鲁B|蒙[AEH])[0-9]{4}领$|^粤Z[0-9A-HJ-NP-Z][0-9]{3}[港澳]$" #↑用来校验车牌的正则表达式 carpailist=[]#存最近识别的100个车牌的手动实现的队列,在队列中查找每个结果确保单个车牌不被多次触发 datalist = Queue() num=0 def cv2ImgAddText(img, text, left, top, textColor=(0, 255, 0), textSize=20): if (isinstance(img, numpy.ndarray)): img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)) draw = ImageDraw.Draw(img) fontText = ImageFont.truetype( "font/simsun.ttc", textSize, encoding="utf-8") draw.text((left, top), text, textColor, font=fontText) return cv2.cvtColor(numpy.asarray(img), cv2.COLOR_RGB2BGR) class lprclass: def __init__(self): self.running=True
def __init__(self): self.tag_queue = Queue() self.config = get_config_for_testing() self.db_backend_service = DatabaseMock(None)
def read_input(): num_nodes = int(input()) queue = Queue() queue.put(BSTNode(1)) return num_nodes, build_tree(queue)
from datetime import datetime, date, timezone from numpy.random import randint, uniform from math import floor from queue import Queue from subprocess import Popen from time import sleep import threading, sys, os sys.path.append( os.path.abspath(__file__).rsplit('tests/', 1)[0] + '/pysqream/') import dbapi q = Queue() varchar_length = 10 nvarchar_length = 10 max_bigint = sys.maxsize if sys.platform not in ('win32', 'cygwin') else 2147483647 def generate_varchar(length): return ''.join(chr(num) for num in randint(32, 128, length)) col_types = { 'bool', 'tinyint', 'smallint', 'int', 'bigint', 'real', 'double', 'date', 'datetime', 'varchar({})'.format(varchar_length), 'nvarchar({})'.format(varchar_length) } pos_test_vals = { 'bool': (0, 1, True, False, 2, 3.6, 'test', (1997, 5, 9), (1997, 12, 12,
def __init__(self, event_factory): self._event_factory = event_factory self._queue = Queue() self._producer = None self._consumers = [] self._event_handlers = defaultdict(list)
import threading from queue import Queue from spider import Spider from domain import * from general import * PROJECT_NAME='' HOMEPAGE='' DOMAIN_NAME=get_domain_name(HOMEPAGE) QUEUE_FILE=PROJECT_NAME+'/queue.txt' CRAWLED_FILE=PROJECT_NAME+'/crawled.txt' NUMBER_OF_THREADS=8 #thread queue queue=Queue() Spider(PROJECT_NAME,HOMEPAGE,DOMAIN_NAME) #creating threads def create_workers(): for _ in range(NUMBER_OF_THREADS): t=threading.Thread(target=work) t.daemon=True t.start() #do the next job in the queue def work(): while True: url=queue.get() Spider.crawl_page(threading.current_thread().name,url) queue.task_done()
def __init__(self, name: str, accepted_types: list): self.name = name self.accepted_types = accepted_types self.tasks_queue = Queue() self.active = False