def create_spock_profile(userdir, profile, door_name=None): """Create spock profile directory and configuration file from a template file :param userdir: directory where the spock profile will be created :param profile: profile name :param door_name: door name, if None, user will be asked for the door name :""" if not os.path.isdir(userdir): ProfileDir.create_profile_dir(userdir) p_dir = ProfileDir.create_profile_dir_by_name(userdir, profile) ipy_profile_dir = p_dir.location try: _create_config_file(ipy_profile_dir) # catch BaseException in order to catch also KeyboardInterrupt except BaseException: import shutil try: shutil.rmtree(ipy_profile_dir) except OSError: msg = ('Could not remove spock profile directory {0}. ' 'Remove it by hand e.g. rmdir {0}').format(ipy_profile_dir) print(msg) sys.exit(-1)
def _create_base_ipython_dirs(): """Create default user directories to prevent potential race conditions downstream. """ utils.safe_makedir(get_ipython_dir()) ProfileDir.create_profile_dir_by_name(get_ipython_dir()) utils.safe_makedir(os.path.join(get_ipython_dir(), "db")) utils.safe_makedir(os.path.join(locate_profile(), "db"))
def init_profile_dir(self): """initialize the profile dir""" self._in_init_profile_dir = True if self.profile_dir is not None: # already ran return if 'ProfileDir.location' not in self.config: # location not specified, find by profile name try: p = ProfileDir.find_profile_dir_by_name( self.ipython_dir, self.profile, self.config) except ProfileDirError: # not found, maybe create it (always create default profile) if self.auto_create or self.profile == 'default': try: p = ProfileDir.create_profile_dir_by_name( self.ipython_dir, self.profile, self.config) except ProfileDirError: self.log.fatal( "Could not create profile: %r" % self.profile) self.exit(1) else: self.log.info("Created profile dir: %r" % p.location) else: self.log.fatal("Profile %r not found." % self.profile) self.exit(1) else: self.log.info("Using existing profile dir: %r" % p.location) else: location = self.config.ProfileDir.location # location is fully specified try: p = ProfileDir.find_profile_dir(location, self.config) except ProfileDirError: # not found, maybe create it if self.auto_create: try: p = ProfileDir.create_profile_dir( location, self.config) except ProfileDirError: self.log.fatal( "Could not create profile directory: %r" % location) self.exit(1) else: self.log.info( "Creating new profile dir: %r" % location) else: self.log.fatal( "Profile directory %r not found." % location) self.exit(1) else: self.log.info("Using existing profile dir: %r" % location) # if profile_dir is specified explicitly, set profile name dir_name = os.path.basename(p.location) if dir_name.startswith('profile_'): self.profile = dir_name[8:] self.profile_dir = p self.config_file_paths.append(p.location) self._in_init_profile_dir = False
def create_sardana_profile(profile, door_name): ipython_dir = get_ipython_dir() try: ProfileDir.find_profile_dir_by_name(ipython_dir, profile) except ProfileDirError: from sardana.spock.genutils import create_spock_profile create_spock_profile(ipython_dir, "spock", profile, door_name)
def ensure_profile(): """ """ canonical_prof = os.path.join(SMASHLIB_DIR, 'ipython_config.py') ProfileDir.create_profile_dir_by_name(SMASH_DIR, main_profile_name) profile_dir = os.path.join(SMASH_DIR, 'profile_' + main_profile_name) config_file = os.path.join(profile_dir, 'ipython_config.py') shutil.copy(canonical_prof, config_file,) return profile_dir
def init_profile_dir(self): """initialize the profile dir""" try: # location explicitly specified: location = self.config.ProfileDir.location except AttributeError: # location not specified, find by profile name try: p = ProfileDir.find_profile_dir_by_name( self.ipython_dir, self.profile, self.config) except ProfileDirError: # not found, maybe create it (always create default profile) if self.auto_create or self.profile == 'python3': try: p = ProfileDir.create_profile_dir_by_name( self.ipython_dir, self.profile, self.config) except ProfileDirError: self.log.fatal( "Could not create profile: %r" % self.profile) self.exit(1) else: self.log.info("Created profile dir: %r" % p.location) else: self.log.fatal("Profile %r not found." % self.profile) self.exit(1) else: self.log.info("Using existing profile dir: %r" % p.location) else: # location is fully specified try: p = ProfileDir.find_profile_dir(location, self.config) except ProfileDirError: # not found, maybe create it if self.auto_create: try: p = ProfileDir.create_profile_dir( location, self.config) except ProfileDirError: self.log.fatal("Could not create profile directory: %r" % location) self.exit(1) else: self.log.info( "Creating new profile dir: %r" % location) else: self.log.fatal( "Profile directory %r not found." % location) self.exit(1) else: self.log.info("Using existing profile dir: %r" % location) self.profile_dir = p self.config_file_paths.append(p.location)
def create_spock_profile(userdir, profile, door_name=None): """Create spock profile directory and configuration file from a template file :param userdir: directory where the spock profile will be created :param profile: profile name :param door_name: door name, if None, user will be asked for the door name """ if not os.path.isdir(userdir): ProfileDir.create_profile_dir(userdir) p_dir = ProfileDir.create_profile_dir_by_name(userdir, profile) ipy_profile_dir = p_dir.location _create_config_file(ipy_profile_dir)
def list_running_servers(profile='default'): """Iterate over the server info files of running notebook servers. Given a profile name, find nbserver-* files in the security directory of that profile, and yield dicts of their information, each one pertaining to a currently running notebook server instance. """ pd = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), name=profile) for file in os.listdir(pd.security_dir): if file.startswith('nbserver-'): with io.open( os.path.join(pd.security_dir, file), encoding='utf-8') as f: info = json.load(f) # Simple check whether that process is really still running # Also remove leftover files from IPython 2.x without a pid field if ('pid' in info) and check_pid(info['pid']): yield info else: # If the process has died, try to delete its info file try: os.unlink(file) except OSError: pass # TODO: This should warn or log or something
def __init__(self, exec_lines=None): self.cout = StringIO() if exec_lines is None: exec_lines = [] # Create config object for IPython config = Config() config.HistoryManager.hist_file = ":memory:" config.InteractiveShell.autocall = False config.InteractiveShell.autoindent = False config.InteractiveShell.colors = "NoColor" # create a profile so instance history isn't saved tmp_profile_dir = tempfile.mkdtemp(prefix="profile_") profname = "auto_profile_sphinx_build" pdir = os.path.join(tmp_profile_dir, profname) profile = ProfileDir.create_profile_dir(pdir) # Create and initialize global ipython, but don't start its mainloop. # This will persist across different EmbededSphinxShell instances. IP = InteractiveShell.instance(config=config, profile_dir=profile) atexit.register(self.cleanup) sys.stdout = self.cout sys.stderr = self.cout # For debugging, so we can see normal output, use this: # from IPython.utils.io import Tee # sys.stdout = Tee(self.cout, channel='stdout') # dbg # sys.stderr = Tee(self.cout, channel='stderr') # dbg # Store a few parts of IPython we'll need. self.IP = IP self.user_ns = self.IP.user_ns self.user_global_ns = self.IP.user_global_ns self.input = "" self.output = "" self.tmp_profile_dir = tmp_profile_dir self.is_verbatim = False self.is_doctest = False self.is_suppress = False # Optionally, provide more detailed information to shell. # this is assigned by the SetUp method of IPythonDirective # to point at itself. # # So, you can access handy things at self.directive.state self.directive = None # on the first call to the savefig decorator, we'll import # pyplot as plt so we can make a call to the plt.gcf().savefig self._pyplot_imported = False # Prepopulate the namespace. for line in exec_lines: self.process_input_line(line, store_history=False)
def test_list_profiles_in(): # No need to remove these directories and files, as they will get nuked in # the module-level teardown. td = tempfile.mkdtemp(dir=TMP_TEST_DIR) td = py3compat.str_to_unicode(td) for name in ('profile_foo', 'profile_hello', 'not_a_profile'): os.mkdir(os.path.join(td, name)) if dec.unicode_paths: os.mkdir(os.path.join(td, 'profile_ünicode')) with open(os.path.join(td, 'profile_file'), 'w') as f: f.write("I am not a profile directory") profiles = list_profiles_in(td) # unicode normalization can turn u'ünicode' into u'u\0308nicode', # so only check for *nicode, and that creating a ProfileDir from the # name remains valid found_unicode = False for p in list(profiles): if p.endswith('nicode'): pd = ProfileDir.find_profile_dir_by_name(td, p) profiles.remove(p) found_unicode = True break if dec.unicode_paths: nt.assert_true(found_unicode) nt.assert_equal(set(profiles), set(['foo', 'hello']))
def get_security_file(filename, profile='default'): """Return the absolute path of a security file given by filename and profile This allows users and developers to find security files without knowledge of the IPython directory structure. The search path will be ['.', profile.security_dir] Parameters ---------- filename : str The file to be found. If it is passed as an absolute path, it will simply be returned. profile : str [default: 'default'] The name of the profile to search. Leaving this unspecified The file to be found. If it is passed as an absolute path, fname will simply be returned. Returns ------- Raises :exc:`IOError` if file not found or returns absolute path to file. """ # import here, because profiledir also imports from utils.path from IPython.core.profiledir import ProfileDir try: pd = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), profile) except Exception: # will raise ProfileDirError if no such profile raise IOError("Profile %r not found") return filefind(filename, ['.', pd.security_dir])
def find_connection_file(filename='kernel-*.json', profile=None): """find a connection file, and return its absolute path. The current working directory and the profile's security directory will be searched for the file if it is not given by absolute path. If profile is unspecified, then the current running application's profile will be used, or 'default', if not run from IPython. If the argument does not match an existing file, it will be interpreted as a fileglob, and the matching file in the profile's security dir with the latest access time will be used. Parameters ---------- filename : str The connection file or fileglob to search for. profile : str [optional] The name of the profile to use when searching for the connection file, if different from the current IPython session or 'default'. Returns ------- str : The absolute path of the connection file. """ from IPython.core.application import BaseIPythonApplication as IPApp try: # quick check for absolute path, before going through logic return filefind(filename) except IOError: pass if profile is None: # profile unspecified, check if running from an IPython app if IPApp.initialized(): app = IPApp.instance() profile_dir = app.profile_dir else: # not running in IPython, use default profile profile_dir = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), 'default') else: # find profiledir by profile name: profile_dir = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), profile) security_dir = profile_dir.security_dir return jupyter_client.find_connection_file(filename, path=['.', security_dir])
def get_args(argv): script_name = argv[0] _, session = os.path.split(script_name) script_name = os.path.realpath(script_name) macro_server = None door = None # Define the profile file profile = "spockdoor" try: for _, arg in enumerate(argv[1:]): if arg.startswith('--profile='): profile = arg[10:] break else: argv.append("--profile=" + profile) except: pass ipython_dir = get_ipython_dir() try: ProfileDir.find_profile_dir_by_name(ipython_dir, profile) except ProfileDirError: r = '' while not r in ('y', 'n'): prompt = 'Profile \'%s\' does not exist. Do you want to create '\ 'one now ([y]/n)? ' % profile r = raw_input(prompt) or 'y' if r.lower() == 'y': create_spock_profile(ipython_dir, profile) else: sys.stdout.write( 'No spock door extension profile was created. Starting normal spock...\n') sys.stdout.flush() profile = '' # inform the shell of the profile it should use if not '--profile=' in argv and profile: argv.append('--profile=' + profile) user_ns = {'MACRO_SERVER_NAME': macro_server, 'DOOR_NAME': door, 'PROFILE': profile} return user_ns
def load_subconfig(self, fname, path=None, profile=None): if profile is not None: try: profile_dir = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), profile) except ProfileDirError: return path = profile_dir.location return super(ProfileAwareConfigLoader, self).load_subconfig(fname, path=path)
def is_installed(ipydir=None, profile='tango'): ipython_dir = ipydir or get_ipython_dir() try: p_dir = ProfileDir.find_profile_dir_by_name(ipython_dir, profile) except ProfileDirError: return False abs_config_file_name = os.path.join(p_dir.location, _CONFIG_FILE_NAME) return os.path.isfile(abs_config_file_name)
def get_config(profile_name='default'): basefilename = 'nbx_config' ipython_dir = get_ipython_dir() profiledir = ProfileDir.find_profile_dir_by_name(ipython_dir, profile_name) pyloader = PyFileConfigLoader(basefilename+'.py', path=profiledir.location) config = pyloader.load_config() return config
def install(ipydir=None, verbose=True, profile='tango'): if verbose: def out(msg): sys.stdout.write(msg) sys.stdout.flush() else: out = lambda x: None ipython_dir = ipydir or get_ipython_dir() ensure_dir_exists(ipython_dir) try: p_dir = ProfileDir.find_profile_dir_by_name(ipython_dir, profile) except ProfileDirError: p_dir = ProfileDir.create_profile_dir_by_name(ipython_dir, profile) abs_config_file_name = os.path.join(p_dir.location, _CONFIG_FILE_NAME) create_config = True if os.path.isfile(abs_config_file_name): msg = "Tango configuration file {0} already exists.\n" msg += "Do you wish to replace it (y/n)?" msg = msg.format(abs_config_file_name) create_config = ask_yes_no(msg, default='y') if not create_config: return out("Installing tango extension to ipython... ") profile = __PROFILE.format(pytangover=tango.Release.version, ipyver=IPython.release.version, protected_block=__PROTECTED_BLOCK) with open(abs_config_file_name, "w") as f: f.write(profile) f.close() out("[DONE]\n\n") out("""\ To start ipython with tango interface simply type on the command line: %% ipython --profile=tango For more information goto: http://pytango.readthedocs.io Have fun with ITango! The PyTango team """)
def __init__(self, exec_lines=None,state=None): self.cout = DecodingStringIO(u'') if exec_lines is None: exec_lines = [] self.state = state # Create config object for IPython config = Config() config.InteractiveShell.autocall = False config.InteractiveShell.autoindent = False config.InteractiveShell.colors = 'NoColor' # create a profile so instance history isn't saved tmp_profile_dir = tempfile.mkdtemp(prefix='profile_') profname = 'auto_profile_sphinx_build' pdir = os.path.join(tmp_profile_dir,profname) profile = ProfileDir.create_profile_dir(pdir) # Create and initialize global ipython, but don't start its mainloop. # This will persist across different EmbededSphinxShell instances. IP = InteractiveShell.instance(config=config, profile_dir=profile) # io.stdout redirect must be done after instantiating InteractiveShell io.stdout = self.cout io.stderr = self.cout # For debugging, so we can see normal output, use this: #from IPython.utils.io import Tee #io.stdout = Tee(self.cout, channel='stdout') # dbg #io.stderr = Tee(self.cout, channel='stderr') # dbg # Store a few parts of IPython we'll need. self.IP = IP self.user_ns = self.IP.user_ns self.user_global_ns = self.IP.user_global_ns self.input = '' self.output = '' self.is_verbatim = False self.is_doctest = False self.is_suppress = False # Optionally, provide more detailed information to shell. self.directive = None # on the first call to the savefig decorator, we'll import # pyplot as plt so we can make a call to the plt.gcf().savefig self._pyplot_imported = False # Prepopulate the namespace. for line in exec_lines: self.process_input_line(line, store_history=False)
def find_connection_file(filename='kernel-*.json', profile=None): """DEPRECATED: find a connection file, and return its absolute path. THIS FUNCION IS DEPRECATED. Use juptyer_client.find_connection_file instead. Parameters ---------- filename : str The connection file or fileglob to search for. profile : str [optional] The name of the profile to use when searching for the connection file, if different from the current IPython session or 'default'. Returns ------- str : The absolute path of the connection file. """ import warnings warnings.warn("""ipykernel.find_connection_file is deprecated, use jupyter_client.find_connection_file""", DeprecationWarning, stacklevel=2) from IPython.core.application import BaseIPythonApplication as IPApp try: # quick check for absolute path, before going through logic return filefind(filename) except IOError: pass if profile is None: # profile unspecified, check if running from an IPython app if IPApp.initialized(): app = IPApp.instance() profile_dir = app.profile_dir else: # not running in IPython, use default profile profile_dir = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), 'default') else: # find profiledir by profile name: profile_dir = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), profile) security_dir = profile_dir.security_dir return jupyter_client.find_connection_file(filename, path=['.', security_dir])
def is_installed(ipydir=None, profile='tango'): ipython_dir = ipydir or get_ipython_dir() try: p_dir = ProfileDir.find_profile_dir_by_name(ipython_dir, profile) except ProfileDirError: return False abs_config_file_name = os.path.join(p_dir.location, _CONFIG_FILE_NAME) if not os.path.isfile(abs_config_file_name): return False with open(abs_config_file_name) as f: return __PROTECTED_BLOCK in f.read()
def list_running_servers(profile='default'): """Iterate over the server info files of running notebook servers. Given a profile name, find nbserver-* files in the security directory of that profile, and yield dicts of their information, each one pertaining to a currently running notebook server instance. """ pd = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), name=profile) for file in os.listdir(pd.security_dir): if file.startswith('nbserver-'): with io.open(os.path.join(pd.security_dir, file), encoding='utf-8') as f: yield json.load(f)
def locate_profile(profile='default'): """Find the path to the folder associated with a given profile. I.e. find $IPYTHONDIR/profile_whatever. """ from IPython.core.profiledir import ProfileDir, ProfileDirError try: pd = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), profile) except ProfileDirError: # IOError makes more sense when people are expecting a path raise IOError("Couldn't find profile %r" % profile) return pd.location
def install(ipydir=None, verbose=True, profile='tango'): if verbose: def out(msg): sys.stdout.write(msg) sys.stdout.flush() else: out = lambda x : None ipython_dir = ipydir or get_ipython_dir() try: p_dir = ProfileDir.find_profile_dir_by_name(ipython_dir, profile) except ProfileDirError: p_dir = ProfileDir.create_profile_dir_by_name(ipython_dir, profile) abs_config_file_name = os.path.join(p_dir.location, _CONFIG_FILE_NAME) create_config = True if os.path.isfile(abs_config_file_name): create_config = ask_yes_no("Tango configuration file already exists. "\ "Do you wish to replace it?", default='y') if not create_config: return out("Installing tango extension to ipython... ") profile = __PROFILE.format(pytangover=PyTango.Release.version, ipyver=IPython.release.version) with open(abs_config_file_name, "w") as f: f.write(profile) f.close() out("[DONE]\n\n") out("""\ To start ipython with tango interface simply type on the command line: %% ipython --profile=tango For more information goto: http://www.tango-controls.org/static/PyTango/latest/doc/html/ Have fun with ITango! The PyTango team """)
def test_startup_py(): # create profile dir pd = ProfileDir.create_profile_dir_by_name(IP_TEST_DIR, 'test') # write startup python file with open(os.path.join(pd.startup_dir, '00-start.py'), 'w') as f: f.write('zzz=123\n') # write simple test file, to check that the startup file was run fname = os.path.join(TMP_TEST_DIR, 'test.py') with open(fname, 'w') as f: f.write('print zzz\n') # validate output tt.ipexec_validate(fname, '123', '', options=['--ipython-dir', IP_TEST_DIR, '--profile', 'test'])
def test_startup_ipy(): # create profile dir pd = ProfileDir.create_profile_dir_by_name(IP_TEST_DIR, 'test') # write startup ipython file with open(os.path.join(pd.startup_dir, '00-start.ipy'), 'w') as f: f.write('%profile\n') # write empty script, because we don't need anything to happen # after the startup file is run fname = os.path.join(TMP_TEST_DIR, 'test.py') with open(fname, 'w') as f: f.write('') # validate output tt.ipexec_validate(fname, 'test', '', options=['--ipython-dir', IP_TEST_DIR, '--profile', 'test'])
def __init__(self): self.cout = cStringIO.StringIO() # Create config object for IPython config = Config() config.Global.display_banner = False config.Global.exec_lines = ['import numpy as np', 'from pylab import *' ] config.InteractiveShell.autocall = False config.InteractiveShell.autoindent = False config.InteractiveShell.colors = 'NoColor' config.InteractiveShell.cache_size = 0 # create a profile so instance history isn't saved tmp_profile_dir = tempfile.mkdtemp(prefix='profile_') profname = 'auto_profile_sphinx_build' pdir = os.path.join(tmp_profile_dir, profname) profile = ProfileDir.create_profile_dir(pdir) # Create and initialize ipython, but don't start its mainloop IP = InteractiveShell.instance(config=config, profile_dir=profile) # io.stdout redirect must be done *after* instantiating # InteractiveShell io.stdout = self.cout io.stderr = self.cout # For debugging, so we can see normal output, use this: # from IPython.utils.io import Tee # io.stdout = Tee(self.cout, channel='stdout') # dbg # io.stderr = Tee(self.cout, channel='stderr') # dbg # Store a few parts of IPython we'll need. self.IP = IP self.user_ns = self.IP.user_ns self.user_global_ns = self.IP.user_global_ns self.input = '' self.output = '' self.is_verbatim = False self.is_doctest = False self.is_suppress = False # on the first call to the savefig decorator, we'll import # pyplot as plt so we can make a call to the plt.gcf().savefig self._pyplot_imported = False
def prepare_cmdline(argv=None): if argv is None: argv = sys.argv script_name = argv[0] _, session = os.path.split(script_name) script_name = os.path.realpath(script_name) # Define the profile file profile, append_profile = "spockdoor", True try: # in ipython the last option in the list takes precedence # so reversing order for searching of the profile reversed_argv = reversed(argv[1:]) for _, arg in enumerate(reversed_argv): if arg.startswith('--profile='): profile=arg[10:] append_profile = False break except: pass ipython_dir = get_ipython_dir() try: pd = ProfileDir.find_profile_dir_by_name(ipython_dir, profile) except ProfileDirError: r = '' while not r in ('y', 'n'): prompt = "Profile '%s' does not exist. Do you want to create "\ "one now ([y]/n)? " % profile r = raw_input(prompt) or 'y' if r.lower() == 'y': create_spock_profile(ipython_dir, profile) else: sys.stdout.write('No spock profile was created. ' 'Starting ipython with default profile...\n') sys.stdout.flush() # removing all options refering to profile for _, arg in enumerate(argv[1:]): if arg.startswith('--profile='): argv.remove(arg) return else: ipy_profile_dir = pd.location # directory with the spock profile check_for_upgrade(ipy_profile_dir) if append_profile: argv.append("--profile=" + profile)
def load_config_file(self, *args, **kwds): from IPython.config.loader import PyFileConfigLoader, ConfigFileNotFound from IPython.core.profiledir import ProfileDir from IPython.utils.path import get_ipython_dir conf = Config() conf._merge(DEFAULT_SAGE_CONFIG) conf._merge(self.command_line_config) # Get user config. sage_profile_dir = ProfileDir.find_profile_dir_by_name( get_ipython_dir(), 'sage').location try: cl = PyFileConfigLoader('ipython_config.py', sage_profile_dir) conf._merge(cl.load_config()) except ConfigFileNotFound: pass self.update_config(conf)
def client_json_file(profile='default', cluster_id=None): """ Get the path to the ipcontroller-client.json file. This really shouldn't be necessary, except that IPython doesn't automatically insert the cluster_id in the way that it should. I submitted a pull request to fix it, but here is a monkey patch in the mean time """ from IPython.core.profiledir import ProfileDir from IPython.utils.path import get_ipython_dir profile_dir = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), profile) if not cluster_id: client_json = 'ipcontroller-client.json' else: client_json = 'ipcontroller-%s-client.json' % cluster_id filename = os.path.join(profile_dir.security_dir, client_json) if not os.path.exists(filename): raise ValueError('controller information not found at: %s' % filename) return filename
def load_subconfig(fname, profile=None): # import here to prevent circular imports from IPython.core.profiledir import ProfileDir, ProfileDirError if profile is not None: try: profile_dir = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), profile) except ProfileDirError: return path = profile_dir.location else: path = self.path loader = PyFileConfigLoader(fname, path) try: sub_config = loader.load_config() except IOError: # Pass silently if the sub config is not there. This happens # when a user s using a profile, but not the default config. pass else: self.config._merge(sub_config)
def test_ipcluster_start_stop(request, ipython_dir, daemonize): default_profile = ProfileDir.find_profile_dir_by_name(ipython_dir) default_profile_dir = default_profile.location # cleanup the security directory to avoid leaking files from one test to the next def cleanup_security(): for f in glob.glob(os.path.join(default_profile.security_dir, "*.json")): print(f"Cleaning up {f}") try: os.remove(f) except Exception as e: print(f"Error removing {f}: {e}") request.addfinalizer(cleanup_security) n = 2 start_args = ["-n", str(n)] if daemonize: start_args.append("--daemonize") start = Popen( [sys.executable, "-m", "ipyparallel.cluster", "start", "--debug"] + start_args) request.addfinalizer(start.terminate) if daemonize: # if daemonize, should exit after starting start.wait(30) else: # wait for file to appear # only need this if not daemonize cluster_file = ipp.Cluster(profile_dir=default_profile_dir, cluster_id="").cluster_file for i in range(100): if os.path.isfile(cluster_file) or start.poll() is not None: break else: time.sleep(0.1) assert os.path.isfile(cluster_file) # list should show a file out = ipcluster_list() assert len(out.splitlines()) == 2 # cluster running, try to connect with default args cluster = ipp.Cluster.from_file(log_level=10) try: with cluster.connect_client_sync() as rc: rc.wait_for_engines(n=2, timeout=60) rc[:].apply_async(os.getpid).get(timeout=10) except Exception: print("controller output") print(cluster.controller.get_output()) print("engine output") for engine_set in cluster.engines.values(): print(engine_set.get_output()) raise # stop with ipcluster stop check_call([sys.executable, "-m", "ipyparallel.cluster", "stop"]) # start should exit when this happens start.wait(30) # and ipcluster list should return empty out = ipcluster_list() assert len(out.splitlines()) == 1 # stop all succeeds even if there's nothing to stop check_call([sys.executable, "-m", "ipyparallel.cluster", "stop", "--all"])
def setUp(self): # create profile dir self.pd = ProfileDir.create_profile_dir_by_name(IP_TEST_DIR, 'test') self.options = ['--ipython-dir', IP_TEST_DIR, '--profile', 'test'] self.fname = os.path.join(TMP_TEST_DIR, 'test.py')
def get_profile_dir(self, name, path): p = ProfileDir.find_profile_dir_by_name(path, name=name) return p.location
def setUp(self): # create profile dir self.pd = ProfileDir.create_profile_dir_by_name(IP_TEST_DIR, "test") self.options = ["--ipython-dir", IP_TEST_DIR, "--profile", "test"] self.fname = TMP_TEST_DIR / "test.py"
def __init__(self, exec_lines=None): self.cout = StringIO() if exec_lines is None: exec_lines = [] # Create config object for IPython config = Config() config.HistoryManager.hist_file = ':memory:' config.InteractiveShell.autocall = False config.InteractiveShell.autoindent = False config.InteractiveShell.colors = 'NoColor' # create a profile so instance history isn't saved tmp_profile_dir = tempfile.mkdtemp(prefix='profile_') profname = 'auto_profile_sphinx_build' pdir = os.path.join(tmp_profile_dir, profname) profile = ProfileDir.create_profile_dir(pdir) # Create and initialize global ipython, but don't start its mainloop. # This will persist across different EmbededSphinxShell instances. IP = InteractiveShell.instance(config=config, profile_dir=profile) atexit.register(self.cleanup) # io.stdout redirect must be done after instantiating InteractiveShell io.stdout = self.cout io.stderr = self.cout # For debugging, so we can see normal output, use this: #from IPython.utils.io import Tee #io.stdout = Tee(self.cout, channel='stdout') # dbg #io.stderr = Tee(self.cout, channel='stderr') # dbg # Store a few parts of IPython we'll need. self.IP = IP self.user_ns = self.IP.user_ns self.user_global_ns = self.IP.user_global_ns self.input = '' self.output = '' self.tmp_profile_dir = tmp_profile_dir self.is_verbatim = False self.is_doctest = False self.is_suppress = False # Optionally, provide more detailed information to shell. # this is assigned by the SetUp method of IPythonDirective # to point at itself. # # So, you can access handy things at self.directive.state self.directive = None # on the first call to the savefig decorator, we'll import # pyplot as plt so we can make a call to the plt.gcf().savefig self._pyplot_imported = False # Prepopulate the namespace. for line in exec_lines: self.process_input_line(line, store_history=False)
def init_profile_dir(self): """initialize the profile dir""" self._in_init_profile_dir = True if self.profile_dir is not None: # already ran return if 'ProfileDir.location' not in self.config: # location not specified, find by profile name try: p = ProfileDir.find_profile_dir_by_name( self.ipython_dir, self.profile, self.config) except ProfileDirError: # not found, maybe create it (always create default profile) if self.auto_create or self.profile == 'default': try: p = ProfileDir.create_profile_dir_by_name( self.ipython_dir, self.profile, self.config) except ProfileDirError: self.log.fatal("Could not create profile: %r" % self.profile) self.exit(1) else: self.log.info("Created profile dir: %r" % p.location) else: self.log.fatal("Profile %r not found." % self.profile) self.exit(1) else: self.log.debug("Using existing profile dir: %r" % p.location) else: location = self.config.ProfileDir.location # location is fully specified try: p = ProfileDir.find_profile_dir(location, self.config) except ProfileDirError: # not found, maybe create it if self.auto_create: try: p = ProfileDir.create_profile_dir( location, self.config) except ProfileDirError: self.log.fatal( "Could not create profile directory: %r" % location) self.exit(1) else: self.log.debug("Creating new profile dir: %r" % location) else: self.log.fatal("Profile directory %r not found." % location) self.exit(1) else: self.log.info("Using existing profile dir: %r" % location) # if profile_dir is specified explicitly, set profile name dir_name = os.path.basename(p.location) if dir_name.startswith('profile_'): self.profile = dir_name[8:] self.profile_dir = p self.config_file_paths.append(p.location) self._in_init_profile_dir = False
def get_profile_dir(self, name, path): from IPython.core.profiledir import ProfileDir p = ProfileDir.find_profile_dir_by_name(path,name=name) return p.location
def find_connection_file(filename, profile=None): """find a connection file, and return its absolute path. The current working directory and the profile's security directory will be searched for the file if it is not given by absolute path. If profile is unspecified, then the current running application's profile will be used, or 'default', if not run from IPython. If the argument does not match an existing file, it will be interpreted as a fileglob, and the matching file in the profile's security dir with the latest access time will be used. Parameters ---------- filename : str The connection file or fileglob to search for. profile : str [optional] The name of the profile to use when searching for the connection file, if different from the current IPython session or 'default'. Returns ------- str : The absolute path of the connection file. """ from IPython.core.application import BaseIPythonApplication as IPApp try: # quick check for absolute path, before going through logic return filefind(filename) except IOError: pass if profile is None: # profile unspecified, check if running from an IPython app if IPApp.initialized(): app = IPApp.instance() profile_dir = app.profile_dir else: # not running in IPython, use default profile profile_dir = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), 'default') else: # find profiledir by profile name: profile_dir = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), profile) security_dir = profile_dir.security_dir try: # first, try explicit name return filefind(filename, ['.', security_dir]) except IOError: pass # not found by full name if '*' in filename: # given as a glob already pat = filename else: # accept any substring match pat = '*%s*' % filename matches = glob.glob( os.path.join(security_dir, pat) ) if not matches: raise IOError("Could not find %r in %r" % (filename, security_dir)) elif len(matches) == 1: return matches[0] else: # get most recent match, by access time: return sorted(matches, key=lambda f: os.stat(f).st_atime)[-1]