Beispiel #1
0
def test_render():
    fake_env = FakeEnv()
    fake_agent = FakeAgent(observation_space=None, action_space=None)

    trainer = Trainer(environment=fake_env, agent=fake_agent)

    trainer.render()

    assert fake_env.step_done == 0 and fake_env.reset_done == 0 and fake_env.render_done == 1

    from IPython.testing.globalipapp import get_ipython

    get_ipython().run_line_magic('matplotlib', 'inline')

    sys.stdout = FakeOutStream()
    # init inline
    trainer.render()
    assert fake_env.step_done == 0 and fake_env.reset_done == 0 and fake_env.render_done == 2
    # maj inline
    trainer.render()
    assert fake_env.step_done == 0 and fake_env.reset_done == 0 and fake_env.render_done == 3

    ## Test when rgba mode is not supported from gym env

    fake_env = FakeEnvRaise()
    trainer = Trainer(environment=fake_env, agent=fake_agent)

    # init inline
    trainer.render()
Beispiel #2
0
    def my_func():
        ip0 = get_ipython()
        if ip0 is None:
            return func()
        # We have a real ipython running...
        user_ns = ip0.user_ns
        user_global_ns = ip0.user_global_ns

        # Previously the isolation was attempted with a deep copy of the user
        # dicts, but we found cases where this didn't work correctly. I'm not
        # quite sure why, but basically it did damage the user namespace, such
        # that later tests stopped working correctly.  Instead we use a simpler
        # approach, just computing the list of added keys to the namespace and
        # eliminating those afterwards.  Existing keys that may have been
        # modified remain modified.  So far this has proven to be robust.

        # Compute set of old local/global keys
        old_locals = set(user_ns.keys())
        old_globals = set(user_global_ns.keys())
        try:
            out = func()
        finally:
            # Find new keys, and if any, remove them
            new_locals = set(user_ns.keys()) - old_locals
            new_globals = set(user_global_ns.keys()) - old_globals
            for k in new_locals:
                del user_ns[k]
            for k in new_globals:
                del user_global_ns[k]
        return out
Beispiel #3
0
def test_webgl_loading():
    """Test if the vispy.ipython extension loads the webGL backend
    on IPython 3.0 and greater.

    Test if it fails to load the webGL backend for IPython versions
    less that 3.0
    """
    import IPython
    from distutils.version import LooseVersion
    from IPython.testing.globalipapp import get_ipython

    ipy = get_ipython()
    ipy.run_cell("from vispy import app")

    if LooseVersion(IPython.__version__) >= LooseVersion("3.0.0"):
        ipy.run_cell("%load_ext vispy.ipython")
        ipy.run_cell("backend_name = app.use_app().backend_name")
        # make sure that the webgl backend got loaded
        assert_equal(ipy.user_ns["backend_name"], "ipynb_webgl")
    else:
        ipy.run_cell("%load_ext vispy.ipython")
        ipy.run_cell("backend_name = app.use_app().backend_name")

        # the above call should have failed, and thus the key
        # backend_name should not exist in the namespace

        def invalid_backend_access(ipy):
            ipy.user_ns["backend_name"]

        assert_raises(KeyError, invalid_backend_access, ipy)
Beispiel #4
0
    def test_display_extension(self):
        # noinspection PyUnresolvedReferences
        import pyrasterframes.rf_ipython

        self.create_layer()
        ip = globalipapp.get_ipython()

        num_rows = 2

        result = {}

        def counter(data, md):
            nonlocal result
            result['payload'] = (data, md)
            result['row_count'] = data.count('<tr>')

        ip.mime_renderers['text/html'] = counter

        # ip.mime_renderers['text/markdown'] = lambda a, b: print(a, b)

        self.df.display(num_rows=num_rows)

        # Plus one for the header row.
        self.assertIs(result['row_count'],
                      num_rows + 1,
                      msg=f"Received: {result['payload']}")
Beispiel #5
0
def test_webgl_loading():
    """Test if the vispy.ipython extension loads the webGL backend
    on IPython 3.0 and greater.

    Test if it fails to load the webGL backend for IPython versions
    less that 3.0"""

    import IPython
    from distutils.version import LooseVersion
    from IPython.testing.globalipapp import get_ipython

    ipy = get_ipython()
    ipy.run_cell("from vispy import app")

    if LooseVersion(IPython.__version__) >= LooseVersion("3.0.0"):
        ipy.run_cell("%load_ext vispy.ipython")
        ipy.run_cell("backend_name = app.use_app().backend_name")
        # make sure that the webgl backend got loaded
        assert_equal(ipy.user_ns["backend_name"], "ipynb_webgl")
    else:
        ipy.run_cell("%load_ext vispy.ipython")
        ipy.run_cell("backend_name = app.use_app().backend_name")

        # the above call should have failed, and thus the key
        # backend_name should not exist in the namespace

        def invalid_backend_access(ipy):
            ipy.user_ns["backend_name"]

        assert_raises(KeyError, invalid_backend_access, ipy)
Beispiel #6
0
def get_ip():
    ip = get_ipython()
    ip.run_cell('%load_ext autoreload')
    ip.run_cell('%autoreload 2')
    ip.run_cell('import numpy as np')
    ip.run_cell('import matplotlib.pylab as plt')
    return ip
 def setUp(self):
     os.environ['DJANGO_SETTINGS_MODULE'] = 'mydjangosettings'
     sys.modules['mydjangosettings'] = Settings()
     import django
     django.setup()
     self.ipshell = globalipapp.get_ipython()
     import django_tabcomplete
    def my_func():
        ip0 = get_ipython()
        if ip0 is None:
            return func()
        # We have a real ipython running...
        user_ns = ip0.user_ns
        user_global_ns = ip0.user_global_ns

        # Previously the isolation was attempted with a deep copy of the user
        # dicts, but we found cases where this didn't work correctly. I'm not
        # quite sure why, but basically it did damage the user namespace, such
        # that later tests stopped working correctly.  Instead we use a simpler
        # approach, just computing the list of added keys to the namespace and
        # eliminating those afterwards.  Existing keys that may have been
        # modified remain modified.  So far this has proven to be robust.

        # Compute set of old local/global keys
        old_locals = set(user_ns.keys())
        old_globals = set(user_global_ns.keys())
        try:
            out = func()
        finally:
            # Find new keys, and if any, remove them
            new_locals = set(user_ns.keys()) - old_locals
            new_globals = set(user_global_ns.keys()) - old_globals
            for k in new_locals:
                del user_ns[k]
            for k in new_globals:
                del user_global_ns[k]
        return out
def get_ip():
    ip = get_ipython()
    ip.run_cell('%load_ext autoreload')        
    ip.run_cell('%autoreload 2')    
    ip.run_cell('import numpy as np')
    ip.run_cell('import matplotlib.pylab as plt')
    return ip
Beispiel #10
0
def register(db, test=False):
    global get_ipython
    if test:
        from IPython.testing.globalipapp import get_ipython
    ip = get_ipython()
    magics = SqlMagic(ip, db)
    ip.register_magics(magics)
    return ip
def ipython_with_magic():
    if IPython is None:
        return None
    ip = get_ipython()
    # This is just to get a minimally modified version of the changes
    # working
    ip.magic('load_ext rpy2.ipython')
    return ip
    def setUp(self):
        self._ip = get_ipython()
        if self._ip is None:
            self._ip = start_test_ip()

        self.style = GruvboxStyle()
        # self.colorscheme = self._ip.highlighting_style.style_rules
        self.colorscheme = self.style.style_rules
Beispiel #13
0
 def setup_class(cls):
     cls.ip = get_ipython()
     cls.ip.run_cell('import random')
     cls.ip.run_cell('import numpy as np')
     if 'USE_OCTAVE' in os.environ:
         matlab = 'octave'
     else:
         matlab = 'matlab'
     pymat.load_ipython_extension(cls.ip, matlab=matlab)
Beispiel #14
0
 def setUpClass(cls):
     '''Set up an IPython session just once.
     It'd be safer to set it up for each test, but for now, I'm mimicking the
     IPython team's logic.
     '''
     cls.ip = get_ipython()
     # This is just to get a minimally modified version of the changes
     # working
     cls.ip.magic('load_ext rpy2.ipython')
 def setup_class(cls):
     cls.ip = get_ipython()
     cls.ip.run_cell('import random')
     cls.ip.run_cell('import numpy as np')
     if 'USE_OCTAVE' in os.environ:
         matlab = 'octave'
     else:
         matlab = 'matlab'
     pymat.load_ipython_extension(cls.ip, matlab=matlab)
Beispiel #16
0
 def setUpClass(cls):
     '''Set up an IPython session just once.
     It'd be safer to set it up for each test, but for now, I'm mimicking the
     IPython team's logic.
     '''
     cls.ip = get_ipython()
     # This is just to get a minimally modified version of the changes
     # working
     cls.ip.magic('load_ext rpy2.ipython')
Beispiel #17
0
    def setUp(self):
        Settings.DEFAULT_EXTENSION_TYPES.clear()
        Settings.DEFAULT_EXTENSION_TYPES.append(
            "tests.test_yuuno.SupportedTestExtension")
        YuunoIPythonEnvironment.feature_classes = [
            "tests.test_ipython_environment.TestFeature"
        ]

        self.shell = globalipapp.get_ipython()
Beispiel #18
0
def cc():
    import matplotlib.pyplot
    from IPython.testing.globalipapp import get_ipython  # https://pmbaumgartner.github.io/blog/testing-ipython-magics/
    ip = get_ipython()

    matplotlib.pyplot.close("all")

    #IPython.get_ipython().run_line_magic('reset', " -f in") # ref: https://ipython.readthedocs.io/en/stable/interactive/magics.html
    #ip.run_line_magic('reset', " -f in") # short form works
    ip.run_line_magic('reset', '-f ')  # short form works
    def setUp(self):
        Settings.DEFAULT_EXTENSION_TYPES.clear()
        Settings.DEFAULT_EXTENSION_TYPES.append("tests.test_ipython_formatter.TestClipExtension")
        YuunoIPythonEnvironment.feature_classes = [
            "tests.test_ipython_magic.TestMagicFeature"
        ]

        self.shell = globalipapp.get_ipython()
        load_ipython_extension(self.shell)

        self.loaded = True
Beispiel #20
0
 def setUpClass(cls):
     '''Set up an IPython session just once.
     It'd be safer to set it up for each test, but for now, I'm mimicking the
     IPython team's logic.
     '''
     if not sys.stdin.encoding:
         sys.stdin.encoding = 'utf-8'  # needed for py.test
     cls.ip = get_ipython()
     # This is just to get a minimally modified version of the changes
     # working
     cls.ip.magic('load_ext oct2py.ipython')
     cls.ip.ex('import numpy as np')
     cls.svgs_generated = 0
 def setUpClass(cls):
     '''Set up an IPython session just once.
     It'd be safer to set it up for each test, but for now, I'm mimicking the
     IPython team's logic.
     '''
     if not sys.stdin.encoding:
         sys.stdin.encoding = 'utf-8'  # needed for py.test
     cls.ip = get_ipython()
     # This is just to get a minimally modified version of the changes
     # working
     cls.ip.magic('load_ext oct2py.ipython')
     cls.ip.ex('import numpy as np')
     cls.svgs_generated = 0
Beispiel #22
0
    def setUp(self):
        Settings.DEFAULT_EXTENSION_TYPES.clear()
        Settings.DEFAULT_EXTENSION_TYPES.append(
            "tests.test_ipython_formatter.TestClipExtension")
        YuunoIPythonEnvironment.feature_classes = [
            "yuuno_ipython.ipython.formatter.Formatter"
        ]

        self.shell = globalipapp.get_ipython()
        load_ipython_extension(self.shell)
        Yuuno.instance().output.icc_profile = None

        self.loaded = True
Beispiel #23
0
    def setUp(self):
        Settings.DEFAULT_EXTENSION_TYPES.clear()
        Settings.DEFAULT_EXTENSION_TYPES.append(
            'tests.test_ipython_namespace.TestExtension')
        YuunoIPythonEnvironment.feature_classes = [
            "yuuno_ipython.ipython.namespace.Namespace"
        ]

        self.shell = globalipapp.get_ipython()
        load_ipython_extension(self.shell)

        self.loaded = True

        self.yuuno = Yuuno.instance()
Beispiel #24
0
 def setUpClass(cls):
     """Set up an IPython session just once.
     It'd be safer to set it up for each test, but for now,
     I'm mimicking the IPython team's logic.
     """
     if not sys.stdin.encoding:
         # needed for py.test
         sys.stdin = codecs.getreader("utf-8")(sys.stdin)
     cls.ip = get_ipython()
     # This is just to get a minimally modified version of the changes
     # working
     cls.ip.run_line_magic("load_ext", "oct2py.ipython")
     cls.ip.ex("import numpy as np")
     cls.svgs_generated = 0
    def setup_class(cls):
        cls.ip = get_ipython()
        cls.ip.run_cell('import random')
        cls.ip.run_cell('import numpy as np')
        if 'USE_OCTAVE' in os.environ:
            matlab = 'octave'
        else:
            matlab = 'matlab'

        # We will test the passing of kwargs through to the Matlab or Octave
        # objects, by assigning the socket address out here:
        socket_addr = "tcp://127.0.0.1" if sys.platform == "win32" else "ipc:///tmp/pymatbridge-%s"%str(uuid4())
        pymat.load_ipython_extension(cls.ip, matlab=matlab,
                                     socket_addr=socket_addr)
Beispiel #26
0
    def test_init(self):
        ip = get_ipython()
        ip.run_line_magic('load_ext', 'line_profiler')
        ip.run_cell(raw_cell='def func():\n    return 2**20')
        lprof = ip.run_line_magic('lprun', '-r -f func func()')

        timings = lprof.get_stats().timings
        self.assertEqual(len(timings), 1)  # 1 function

        func_data, lines_data = next(iter(timings.items()))
        self.assertEqual(func_data[1], 1)  # lineno of the function
        self.assertEqual(func_data[2], "func")  # function name
        self.assertEqual(len(lines_data), 1)  # 1 line of code
        self.assertEqual(lines_data[0][0], 2)  # lineno
        self.assertEqual(lines_data[0][1], 1)  # hits
Beispiel #27
0
def test_ipython_magics():
    """Test that the %aiida magic can be loaded and adds the QueryBuilder and Node variables."""
    ipy = get_ipython()
    register_ipython_extension(ipy)

    cell = """
%aiida
qb=QueryBuilder()
qb.append(Node)
qb.all()
Dict().store()
"""
    result = ipy.run_cell(cell)

    assert result.success
def test_myinput():
    ip = get_ipython()

    test_cell = "foo\nbar"

    assert not ip.register_magic_function(replace_input, magic_kind="cell")
    assert not ip.run_cell_magic("replace_input", None, test_cell)

    for line in test_cell.split("\n"):
        c = ip.run_cell("input()")
        print(c.result)
        assert c.success
        assert c.result == line
    c = ip.run_cell("input()")
    assert not c.success
    assert isinstance(c.error_in_exec, StopIteration)
Beispiel #29
0
    def setup_class(cls):
        cls.ip = get_ipython()
        cls.ip.run_cell('import random')
        cls.ip.run_cell('import numpy as np')
        if 'USE_OCTAVE' in os.environ:
            matlab = 'octave'
        else:
            matlab = 'matlab'

        # We will test the passing of kwargs through to the Matlab or Octave
        # objects, by assigning the socket address out here:
        socket_addr = "tcp://127.0.0.1" if sys.platform == "win32" else "ipc:///tmp/pymatbridge-%s" % str(
            uuid4())
        pymat.load_ipython_extension(cls.ip,
                                     matlab=matlab,
                                     socket_addr=socket_addr)
Beispiel #30
0
    def test_graph_notebook_config(self):
        ip = get_ipython()
        ip.magic('load_ext graph_notebook.magics')

        res: Configuration = ip.run_line_magic('graph_notebook_config', '')
        config_dict = res.to_dict()
        self.assertEqual(self.config.to_dict(), res.to_dict())

        config_dict['host'] = 'this-was-changed'
        res2: Configuration = ip.run_cell_magic('graph_notebook_config', '',
                                                json.dumps(config_dict))
        config_dict2 = res2.to_dict()

        res3: Configuration = ip.run_line_magic('graph_notebook_config', '')
        config_dict3 = res3.to_dict()

        self.assertEqual(config_dict2, config_dict3)
Beispiel #31
0
def _get_interpreter():
    """ Get iPython interpreter.

    If it has been previously initialized, return it. Otherwise, start it.

    Further work: implement some mechanism to get an interpreter configured
    with some virtual environment or kernel.

    Returns
    -------
    callable
        iPython interpreter.
    """
    if not globals()['IPYTHON_INTERPRETER']:
        globals()['IPYTHON_INTERPRETER'] = get_ipython()

    return IPYTHON_INTERPRETER
Beispiel #32
0
def exec_line_magic(context, command):
    """Execute line magic function """
    ip = get_ipython()
    ip.magic(command)
Beispiel #33
0
# third party
import nose.tools as nt

# our own packages
from IPython.core import autocall
from IPython.testing import tools as tt
from IPython.testing.globalipapp import get_ipython
from IPython.utils import py3compat

#-----------------------------------------------------------------------------
# Globals
#-----------------------------------------------------------------------------

# Get the public instance of IPython
ip = get_ipython()

failures = []
num_tests = 0

#-----------------------------------------------------------------------------
# Test functions
#-----------------------------------------------------------------------------


class CallableIndexable(object):
    def __getitem__(self, idx):
        return True

    def __call__(self, *args, **kws):
        return True
"""Tests for input manipulation machinery."""

#-----------------------------------------------------------------------------
# Imports
#-----------------------------------------------------------------------------
import nose.tools as nt

from IPython.core.prefilter import AutocallChecker
from IPython.testing import tools as tt, decorators as dec
from IPython.testing.globalipapp import get_ipython

#-----------------------------------------------------------------------------
# Tests
#-----------------------------------------------------------------------------
ip = get_ipython()

@dec.parametric
def test_prefilter():
    """Test user input conversions"""

    # pairs of (raw, expected correct) input
    pairs = [ ('2+2','2+2'),
              ('>>> 2+2','2+2'),
              ('>>> # This is a comment\n'
               '... 2+2',
               '# This is a comment\n'
               '2+2'),
              # Some IPython input
              ('In [1]: 1', '1'),
              ('In [2]: for i in range(5):\n'
               '   ...:     print i,',
Beispiel #35
0
 def tearDownClass(cls) -> None:
     globalipapp.get_ipython().atexit_operations()
Beispiel #36
0
 def setUpClass(self):
     self.ip = get_ipython()
     self.ip.magic('load_ext ipython_cells')
     self.ip.magic('load_file example.py')
Beispiel #37
0
def test_register_magics(julia):
    magic.load_ipython_extension(globalipapp.get_ipython())
Beispiel #38
0
def julia_magics(julia):
    return magic.JuliaMagics(shell=globalipapp.get_ipython())
Beispiel #39
0
def ipy_with_magic(julia):
    ip = get_ipython()
    magic.load_ipython_extension(ip)
    return ip