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 _cluster_started(self, cluster_id): home_dir = os.path.expanduser('~') started = False self.connection_files = [get_ipython_dir() + '/profile_sge/security/ipcontroller-' + cluster_id + '-client.json', get_ipython_dir() + '/profile_sge/security/ipcontroller-' + cluster_id + '-engine.json', ] if os.path.isfile(self.connection_files[0]): if os.path.isfile(self.connection_files[1]): started = True return started
def setup(): cp = Popen('ipcontroller --profile iptest -r --log-level 10 --log-to-file --usethreads'.split(), stdout=blackhole, stderr=STDOUT) processes.append(cp) engine_json = os.path.join(get_ipython_dir(), 'cluster_iptest', 'security', 'ipcontroller-engine.json') client_json = os.path.join(get_ipython_dir(), 'cluster_iptest', 'security', 'ipcontroller-client.json') tic = time.time() while not os.path.exists(engine_json) or not os.path.exists(client_json): if cp.poll() is not None: print cp.poll() raise RuntimeError("The test controller failed to start.") elif time.time()-tic > 10: raise RuntimeError("Timeout waiting for the test controller to start.") time.sleep(0.1) add_engines(1)
def test_get_ipython_dir_2(): """test_get_ipython_dir_2, Testcase to see if we can call get_ipython_dir without Exceptions.""" path.get_home_dir = lambda : "someplace" os.name = "posix" env.pop('IPYTHON3_DIR', None) ipdir = path.get_ipython_dir() nt.assert_equal(ipdir, os.path.join("someplace", ".ipython3"))
def setup(): # show tracebacks for RemoteErrors class RemoteErrorWithTB(error.RemoteError): def __str__(self): s = super(RemoteErrorWithTB, self).__str__() return '\n'.join([s, self.traceback or '']) error.RemoteError = RemoteErrorWithTB cluster_dir = os.path.join(get_ipython_dir(), 'profile_iptest') engine_json = os.path.join(cluster_dir, 'security', 'ipcontroller-engine.json') client_json = os.path.join(cluster_dir, 'security', 'ipcontroller-client.json') for json in (engine_json, client_json): if os.path.exists(json): os.remove(json) cp = TestProcessLauncher() cp.cmd_and_args = ipcontroller_cmd_argv + \ ['--profile=iptest', '--log-level=20', '--ping=250', '--dictdb'] cp.start() launchers.append(cp) tic = time.time() while not os.path.exists(engine_json) or not os.path.exists(client_json): if cp.poll() is not None: raise RuntimeError("The test controller exited with status %s" % cp.poll()) elif time.time()-tic > 15: raise RuntimeError("Timeout waiting for the test controller to start.") time.sleep(0.1) add_engines(1)
def test_get_ipython_dir_7(): """test_get_ipython_dir_7, test home directory expansion on IPYTHONDIR""" path._writable_dir = lambda path: True home_dir = os.path.normpath(os.path.expanduser('~')) env['IPYTHONDIR'] = os.path.join('~', 'somewhere') ipdir = path.get_ipython_dir() nt.assert_equal(ipdir, os.path.join(home_dir, 'somewhere'))
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 test_get_ipython_dir_1(): """test_get_ipython_dir_1, Testcase to see if we can call get_ipython_dir without Exceptions.""" env_ipdir = os.path.join("someplace", ".ipython") path._writable_dir = lambda path: True env['IPYTHONDIR'] = env_ipdir ipdir = path.get_ipython_dir() nt.assert_equal(ipdir, env_ipdir)
def test_get_ipython_dir_7(): """test_get_ipython_dir_7, test home directory expansion on IPYTHONDIR""" path._writable_dir = lambda path: True home_dir = os.path.expanduser("~") env["IPYTHONDIR"] = os.path.join("~", "somewhere") ipdir = path.get_ipython_dir() nt.assert_equal(ipdir, os.path.join(home_dir, "somewhere"))
def write_ipynb_local_js(location=None, d3_src=None): try: from IPython.html import install_nbextension except ImportError: location = os.getcwd() nbextension = False else: nbextension = True d3_src = os.path.join(os.path.dirname(__file__), 'd3.v3.min.js') d3js = os.path.basename(d3_src) if not os.path.exists(d3_src): raise ValueError("d3 src not found at '{0}'".format(d3_src)) if nbextension: try: install_nbextension(d3_src,user=True) except IOError: # files may be read only. We'll try deleting them and re-installing from IPython.utils.path import get_ipython_dir nbext = os.path.join(get_ipython_dir(), "nbextensions") for src in [d3_src]: dest = os.path.join(nbext, os.path.basename(src)) if os.path.exists(dest): os.remove(dest) install_nbextension(d3_src, user=True)
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 test_get_ipython_dir_3(): """test_get_ipython_dir_3, use XDG if defined, and .ipython doesn't exist.""" path.get_home_dir = lambda : "someplace" os.name = "posix" env.pop('IPYTHON_DIR', None) env['XDG_CONFIG_HOME'] = XDG_TEST_DIR ipdir = path.get_ipython_dir() nt.assert_equal(ipdir, os.path.join(XDG_TEST_DIR, "ipython"))
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 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 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 test_get_ipython_dir_4(): """test_get_ipython_dir_4, use XDG if both exist.""" path.get_home_dir = lambda : HOME_TEST_DIR os.name = "posix" env.pop('IPYTHON_DIR', None) env['XDG_CONFIG_HOME'] = XDG_TEST_DIR xdg_ipdir = os.path.join(XDG_TEST_DIR, "ipython") ipdir = path.get_ipython_dir() nt.assert_equal(ipdir, xdg_ipdir)
def test_get_ipython_dir_6(): """test_get_ipython_dir_6, use XDG if defined and neither exist.""" path.get_home_dir = lambda : 'somehome' path.get_xdg_dir = lambda : 'somexdg' os.name = "posix" env.pop('IPYTHON_DIR', None) xdg_ipdir = os.path.join("somexdg", "ipython") ipdir = path.get_ipython_dir() nt.assert_equal(ipdir, xdg_ipdir)
def _getEngineInfoLogFile(self): # Store all logs inside the ipython directory ipdir = get_ipython_dir() pjoin = os.path.join logdir_base = pjoin(ipdir,'log') if not os.path.isdir(logdir_base): os.makedirs(logdir_base) logfile = os.path.join(logdir_base,'ipcontroller-%s-engine-info.log' % os.getpid()) return logfile
def test_get_ipython_dir_5(): """test_get_ipython_dir_5, use .ipython if exists and XDG defined, but doesn't exist.""" path.get_home_dir = lambda : HOME_TEST_DIR os.name = "posix" env.pop('IPYTHON_DIR', None) env['XDG_CONFIG_HOME'] = XDG_TEST_DIR os.rmdir(os.path.join(XDG_TEST_DIR, 'ipython')) ipdir = path.get_ipython_dir() nt.assert_equal(ipdir, IP_TEST_DIR)
def get_local_magics_dir(): """ Ensures that there is a ~/.ipython/metakernel/magics directory, and returns the path to it. """ base = get_ipython_dir() dname = os.path.join(base, 'metakernel', 'magics') if not os.path.exists(dname): os.makedirs(dname) return dname
def _find_profile(profile_name): from IPython.utils.path import locate_profile, get_ipython_dir try: profile_path = locate_profile(profile_name) exists = True except IOError: profile_path = os.path.join(get_ipython_dir(), "profile_%s" % profile_name) exists = False return profile_path, exists
def load_default_config(ipython_dir=None): """Load the default config file from the default ipython_dir. This is useful for embedded shells. """ if ipython_dir is None: ipython_dir = get_ipython_dir() cl = PyFileConfigLoader(default_config_file_name, ipython_dir) config = cl.load_config() return config
def test_get_ipython_dir_6(): """test_get_ipython_dir_6, use XDG if defined and neither exist.""" path.get_home_dir = lambda: 'somehome' path.get_xdg_dir = lambda: 'somexdg' os.name = "posix" env.pop('IPYTHON_DIR', None) env.pop('IPYTHONDIR', None) xdg_ipdir = os.path.join("somexdg", "ipython") ipdir = path.get_ipython_dir() nt.assert_equal(ipdir, xdg_ipdir)
def _getEngineInfoLogFile(self): # Store all logs inside the ipython directory ipdir = get_ipython_dir() pjoin = os.path.join logdir_base = pjoin(ipdir, 'log') if not os.path.isdir(logdir_base): os.makedirs(logdir_base) logfile = os.path.join(logdir_base, 'ipcontroller-%s-engine-info.log' % os.getpid()) return logfile
def test_get_ipython_dir_4(): """test_get_ipython_dir_4, use XDG if both exist.""" path.get_home_dir = lambda: HOME_TEST_DIR os.name = "posix" env.pop('IPYTHON_DIR', None) env.pop('IPYTHONDIR', None) env['XDG_CONFIG_HOME'] = XDG_TEST_DIR xdg_ipdir = os.path.join(XDG_TEST_DIR, "ipython") ipdir = path.get_ipython_dir() nt.assert_equal(ipdir, xdg_ipdir)
def test_get_ipython_dir_5(): """test_get_ipython_dir_5, use .ipython if exists and XDG defined, but doesn't exist.""" path.get_home_dir = lambda: HOME_TEST_DIR os.name = "posix" env.pop('IPYTHON_DIR', None) env.pop('IPYTHONDIR', None) env['XDG_CONFIG_HOME'] = XDG_TEST_DIR os.rmdir(os.path.join(XDG_TEST_DIR, 'ipython')) ipdir = path.get_ipython_dir() nt.assert_equal(ipdir, IP_TEST_DIR)
def test_get_ipython_dir_3(): """test_get_ipython_dir_3, use XDG if defined, and .ipython doesn't exist.""" path.get_home_dir = lambda: "someplace" path._writable_dir = lambda path: True os.name = "posix" env.pop('IPYTHON_DIR', None) env.pop('IPYTHONDIR', None) env['XDG_CONFIG_HOME'] = XDG_TEST_DIR ipdir = path.get_ipython_dir() nt.assert_equal(ipdir, os.path.join(XDG_TEST_DIR, "ipython"))
def get_ipython_profiles(path=None): """list profiles in a given root directory""" if path is None: path = get_ipython_dir() files = os.listdir(path) profiles = [] for f in files: full_path = os.path.join(path, f) if os.path.isdir(full_path) and f.startswith('profile_'): profiles.append(f.split('_',1)[-1]) return profiles
def test_get_ipython_dir_2(): """test_get_ipython_dir_2, Testcase to see if we can call get_ipython_dir without Exceptions.""" with patch_get_home_dir('someplace'): path.get_xdg_dir = lambda: None path._writable_dir = lambda path: True os.name = "posix" env.pop('IPYTHON_DIR', None) env.pop('IPYTHONDIR', None) env.pop('XDG_CONFIG_HOME', None) ipdir = path.get_ipython_dir() nt.assert_equal(ipdir, os.path.join("someplace", ".ipython"))
def test_get_ipython_dir_2(): """test_get_ipython_dir_2, Testcase to see if we can call get_ipython_dir without Exceptions.""" with patch_get_home_dir('someplace'): path.get_xdg_dir = lambda : None path._writable_dir = lambda path: True os.name = "posix" env.pop('IPYTHON_DIR', None) env.pop('IPYTHONDIR', None) env.pop('XDG_CONFIG_HOME', None) ipdir = path.get_ipython_dir() nt.assert_equal(ipdir, os.path.join("someplace", ".ipython"))
def get_ipython_profiles(path=None): """list profiles in a given root directory""" if path is None: path = get_ipython_dir() files = os.listdir(path) profiles = [] for f in files: full_path = os.path.join(path, f) if os.path.isdir(full_path) and f.startswith('profile_'): profiles.append(f.split('_', 1)[-1]) return profiles
def config_ipw(ipw): """Apply and then modify default settings of IPython Qt widget""" ipython_dir = get_ipython_dir() profile_dir = os.path.join(ipython_dir, 'profile_default') cl = PyFileConfigLoader('ipython_qtconsole_config.py', profile_dir) config = cl.load_config() ipw.config = config ipw.set_default_style(colors='Linux') ipw.font = QFont('Lucida Console', 11) # 3rd arg can be e.g. QFont.Bold ipw.font.setFixedPitch(True)
def setup(): cp = Popen( 'ipcontroller --profile iptest -r --log-level 10 --log-to-file --usethreads' .split(), stdout=blackhole, stderr=STDOUT) processes.append(cp) engine_json = os.path.join(get_ipython_dir(), 'cluster_iptest', 'security', 'ipcontroller-engine.json') client_json = os.path.join(get_ipython_dir(), 'cluster_iptest', 'security', 'ipcontroller-client.json') tic = time.time() while not os.path.exists(engine_json) or not os.path.exists(client_json): if cp.poll() is not None: print cp.poll() raise RuntimeError("The test controller failed to start.") elif time.time() - tic > 10: raise RuntimeError( "Timeout waiting for the test controller to start.") time.sleep(0.1) add_engines(1)
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 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 test_get_ipython_dir_8(): """test_get_ipython_dir_8, test / home directory""" old = path._writable_dir, path.get_xdg_dir try: path._writable_dir = lambda path: bool(path) path.get_xdg_dir = lambda: None env.pop("IPYTHON_DIR", None) env.pop("IPYTHONDIR", None) env["HOME"] = "/" nt.assert_equal(path.get_ipython_dir(), "/.ipython") finally: path._writable_dir, path.get_xdg_dir = old
def test_get_ipython_dir_8(): """test_get_ipython_dir_8, test / home directory""" old = path._writable_dir, path.get_xdg_dir try: path._writable_dir = lambda path: bool(path) path.get_xdg_dir = lambda: None env.pop('IPYTHON_DIR', None) env.pop('IPYTHONDIR', None) env['HOME'] = '/' nt.assert_equal(path.get_ipython_dir(), '/.ipython') finally: path._writable_dir, path.get_xdg_dir = old
def test_get_ipython_dir_4(): """test_get_ipython_dir_4, use XDG if both exist.""" path.get_home_dir = lambda: HOME_TEST_DIR os.name = "posix" env.pop('IPYTHON_DIR', None) env.pop('IPYTHONDIR', None) env['XDG_CONFIG_HOME'] = XDG_TEST_DIR ipdir = path.get_ipython_dir() if sys.platform == "darwin": expected = os.path.join(HOME_TEST_DIR, ".ipython") else: expected = os.path.join(XDG_TEST_DIR, "ipython") nt.assert_equal(ipdir, expected)
def test_not_writable_ipdir(): tmpdir = tempfile.mkdtemp() os.name = "posix" env.pop('IPYTHON_DIR', None) env.pop('IPYTHONDIR', None) env.pop('XDG_CONFIG_HOME', None) env['HOME'] = tmpdir ipdir = os.path.join(tmpdir, '.ipython') os.mkdir(ipdir) os.chmod(ipdir, 600) with AssertPrints('is not a writable location', channel='stderr'): ipdir = path.get_ipython_dir() env.pop('IPYTHON_DIR', None)
def create_default_config(self): """Create defaults that can't be set elsewhere. For the most part, we try to set default in the class attributes of Configurables. But, defaults the top-level Application (which is not a HasTraits or Configurables) are not set in this way. Instead we set them here. The Global section is for variables like this that don't belong to a particular configurable. """ c = Config() c.Global.ipython_dir = get_ipython_dir() c.Global.log_level = self.log_level self.default_config = c
def update_profiles(self): """List all profiles in the ipython_dir and cwd. """ for path in [get_ipython_dir(), os.getcwdu()]: for profile in list_profiles_in(path): pd = self.get_profile_dir(profile, path) if profile not in self.profiles: self.log.debug("Adding cluster profile '%s'" % profile) self.profiles[profile] = { 'profile': profile, 'profile_dir': pd, 'status': 'stopped' }
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 test_get_ipython_dir_5(): """test_get_ipython_dir_5, use .ipython if exists and XDG defined, but doesn't exist.""" with patch_get_home_dir(HOME_TEST_DIR): os.name = "posix" env.pop('IPYTHON_DIR', None) env.pop('IPYTHONDIR', None) env['XDG_CONFIG_HOME'] = XDG_TEST_DIR try: os.rmdir(os.path.join(XDG_TEST_DIR, 'ipython')) except OSError as e: if e.errno != errno.ENOENT: raise ipdir = path.get_ipython_dir() nt.assert_equal(ipdir, IP_TEST_DIR)
def __init__(self): """ Utility to manage Sage kernels EXAMPLES:: sage: from sage.repl.ipython_kernel.install import SageKernelSpec sage: spec = SageKernelSpec() sage: spec._display_name # random output 'Sage 6.6.beta2' """ self._display_name = 'Sage {0}'.format(SAGE_VERSION) self._ipython_dir = get_ipython_dir() self._mkdirs()
def test_get_ipython_dir_6(): """test_get_ipython_dir_6, use XDG if defined and neither exist.""" xdg = os.path.join(HOME_TEST_DIR, 'somexdg') os.mkdir(xdg) shutil.rmtree(os.path.join(HOME_TEST_DIR, '.ipython')) path.get_home_dir = lambda: HOME_TEST_DIR path.get_xdg_dir = lambda: xdg os.name = "posix" env.pop('IPYTHON_DIR', None) env.pop('IPYTHONDIR', None) env.pop('XDG_CONFIG_HOME', None) xdg_ipdir = os.path.join(xdg, "ipython") ipdir = path.get_ipython_dir() nt.assert_equal(ipdir, xdg_ipdir)
def _select_profile(self): # See IPython.core.profileapp:list_profile_in() profiles = [] for filename in os.listdir(get_ipython_dir()): if filename.startswith('profile_'): profiles.append(filename[8:]) if profiles == ['default'] and not qt_available: self.profile = 'default' elif not qt_available: raise ValueError("'default' IPython profile does not exist " "and PyQt4 is not available") else: self.profile = choose_profile(profiles)
class BasicConfig(LinkedConfig): """Config options that inherited from IPython.""" profile = Unicode('nbgrader', config=True, help="Default IPython profile to use") overwrite = Bool( False, config=True, help="Whether to overwrite existing config files when copying") auto_create = Bool(True, config=True, help="Whether to automatically generate the profile") extra_config_file = Unicode(config=True, help=dedent(""" Path to an extra config file to load. If specified, load this config file in addition to any other IPython config. """)) copy_config_files = Bool(False, config=True, help=dedent(""" Whether to install the default config files into the profile dir. If a new profile is being created, and IPython contains config files for that profile, then they will be staged into the new directory. Otherwise, default config files will be automatically generated. """)) ipython_dir = Unicode(get_ipython_dir(), config=True, help=dedent(""" The name of the IPython directory. This directory is used for logging configuration (through profiles), history storage, etc. The default is usually $HOME/.ipython. This option can also be specified through the environment variable IPYTHONDIR. """)) log_datefmt = Unicode( "%Y-%m-%d %H:%M:%S", config=True, help="The date format used by logging formatters for %(asctime)s") log_format = Unicode( "%(color)s[%(name)s | %(levelname)s]%(end_color)s %(message)s", config=True, help="The logging format template")
def copyNeededFilesToWebServer(): nbextension = True try: if IPython.version_info[0] >= 4: from notebook import install_nbextension else: from IPython.html import install_nbextension except ImportError: nbextension = False moduleDir = os.path.dirname(os.path.abspath(__file__)) tulipjs_files = os.path.join(moduleDir, 'tulipjs') required_files = [tulipjs_files] if nbextension: def _install_nbextension(extensions): """Wrapper for IPython.html.install_nbextension.""" if IPython.version_info[0] >= 3: for extension in extensions: install_nbextension(extension, user=True, verbose=0) else: install_nbextension(extensions, verbose=0) try: _install_nbextension(required_files) except IOError: # files may be read only. We'll try deleting them and re-installing from IPython.utils.path import get_ipython_dir nbext = os.path.join(get_ipython_dir(), "nbextensions") for req_file in required_files: dest = os.path.join(nbext, os.path.basename(req_file)) if os.path.exists(dest): os.remove(dest) _install_nbextension(required_files) prefix = '/nbextensions/tulipjs/' urls = {} urls['tulipjs'] = prefix + 'tulip.js' urls['base64utilsjs'] = prefix + 'base64utils.js' urls['jquerytoolbarjs'] = prefix + 'jquery.toolbar.min.js' urls['jquerytoolbarcss'] = prefix + 'css/jquery.toolbar.css' urls['fontawesomecss'] = prefix + 'css/font-awesome.min.css' return urls
def load_default_config(ipython_dir=None): """Load the default config file from the default ipython_dir. This is useful for embedded shells. """ if ipython_dir is None: ipython_dir = get_ipython_dir() profile_dir = os.path.join(ipython_dir, 'profile_default') cl = PyFileConfigLoader("ipython_config.py", profile_dir) try: config = cl.load_config() except ConfigFileNotFound: # no config found config = Config() return config
def load_default_config(ipython_dir=None): """Load the default config file from the default ipython_dir. This is useful for embedded shells. """ if ipython_dir is None: ipython_dir = get_ipython_dir() profile_dir = os.path.join(ipython_dir, 'profile_default') config = Config() for cf in Application._load_config_files("ipython_config", path=profile_dir): config.update(cf) return config
def _find_furl(self, profile='default', cluster_dir=None, furl_or_file=None, furl_file_name=None, ipython_dir=None): """Find a FURL file. If successful, this returns a FURL file that exists on the file system. The contents of the file have not been checked though. This is because we often have to deal with FURL file whose buffers have not been flushed. This raises an :exc:`~IPython.kernel.fcutil.FURLError` exception if a FURL file can't be found. This tries the following: 1. By the name ``furl_or_file``. 2. By ``cluster_dir`` and ``furl_file_name``. 3. By cluster profile with a default of ``default``. This uses ``ipython_dir``. """ # Try by furl_or_file if furl_or_file is not None: if is_valid_furl_or_file(furl_or_file): return furl_or_file if furl_file_name is None: raise FURLError('A furl_file_name must be provided if furl_or_file is not') # Try by cluster_dir if cluster_dir is not None: cluster_dir_obj = ClusterDir.find_cluster_dir(cluster_dir) sdir = cluster_dir_obj.security_dir furl_file = os.path.join(sdir, furl_file_name) validate_furl_or_file(furl_file) return furl_file # Try by profile if ipython_dir is None: ipython_dir = get_ipython_dir() if profile is not None: cluster_dir_obj = ClusterDir.find_cluster_dir_by_profile( ipython_dir, profile) sdir = cluster_dir_obj.security_dir furl_file = os.path.join(sdir, furl_file_name) validate_furl_or_file(furl_file) return furl_file raise FURLError('Could not find a valid FURL file.')
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 _get_nbext_dir(nbextensions_dir=None, user=False, prefix=None): """Return the nbextension directory specified""" if sum(map(bool, [user, prefix, nbextensions_dir])) > 1: raise ArgumentConflict( "Cannot specify more than one of user, prefix, or nbextensions_dir." ) if user: nbext = pjoin(get_ipython_dir(), u'nbextensions') else: if prefix: nbext = pjoin(prefix, 'share', 'jupyter', 'nbextensions') elif nbextensions_dir: nbext = nbextensions_dir else: nbext = SYSTEM_NBEXTENSIONS_INSTALL_DIR return nbext