def play_trailers(): # type: () -> None """ :return: """ my_trailer_dialog = None black_background = None exiting_playing_movie = False try: black_background = BlackBackground.get_instance() black_background.show() legal_info = LegalInfo('legal.xml', Constants.ADDON_PATH, 'Default') legal_info.show() Monitor.throw_exception_if_abort_requested(timeout=10.0) legal_info.close() legal_info.destroy() my_trailer_dialog = TrailerDialog('script-trailerwindow.xml', Constants.ADDON_PATH, 'Default') exiting_playing_movie = my_trailer_dialog.doModal() finally: if my_trailer_dialog is not None: del my_trailer_dialog my_trailer_dialog = None if black_background is not None: black_background.destroy() del black_background black_background = None if exiting_playing_movie: if logger.isEnabledFor(LazyLogger.DEBUG_VERBOSE): logger.debug('ReplaceWindow(12005)') xbmc.executebuiltin('ReplaceWindow(12005)')
def returned_trailer(cls, data): # type: (Any) -> None """ Front-end receives trailer from back-end :param data: :return: """ try: Monitor.throw_exception_if_abort_requested() cls._next_trailer = data.get('trailer', None) cls._status = data.get('status', None) if cls._status == FrontendBridgeStatus.BUSY: Monitor.throw_exception_if_abort_requested(timeout=2.0) elif cls._logger.isEnabledFor(LazyLogger.DEBUG_EXTRA_VERBOSE): if cls._next_trailer is None: title = 'No Trailer Received' else: title = cls._next_trailer.get(Movie.TITLE, 'No Title') cls._logger.debug_extra_verbose('status:', cls._status, 'received trailer for:', title) except AbortException: reraise(*sys.exc_info()) except Exception as e: cls._logger.exception('')
def delay_between_transactions(cls, source: str, video: bool) -> None: if video: delay_range = DOWNLOAD_VIDEO_DELAY_BY_SOURCE[source] else: delay_range = DOWNLOAD_INFO_DELAY_BY_SOURCE[source] delay = cls.get_delay(delay_range) # min_time_between_requests = datetime.timedelta(seconds=10.0) try: cls.get_lock(source) # Block new transaction # HAVE LOCK if source == Movie.ITUNES_SOURCE: waited: datetime.timedelta = ( datetime.datetime.now() - cls._last_itunes_request_timestamp) else: waited: datetime.timedelta = ( datetime.datetime.now() - cls._last_youtube_request_timestamp) time_to_wait = delay - waited.total_seconds() if time_to_wait > 0.0: Monitor.throw_exception_if_abort_requested(time_to_wait) finally: cls.release_lock(source) # LOCK RELEASED if source == Movie.ITUNES_SOURCE: cls._last_itunes_request_timestamp = datetime.datetime.now() else: cls._last_youtube_request_timestamp = datetime.datetime.now()
def run_worker(self) -> None: clz = RunCommand rc = 0 env = os.environ.copy() try: if xbmc.getCondVisibility('System.Platform.Windows'): # Prevent console for ffmpeg from opening self.process = subprocess.Popen( self.args, stdin=None, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False, universal_newlines=True, env=env, close_fds=True, creationflags=subprocess.DETACHED_PROCESS) else: self.process = subprocess.Popen( self.args, stdin=None, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False, universal_newlines=True, env=env, close_fds=True) self.stdout_thread = threading.Thread(target=self.stdout_reader, name='normalize stdout reader') Monitor.throw_exception_if_abort_requested() self.stdout_thread.start() self.stderr_thread = threading.Thread(target=self.stderr_reader, name='normalize stderr reader') self.stderr_thread.start() except AbortException as e: pass # Let thread die except Exception as e: clz.logger.exception(e)
def play(self, item="", listitem=None, windowed=False, startpos=-1): # type: (Union[PlayList], 'xbmcgui.ListItem', bool, int) ->None """ Play a item. :param item: [opt] string - filename, url or playlist :param listitem: [opt] listitem - used with setInfo() to set different infolabels. :param windowed: [opt] bool - true=play video windowed, false=play users preference.(default) :param startpos: [opt] int - starting position when playing a playlist. Default = -1 If item is not given then the Player will try to play the current item in the current playlist. You can use the above as keywords for arguments and skip certain optional arguments. Once you use a keyword, all following arguments require the keyword. Example:: listitem = xbmcgui.ListItem('Ironman') listitem.setInfo('video', {'Title': 'Ironman', 'Genre': 'Science Fiction'}) xbmc.Player().play(url, listitem, windowed) xbmc.Player().play(playlist, listitem, windowed, startpos) """ local_class = AdvancedPlayer Monitor.throw_exception_if_abort_requested() if type(self).DEBUG_MONITOR: local_class._logger.enter() super().play(item, listitem, windowed, startpos) self.enableAdvancedMonitoring()
def get(self, block: bool = True, timeout: Optional[float] = None) -> Union[MovieType, None]: """ :param block: :param timeout: :return: """ if not block: timeout = 0 if timeout is None: timeout = float(60 * 60 * 24 * 365) # A year time_remaining = timeout time_chunk = 0.01 finished = False item = None while not finished: try: with self._lock: item = self._wrapped_queue.get(block=False) finished = True except KodiQueue.Empty: Monitor.throw_exception_if_abort_requested(timeout=time_chunk) time_remaining -= time_chunk if time_remaining <= 0: raise KodiQueue.Empty return item
def load_unprocessed_movie_cache(cls): # type: () -> None """ :return: """ path = os.path.join(Settings.get_remote_db_cache_path(), 'index', 'tmdb_unprocessed_movies.json') path = xbmcvfs.validatePath(path) try: parent_dir, file_name = os.path.split(path) DiskUtils.create_path_if_needed(parent_dir) with CacheIndex.lock: if os.path.exists(path): with io.open(path, mode='rt', newline=None, encoding='utf-8') as cacheFile: cls._unprocessed_movies = json.load( cacheFile, encoding='utf-8', object_hook=CacheIndex.datetime_parser) cls.last_saved_movie_timestamp = None cls._unprocessed_movie_changes = 0 else: cls._unprocessed_movies = {} Monitor.throw_exception_if_abort_requested() except AbortException: reraise(*sys.exc_info()) except IOError as e: CacheIndex.logger().exception('') except JSONDecodeError as e: os.remove(path) except Exception as e: CacheIndex.logger().exception('')
def get_from_fetch_queue(self, player_starving: bool = False) -> MovieType: """ :return: """ clz = AbstractMovieData # if self.logger.isEnabledFor(LazyLogger.DEBUG_EXTRA_VERBOSE): # self.logger.debug_extra_verbose('starving:', player_starving) self.load_fetch_queue() trailer = None if self._trailers_to_fetch_queue.empty(): if self.logger.isEnabledFor(LazyLogger.DEBUG_VERBOSE): self.logger.debug_verbose(': empty') while trailer is None: try: if player_starving: trailer = self.get_from_starvation_queue() if trailer is None: trailer = self._trailers_to_fetch_queue.get(timeout=0.5) except KodiQueue.Empty: Monitor.throw_exception_if_abort_requested() if self.logger.isEnabledFor(LazyLogger.DEBUG_EXTRA_VERBOSE): self.logger.debug_extra_verbose( 'Got:', trailer[Movie.TITLE], 'from fetch queue') return trailer
def load_trailers() -> None: """ Start up the configured trailer discovery threads. Called whenever settings have changed to start any threads that have just ben enabled. :return: """ module_logger.enter() if Settings.get_include_library_trailers(): lib_instance = DiscoverLibraryMovies() lib_instance.discover_basic_information() # Manufacture trailer entries for folders which contain trailer # files. Note that files are assumed to be videos. if Settings.get_include_trailer_folders(): DiscoverFolderTrailers().discover_basic_information() if Settings.get_include_itunes_trailers(): DiscoverItunesMovies().discover_basic_information() if Settings.get_include_tmdb_trailers(): DiscoverTmdbMovies().discover_basic_information() if Settings.is_include_tfh_trailers(): DiscoverTFHMovies().discover_basic_information() Monitor.throw_exception_if_abort_requested(timeout=1.0) Monitor.set_startup_complete()
def bootstrap_random_trailers(screensaver: bool) -> None: """ :param screensaver: True when launched as a screensaver :return: """ try: Monitor.register_settings_changed_listener( Settings.on_settings_changed) Monitor.register_settings_changed_listener( LazyLogger.on_settings_changed) MainThreadLoop.class_init(screensaver) MainThreadLoop.startup() # LazyLogger can be unusable during shutdown if module_logger.isEnabledFor(LazyLogger.DEBUG): module_logger.exit('Exiting plugin') except AbortException: pass # Exit in finally block except Exception: module_logger.exception('') finally: if REMOTE_DEBUG: try: pydevd.stoptrace() except Exception: pass sys.exit(0)
def __next__(self): # type: () -> Union[dict, None] """ :return: """ movie = None try: finished = False attempt = 0 while not finished: try: attempt += 1 movie = self._do_next() finished = True except RestartDiscoveryException: Monitor.throw_exception_if_abort_requested(timeout=0.10) if self.logger.isEnabledFor(LazyLogger.DEBUG_VERBOSE): self.logger.debug_verbose( 'Rediscovery in progress. attempt:', attempt) except Exception as e: self.logger.exception('') reraise(*sys.exc_info()) return movie
def status_hook(self, status: Dict[str, str]) -> None: clz = BaseInfoHook if Monitor.is_abort_requested(): self._callback._error = 99 # Kill YoutubeDL Monitor.throw_exception_if_abort_requested() status_str = status.get('status', 'missing status') if status_str is None: clz._logger.debug('Missing status indication') elif status_str == 'downloading': self._download_eta = status.get('eta', 0) # In seconds elif status_str == 'error': clz._logger.error('Status:', str(status)) self.error_lines.append('Error downloading') self._error = VideoDownloader.DOWNLOAD_ERROR elif status_str == 'finished': filename = status.get('filename') tmpfilename = status.get('tmpfilename') downloaded_bytes = status.get('downloaded_bytes') total_bytes = status.get('total_bytes') total_bytes_estimate = status.get('total_bytes_estimate') elapsed = status.get('elapsed') eta = status.get('eta') speed = status.get('speed') fragment_index = status.get('fragment_index') fragment_count = status.get('fragment_count') clz._logger.debug('Finished')
def save_cache(cls): # type: () -> None """ :return: """ path = os.path.join(Settings.get_remote_db_cache_path(), 'index', 'tmdb_discovery_parameters.json') path = xbmcvfs.validatePath(path) parent_dir, file_name = os.path.split(path) if not os.path.exists(parent_dir): DiskUtils.create_path_if_needed(parent_dir) with CacheIndex.lock: try: Monitor.throw_exception_if_abort_requested() with io.open( path, mode='wt', newline=None, encoding='utf-8', ) as cacheFile: json_text = cls.to_json() cacheFile.write(json_text) cacheFile.flush() except AbortException: reraise(*sys.exc_info()) except (IOError) as e: cls._logger.exception('') except Exception as e: cls._logger.exception('')
def init_class(cls) -> None: """ """ if cls._logger is None: cls._logger = module_logger.getChild(cls.__name__) Monitor.register_settings_changed_listener(cls.on_settings_changed)
def save_unprocessed_movie_cache(cls, flush=False): # type: (bool) -> None """ :param flush: :return: """ # TODO: Should use lock here, review locking with cls.lock: if cls._unprocessed_movie_changes == 0: return if (not flush and # Constants.TRAILER_CACHE_FLUSH_UPDATES) (cls._unprocessed_movie_changes < 10) and (datetime.datetime.now() - \ cls._last_saved_unprocessed_movie_timestamp) < datetime.timedelta(minutes=5)): return path = os.path.join(Settings.get_remote_db_cache_path(), 'index', 'tmdb_unprocessed_movies.json') path = xbmcvfs.validatePath(path) parent_dir, file_name = os.path.split(path) if not os.path.exists(parent_dir): DiskUtils.create_path_if_needed(parent_dir) try: with io.open( path, mode='wt', newline=None, encoding='utf-8', ) as cacheFile: # TODO: Need ability to interrupt when ABORT. Object_handler # not a valid arg to dumps json_text = json.dumps(cls.get_unprocessed_movies(), encoding='utf-8', ensure_ascii=False, default=CacheIndex.handler, indent=3, sort_keys=True) cacheFile.write(json_text) cacheFile.flush() cls._last_saved_unprocessed_movie_timestamp = datetime.datetime.now( ) cls._unprocessed_movie_changes = 0 Monitor.throw_exception_if_abort_requested() except AbortException: reraise(*sys.exc_info()) except IOError as e: cls.logger().exception('') except Exception as e: cls.logger().exception('')
def abort_checker(dct: Dict[str, Any]) -> Dict[str, Any]: """ :param dct: :return: """ Monitor.throw_exception_if_abort_requested() return dct
def add_to_ready_to_play_queue(self, movie: MovieType) -> None: """ :param movie: :return: """ clz = PlayableTrailersContainer if clz.logger.isEnabledFor(LazyLogger.DEBUG_VERBOSE): if Movie.TITLE not in movie: clz.logger.warning('Invalid movie entry. Missing title: ', str(movie)) Debug.validate_detailed_movie_properties(movie, stack_trace=False) try: title = movie[Movie.TITLE] if title not in clz._recently_played_trailers: clz._recently_played_trailers[title] = movie if len(clz._recently_played_trailers) > 10: clz._recently_played_trailers.popitem() else: if clz.logger.isEnabledFor(LazyLogger.DEBUG_VERBOSE): clz.logger.debug_verbose( f'Movie: {title} played recently, skipping') return except Exception as e: clz.logger.exception(e) if clz.logger.isEnabledFor(LazyLogger.DEBUG): clz.logger.debug_verbose('movie:', movie[Movie.TITLE], 'queue empty:', self._ready_to_play_queue.empty(), 'full:', self._ready_to_play_queue.full()) finished = False waited = 0 while not finished: try: self._ready_to_play_queue.put(movie, block=True, timeout=0.05) finished = True self._number_of_added_trailers += 1 except (queue.Full): waited += 1 Monitor.throw_exception_if_abort_requested(timeout=0.5) if not clz._any_trailers_available_to_play.isSet(): if clz.logger.isEnabledFor(LazyLogger.DEBUG_VERBOSE): clz.logger.debug_verbose( 'Setting _any_trailers_available_to_play') clz._any_trailers_available_to_play.set() self._is_playable_trailers.set() if clz.logger.isEnabledFor(LazyLogger.DEBUG_EXTRA_VERBOSE): clz.logger.debug_extra_verbose('readyToPlayQueue size:', self._ready_to_play_queue.qsize(), 'waited:', waited) return
def save_search_pages(self, flush=False): # type: (bool) -> None """ :return: """ with CacheIndex.lock: if (not flush and self.get_number_of_unsaved_changes() < Constants.TRAILER_CACHE_FLUSH_UPDATES and self.get_time_since_last_save() < datetime.timedelta(minutes=5)): return saved_pages = len(self._cached_page_by_key.items()) path = xbmcvfs.validatePath(self._path) temp_path = xbmcvfs.validatePath(self._temp_path) try: parent_dir, file_name = os.path.split(path) DiskUtils.create_path_if_needed(parent_dir) Monitor.throw_exception_if_abort_requested() with io.open(temp_path, mode='wt', newline=None, encoding='utf-8') as cacheFile: json_dict = self.to_json() # TODO: Need ability to interrupt when ABORT. Object_handler # not a valid arg to dumps json_text = json.dumps(json_dict, encoding='utf-8', ensure_ascii=False, default=CacheIndex.handler, indent=3, sort_keys=True) cacheFile.write(json_text) cacheFile.flush() self._number_of_unsaved_changes = 0 self._time_of_last_save = datetime.datetime.now() try: os.replace(temp_path, path) except OSError: self._logger.exception( f'Failed to replace move information' f' planned for download: {path}') Monitor.throw_exception_if_abort_requested() except AbortException: reraise(*sys.exc_info()) except IOError as e: self._logger.exception('') except JSONDecodeError as e: os.remove(path) except Exception as e: self._logger.exception('') self._logger.debug_verbose("Entries Saved: ", saved_pages)
def monitor(self): Monitor.throw_exception_if_abort_requested() if not self._monitor_thread or not self._monitor_thread.isAlive(): if self._monitor_thread: self._monitor_thread.join() self._monitor_thread = threading.Thread( target=self._monitor, name='AdvancedPlayer:MONITOR') self._monitor_thread.start()
def remove_self(self): # type: () -> None """ The Discoverxx thread is being shutdown, perhaps due to changed settings. """ clz = BaseDiscoverMovies Monitor.unregister_settings_changed_listener(self.on_settings_changed) self._movie_data.remove()
def get_lock(cls, source: str): lock_source = cls.get_lock_source(source) if cls._logger.isEnabledFor(LazyLogger.DISABLED): cls._logger.debug_extra_verbose(f'Getting Lock: {lock_source} ' f'for {source}') while not cls.locks[source].acquire(blocking=False): Monitor.throw_exception_if_abort_requested(timeout=0.5) if cls._logger.isEnabledFor(LazyLogger.DISABLED): cls._logger.debug_extra_verbose(f'Got Lock: {source}')
def wait_until_restart_or_shutdown(self): # type: () -> None """ :return: """ clz = BaseDiscoverMovies finished = False while not finished: Monitor.wait_for_abort(timeout=1.0) self.throw_exception_on_forced_to_stop()
def warning(self, line: str) -> None: if Monitor.is_abort_requested(): self._callback._error = 99 # Kill YoutubeDL Monitor.throw_exception_if_abort_requested() if 'merged' in line: # str: Requested formats are incompatible for merge and will be merged into # mkv. pass else: self.warning_lines.append(line)
def handler(obj: Any) -> Any: """ :param obj: :return: """ Monitor.throw_exception_if_abort_requested() if hasattr(obj, 'isoformat'): return obj.isoformat() else: raise TypeError( 'Object of type %s with value of %s is not JSON serializable' % (type(obj), repr(obj)))
def wait_if_too_many_requests(cls, source: str, video: bool) -> None: if source == Movie.ITUNES_SOURCE: return delay = cls.get_youtube_wait_seconds() if delay <= 0.0: return cls._logger.debug(f'Waiting for TOO_MANY_REQUESTS: {delay} seconds.') delay = cls.get_youtube_wait_seconds() if delay > 0.0: Monitor.throw_exception_if_abort_requested(delay) cls._logger.debug('Wait for TOO_MANY_REQUESTS complete')
def unregister_slot(cls, signaler_id, signal): # type: (str, str) -> None """ :param signaler_id: :param signal: :return: """ Monitor.throw_exception_if_abort_requested() try: AddonSignals.unRegisterSlot(signaler_id, signal) except Exception: pass
def read_cached_value_from_disk(cls): # type: () -> CacheParameters """ :return: """ path = os.path.join(Settings.get_remote_db_cache_path(), 'index', 'tmdb_discovery_parameters.json') path = xbmcvfs.validatePath(path) parent_dir, file_name = os.path.split(path) if not os.path.exists(parent_dir): DiskUtils.create_path_if_needed(parent_dir) saved_preferences = None with CacheIndex.lock: try: if not os.access(path, os.R_OK): cls._logger.error( Messages.get_formatted_msg(Messages.CAN_NOT_READ_FILE, path)) return None file_mod_time = datetime.datetime.fromtimestamp( os.path.getmtime(path)) now = datetime.datetime.now() expiration_time = now - datetime.timedelta( Settings.get_expire_remote_db_cache_entry_days()) if file_mod_time < expiration_time: if cls._logger.isEnabledFor(LazyLogger.DEBUG): cls._logger.debug('cache file EXPIRED for:', path) return None Monitor.throw_exception_if_abort_requested() with io.open(path, mode='rt', newline=None, encoding='utf-8') as cacheFile: saved_preferences = json.load(cacheFile, encoding='utf-8') saved_preferences = CacheParameters(saved_preferences) except AbortException: reraise(*sys.exc_info()) except IOError as e: cls._logger.exception('') exception_occurred = True except Exception as e: cls._logger.exception('') exception_occurred = True return saved_preferences
def save_found_trailer_ids_cache(cls, flush=False): # type: (bool) -> None """ :param flush: :return: """ with cls.lock: if cls._unsaved_trailer_changes == 0: return if (not flush and (cls._unsaved_trailer_changes < Constants.TRAILER_CACHE_FLUSH_UPDATES) and (datetime.datetime.now() - cls._last_saved_trailer_timestamp) < datetime.timedelta(minutes=5)): return path = os.path.join(Settings.get_remote_db_cache_path(), 'index', 'tmdb_found_trailers.json') path = xbmcvfs.validatePath(path) parent_dir, file_name = os.path.split(path) if not os.path.exists(parent_dir): DiskUtils.create_path_if_needed(parent_dir) try: with io.open( path, mode='wt', newline=None, encoding='utf-8', ) as cacheFile: found_trailer_id_list = list( cls._found_tmdb_trailer_ids) json_text = json.dumps(found_trailer_id_list, encoding='utf-8', ensure_ascii=False, default=CacheIndex.handler, indent=3, sort_keys=True) cacheFile.write(json_text) cacheFile.flush() cls._last_saved_trailer_timestamp = datetime.datetime.now( ) cls._unsaved_trailer_changes = 0 Monitor.throw_exception_if_abort_requested() except AbortException: reraise(*sys.exc_info()) except IOError as e: CacheIndex.logger().exception('') except Exception as e: CacheIndex.logger().exception('')
def wait_for_is_not_playing_video(self, timeout=None, trace=None): # type: (float, str) -> Union[bool, None] ''' This is a mess. The preferred way to deal with this is to monitor onPlayBackStarted/ onPlayBackEnded events, but onPlayBackEnded is not reliably sent. So, poll isPlayingVideo, which is True prior to the video actually being played, so some method calls can throw exceptions until onPlayBackStarted is issued. Sigh Perhaps rely on onVidowWindowOpened/Closed, but that depends upon the actual dialog opening/closing. Not good ''' local_class = AdvancedPlayer try: if timeout is None: timeout = 0 if self._player_window_open: timeout = self.getTime() timeout = self.getTotalTime() - timeout + 2 except Exception: # Player must be finished timeout = 0 timeout = timeout * 1000 # Convert to ms while (self._player_window_open and timeout > 0 and not Monitor.wait_for_abort(0.250)): timeout -= 250 if timeout > 0: return False return True
def make_env(env_id, env_type, mpi_rank=0, subrank=0, seed=None, reward_scale=1.0, gamestate=None, flatten_dict_observations=True, wrapper_kwargs=None, logger_dir=None): wrapper_kwargs = wrapper_kwargs or {} # if env_type == 'atari': # env = make_atari(env_id) # elif env_type == 'retro': # import retro # gamestate = gamestate or retro.State.DEFAULT # env = retro_wrappers.make_retro(game=env_id, max_episode_steps=10000, use_restricted_actions=retro.Actions.DISCRETE, state=gamestate) # else: env = gym.make(env_id) if flatten_dict_observations and isinstance(env.observation_space, gym.spaces.Dict): keys = env.observation_space.spaces.keys() env = gym.wrappers.FlattenDictWrapper(env, dict_keys=list(keys)) env.seed(seed + subrank if seed is not None else None) env = Monitor(env, logger_dir and os.path.join(logger_dir, str(mpi_rank) + '.' + str(subrank)), allow_early_resets=True) # if env_type == 'atari': # env = wrap_deepmind(env, **wrapper_kwargs) # elif env_type == 'retro': # env = retro_wrappers.wrap_deepmind_retro(env, **wrapper_kwargs) # if reward_scale != 1: # env = retro_wrappers.RewardScaler(env, reward_scale) return env
def run(env_id, seed, noise_type, layer_norm, evaluation, **kwargs): # Create envs. env = gym.make(env_id) env = Monitor(env, logger.get_dir() and os.path.join(logger.get_dir(), str(0))) if evaluation: eval_env = gym.make(env_id) eval_env = Monitor(eval_env, os.path.join(logger.get_dir(), 'gym_eval')) env = Monitor(env, None) else: eval_env = None # Parse noise_type action_noise = None param_noise = None nb_actions = env.action_space.shape[-1] for current_noise_type in noise_type.split(','): current_noise_type = current_noise_type.strip() if current_noise_type == 'none': pass elif 'adaptive-param' in current_noise_type: _, stddev = current_noise_type.split('_') param_noise = AdaptiveParamNoiseSpec(initial_stddev=float(stddev), desired_action_stddev=float(stddev)) elif 'normal' in current_noise_type: _, stddev = current_noise_type.split('_') action_noise = NormalActionNoise(mu=np.zeros(nb_actions), sigma=float(stddev) * np.ones(nb_actions)) elif 'ou' in current_noise_type: _, stddev = current_noise_type.split('_') action_noise = OrnsteinUhlenbeckActionNoise(mu=np.zeros(nb_actions), sigma=float(stddev) * np.ones(nb_actions)) else: raise RuntimeError('unknown noise type "{}"'.format(current_noise_type)) # Configure components. memory = Memory(limit=int(1e6), action_shape=env.action_space.shape, observation_shape=env.observation_space.shape) critic = Critic(layer_norm=layer_norm) actor = Actor(nb_actions, layer_norm=layer_norm) # Seed everything to make things reproducible. logger.info('seed={}, logdir={}'.format(seed, logger.get_dir())) tf.reset_default_graph() set_global_seeds(seed) env.seed(seed) if eval_env is not None: eval_env.seed(seed) start_time = time.time() training.train(env=env, eval_env=eval_env, param_noise=param_noise, action_noise=action_noise, actor=actor, critic=critic, memory=memory, **kwargs) env.close() if eval_env is not None: eval_env.close() logger.info('total runtime: {}s'.format(time.time() - start_time))