Add IPython startup scripts

import sys

import logging

from os.path import join, dirname

c = get_config()

	('manage', '{0} manage.py'.format(sys.executable)),

	('manage2', 'python2 manage.py'),

	('manage3', 'python3 manage.py'),

	('rpdb', 'screen -c {0} {1} -m rpdb2 -s'

		.format(join(dirname(__file__), 'screen-debug.conf'), sys.executable)),

	('python', sys.executable),

	('python2', 'python2'),

	('python3', 'python3'),

		('pip', '{0} -m pip'.format(sys.executable)),

	])

c.InteractiveShellApp.exec_lines = [

	'from importlib import reload',

]

c.InteractiveShellApp.log_level = logging.DEBUG

c.TerminalInteractiveShell.confirm_exit = False

c.TerminalInteractiveShell.editing_mode = 'vi'

import sys

from contextlib import suppress

from importlib import reload, util as _import_util

class MagicFinder:

	"""

	Contextual module finder which claims to know about packages given by user

	In the following example if the 'foo' and 'bar' are not found on `sys.path`

	the configured packages will be installed with pip.  Any pip package name

	can be given, including source and VCS URLs:

	> with MagicFinder(foo='python-foo', bar='git+https://github.com/example/pybar'):

	>     import foo.fobulator

	>     import bar

	"""

	def __init__(self, **pip_packages):

		self.packages = pip_packages

	def __enter__(self):

		sys.meta_path.append(self)

	def __exit__(self, *exc_info):

		sys.meta_path.remove(self)

	def find_spec(self, name, path, target):

		if name not in self.packages or path is not None or target is not None:

			return

		# name is popped off self.packages to prevent recursion

		return MagicSpec(name, self.packages.pop(name))

class MagicSpec:

	"""

	Module spec & loader wrapper which handles installation

	After installation the wrapper hands off to an actual loader.

	"""

	def __init__(self, name, package):

		self.name = name

		self.package = package

		self.loader = self

		self.spec = None

	def __getattr__(self, name):

		return getattr(self.spec, name)

	def create_module(self, _):

		from pip._internal import main

		if 0 != main(['install', self.package]):

			raise ImportError("Unable to install {}".format(self.package))

		self.spec = _import_util.find_spec(self.name)

		if hasattr(self.spec.loader, 'create_module'):

			return self.spec.loader.create_module(self.spec)

	def exec_module(self, module):

		module.__spec__ = self.spec

		return self.spec.loader.exec_module(module)

import logging

with MagicFinder(colorlog='colorlog'):

	from colorlog import ColoredFormatter

class StripExcFilter:

	def filter(self, record):

		record.exc_info = None

		return True

# Logger for any of the startup scripts

startup_logger = logging.getLogger('startup')

# Initialise logging with a pretty formatter

handler = logging.StreamHandler()

handler.setFormatter(ColoredFormatter(

	"%(log_color)s%(levelname)7s%(reset)s: [%(name)s] %(log_color)s%(message)s",

))

logging.root.addHandler(handler)

logging.root.setLevel(logging.DEBUG)

# Supress DEBUG from tab-completion parser

logging.getLogger('parso').setLevel(logging.INFO)

# Strip exc-info from curio.kernel messages; we don't need to see the internals

# of the kernel

logging.getLogger('curio.kernel').addFilter(StripExcFilter())

del ColoredFormatter

del handler

with MagicFinder(pudb='git+https://github.com/domsekotill/pudb.git@master'):

	import pudb.ipython

from importlib import reload