예제 #1
0
def process_dialog_for_player(dialog_id, loop=False):
    _dialog = get_dialog(dialog_id)
    _dialog['choices'] = []
    _dialog['loop_choices'] = []
    _dialog['cursor_index'] = 0
    _last_message = get_last_message(dialog_id)

    if loop:
        end_dialog(dialog_id)
        locks.lock('camera_free')

        return False

    for response in get_matching_message(LIFE[SETTINGS['controlling']],
                                         dialog_id,
                                         _last_message['next_gist']):
        _to_check = [response]
        while _to_check:
            _response = _to_check.pop()

            if _response['text'].startswith('>'):
                _text = reformat_text(LIFE[SETTINGS['controlling']],
                                      get_listener(dialog_id), dialog_id,
                                      _response['text'][1:])
                _to_check.extend(
                    get_matching_message(LIFE[SETTINGS['controlling']],
                                         dialog_id, _text))
                _dialog['loop_choices'].extend(_to_check)
            else:
                _dialog['choices'].append(_response)

    _dialog['max_cursor_index'] = len(_dialog['choices'])
예제 #2
0
파일: dialog.py 프로젝트: athros/Reactor-3
def process_dialog_for_player(dialog_id, loop=False):
	_dialog = get_dialog(dialog_id)
	_dialog['choices'] = []
	_dialog['loop_choices'] = []
	_dialog['cursor_index'] = 0	
	_last_message = get_last_message(dialog_id)	
	
	if loop:
		end_dialog(dialog_id)
		locks.lock('camera_free')
		
		return False
	
	for response in get_matching_message(LIFE[SETTINGS['controlling']], dialog_id, _last_message['next_gist']):
		_to_check = [response]
		while _to_check:
			_response = _to_check.pop()
			
			if _response['text'].startswith('>'):
				_text = reformat_text(LIFE[SETTINGS['controlling']], get_listener(dialog_id), dialog_id, _response['text'][1:])
				_to_check.extend(get_matching_message(LIFE[SETTINGS['controlling']], dialog_id, _text))
				_dialog['loop_choices'].extend(_to_check)
			else:
				_dialog['choices'].append(_response)
	
	_dialog['max_cursor_index'] = len(_dialog['choices'])
예제 #3
0
def file_move_safe(old_file_name,
                   new_file_name,
                   chunk_size=1024 * 64,
                   allow_overwrite=False):
    """
    Moves a file from one location to another in the safest way possible.

    First, tries ``os.rename``, which is simple but will break across filesystems.
    If that fails, streams manually from one file to another in pure Python.

    If the destination file exists and ``allow_overwrite`` is ``False``, this
    function will throw an ``IOError``.
    """

    # There's no reason to move if we don't have to.
    if _samefile(old_file_name, new_file_name):
        return

    try:
        # If the destination file exists and allow_overwrite is False then raise an IOError
        if not allow_overwrite and os.access(new_file_name, os.F_OK):
            raise IOError(
                "Destination file %s exists and allow_overwrite is False" %
                new_file_name)

        os.rename(old_file_name, new_file_name)
        return
    except OSError:
        # This will happen with os.rename if moving to another filesystem
        # or when moving opened files on certain operating systems
        pass

    # first open the old file, so that it won't go away
    with open(old_file_name, 'rb') as old_file:
        # now open the new file, not forgetting allow_overwrite
        fd = os.open(new_file_name,
                     (os.O_WRONLY | os.O_CREAT | getattr(os, 'O_BINARY', 0) |
                      (os.O_EXCL if not allow_overwrite else 0)))
        try:
            locks.lock(fd, locks.LOCK_EX)
            current_chunk = None
            while current_chunk != b'':
                current_chunk = old_file.read(chunk_size)
                os.write(fd, current_chunk)
        finally:
            locks.unlock(fd)
            os.close(fd)
    copystat(old_file_name, new_file_name)

    try:
        os.remove(old_file_name)
    except OSError as e:
        # Certain operating systems (Cygwin and Windows)
        # fail when deleting opened files, ignore it.  (For the
        # systems where this happens, temporary files will be auto-deleted
        # on close anyway.)
        if getattr(e, 'winerror', 0) != 32 and getattr(e, 'errno', 0) != 13:
            raise
예제 #4
0
파일: dialog.py 프로젝트: athros/Reactor-3
def process(life, dialog_id):
	if not is_turn_to_talk(life, dialog_id):
		return False
	
	_last_message = get_last_message(dialog_id)
	
	if _last_message['next_gist'] == 'end':
		end_dialog(dialog_id)
		locks.lock('camera_free')
	elif 'player' in life:
		locks.unlock('camera_free', reason='Process dialog')
		process_dialog_for_player(dialog_id, loop=_last_message['loop'])
	else:
		say_via_gist(life, dialog_id, _last_message['next_gist'], loop=_last_message['loop'])
예제 #5
0
def process(life, dialog_id):
    if not is_turn_to_talk(life, dialog_id):
        return False

    _last_message = get_last_message(dialog_id)

    if _last_message['next_gist'] == 'end':
        end_dialog(dialog_id)
        locks.lock('camera_free')
    elif 'player' in life:
        locks.unlock('camera_free', reason='Process dialog')
        process_dialog_for_player(dialog_id, loop=_last_message['loop'])
    else:
        say_via_gist(life,
                     dialog_id,
                     _last_message['next_gist'],
                     loop=_last_message['loop'])
예제 #6
0
def show_next_event():
	if not EVENTS:
		return False
	
	_event = None
	
	for event in EVENTS:
		if not event['delay']:
			_event = event
			break
	
	if not _event:
		return False
	
	EVENTS.remove(_event)
	gfx.refresh_view('map')
	
	if not EVENTS:
		life.focus_on(LIFE[SETTINGS['following']])
		locks.lock('camera_free', reason='No more events')
		
		return False
	
	return True
예제 #7
0
    def __init__(self, torrent):
        self.torrent = torrent

        self.left = torrent.length
        self.peer_id = os.urandom(20)
        self.port = 6882
        self.uploaded = 0
        self.downloaded = 0
        self.finished = False

        self.chunk_queue = []
        self.chunks_left = []
        self.data_left = 0
        self.data = bytearray(torrent.length)

        self.lock = locks.lock()
예제 #8
0
def bot():
    try:
        logger.debug("Checking if script already run...")
        logger.debug(" testing lock of " + flockd_name)
        f = os.open(flockd_name, os.O_TRUNC | os.O_CREAT | os.O_RDWR)
        fres = locks.lock(f, locks.LOCK_EX + locks.LOCK_NB)
        if fres:
            logger.debug(" bot is not active")
            main()
        else:
            logger.debug("Script already running...")
    except IOError:
        logger.debug("Bot is already running")
    except Exception as inst:
        logger.error(type(inst))
        logger.error(inst.args)
        logger.error(inst)
    else:
        logger.debug("Exiting script and unlocking")
        locks.unlock(f)
        os.close(f)
        os.remove(flockd_name)
    logger.debug("Bot is off...")
예제 #9
0
 parser = argparse.ArgumentParser(add_help=True,
                                  description='Telegram bot')
 parser.add_argument("-d",
                     "--daemon",
                     action="store_true",
                     help="run as daemon, only Linux")
 parser.add_argument("-v",
                     "--verbose",
                     action="store_true",
                     help="detailed/debug log")
 args = parser.parse_args()
 logger = tg_logger.initLogger(args.verbose)
 logger.debug("Checking if script already run...")
 logger.debug(" testing lock of " + flockm_name)
 fm = os.open(flockm_name, os.O_TRUNC | os.O_CREAT | os.O_RDWR)
 fmres = locks.lock(fm, locks.LOCK_EX + locks.LOCK_NB)
 if fmres:  #main is not run
     logger.debug(" check if daemon is run: " + flockd_name)
     fd = os.open(flockd_name, os.O_TRUNC | os.O_CREAT | os.O_RDWR)
     fdres = locks.lock(fd, locks.LOCK_EX + locks.LOCK_NB)
     if fdres:  #not run - unlock and re-run as daemon
         locks.unlock(fd)
         logger.debug("dAemonize bot...")
         if args.daemon:
             if os.name == 'nt':
                 logger.warning(
                     "daemon mode is not supported in Windows")
             else:
                 with daemon.DaemonContext(
                         files_preserve=tg_logger.logger_handlers):
                     bot()
예제 #10
0
    def _save(self, name, content):
        full_path = self.path(name)

        # Create any intermediate directories that do not exist.
        # Note that there is a race between os.path.exists and os.makedirs:
        # if os.makedirs fails with EEXIST, the directory was created
        # concurrently, and we can continue normally. Refs #16082.
        directory = os.path.dirname(full_path)
        if not os.path.exists(directory):
            try:
                if self.directory_permissions_mode is not None:
                    # os.makedirs applies the global umask, so we reset it,
                    # for consistency with file_permissions_mode behavior.
                    old_umask = os.umask(0)
                    try:
                        os.makedirs(directory, self.directory_permissions_mode)
                    finally:
                        os.umask(old_umask)
                else:
                    os.makedirs(directory)
            except OSError as e:
                if e.errno != errno.EEXIST:
                    raise
        if not os.path.isdir(directory):
            raise IOError("%s exists and is not a directory." % directory)

        # There's a potential race condition between get_available_name and
        # saving the file; it's possible that two threads might return the
        # same name, at which point all sorts of fun happens. So we need to
        # try to create the file, but if it already exists we have to go back
        # to get_available_name() and try again.

        while True:
            try:
                # This file has a file path that we can move.
                if hasattr(content, 'temporary_file_path'):
                    shutil.move(content.temporary_file_path(), full_path)

                # This is a normal uploadedfile that we can stream.
                else:
                    # This fun binary flag incantation makes os.open throw an
                    # OSError if the file already exists before we open it.
                    flags = (os.O_WRONLY | os.O_CREAT | os.O_EXCL |
                             getattr(os, 'O_BINARY', 0))
                    # The current umask value is masked out by os.open!
                    fd = os.open(full_path, flags, 0o666)
                    _file = None
                    try:
                        locks.lock(fd, locks.LOCK_EX)
                        for chunk in content.chunks():
                            if _file is None:
                                mode = 'wb' if isinstance(chunk, bytes) else 'wt'
                                _file = os.fdopen(fd, mode)
                            _file.write(chunk)
                    finally:
                        locks.unlock(fd)
                        if _file is not None:
                            _file.close()
                        else:
                            os.close(fd)
            except OSError as e:
                if e.errno == errno.EEXIST:
                    # Ooops, the file exists. We need a new file name.
                    name = self.get_available_name(name)
                    full_path = self.path(name)
                else:
                    raise
            else:
                # OK, the file save worked. Break out of the loop.
                break

        if self.file_permissions_mode is not None:
            os.chmod(full_path, self.file_permissions_mode)

        return name
예제 #11
0
    def _save(self, name, content):
        full_path = self.path(name)

        # Create any intermediate directories that do not exist.
        # Note that there is a race between os.path.exists and os.makedirs:
        # if os.makedirs fails with EEXIST, the directory was created
        # concurrently, and we can continue normally. Refs #16082.
        directory = os.path.dirname(full_path)
        if not os.path.exists(directory):
            try:
                if self.directory_permissions_mode is not None:
                    # os.makedirs applies the global umask, so we reset it,
                    # for consistency with file_permissions_mode behavior.
                    old_umask = os.umask(0)
                    try:
                        os.makedirs(directory, self.directory_permissions_mode)
                    finally:
                        os.umask(old_umask)
                else:
                    os.makedirs(directory)
            except OSError as e:
                if e.errno != errno.EEXIST:
                    raise
        if not os.path.isdir(directory):
            raise IOError("%s exists and is not a directory." % directory)

        # There's a potential race condition between get_available_name and
        # saving the file; it's possible that two threads might return the
        # same name, at which point all sorts of fun happens. So we need to
        # try to create the file, but if it already exists we have to go back
        # to get_available_name() and try again.

        while True:
            try:
                # This file has a file path that we can move.
                if hasattr(content, 'temporary_file_path'):
                    shutil.move(content.temporary_file_path(), full_path)

                # This is a normal uploadedfile that we can stream.
                else:
                    # This fun binary flag incantation makes os.open throw an
                    # OSError if the file already exists before we open it.
                    flags = (os.O_WRONLY | os.O_CREAT | os.O_EXCL
                             | getattr(os, 'O_BINARY', 0))
                    # The current umask value is masked out by os.open!
                    fd = os.open(full_path, flags, 0o666)
                    _file = None
                    try:
                        locks.lock(fd, locks.LOCK_EX)
                        for chunk in content.chunks():
                            if _file is None:
                                mode = 'wb' if isinstance(chunk,
                                                          bytes) else 'wt'
                                _file = os.fdopen(fd, mode)
                            _file.write(chunk)
                    finally:
                        locks.unlock(fd)
                        if _file is not None:
                            _file.close()
                        else:
                            os.close(fd)
            except OSError as e:
                if e.errno == errno.EEXIST:
                    # Ooops, the file exists. We need a new file name.
                    name = self.get_available_name(name)
                    full_path = self.path(name)
                else:
                    raise
            else:
                # OK, the file save worked. Break out of the loop.
                break

        if self.file_permissions_mode is not None:
            os.chmod(full_path, self.file_permissions_mode)

        return name