Python verify_api Beispiele

Beispiel #1

Datei: test_showing.py Projekt: jsalcal/bokeh

# API Definition
#-----------------------------------------------------------------------------

api = {

    PUBLIC: (

        ( 'show', (1, 0, 0) ),

    ), INTERNAL: (

    )

}

Test_api = verify_api(bis, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Public API
#-----------------------------------------------------------------------------

@patch('bokeh.io.showing._show_with_state')
def test_show_with_default_args(mock__show_with_state):
    curstate().reset()
    default_kwargs = dict(browser=None, new="tab", notebook_handle=False)
    p = Plot()
    bis.show(p, **default_kwargs)

Beispiel #2

        ( 'CodeRunner',                   (1,0,0) ),

        ( 'CodeRunner.error.fget',        (1,0,0) ),
        ( 'CodeRunner.error_detail.fget', (1,0,0) ),
        ( 'CodeRunner.failed.fget',       (1,0,0) ),
        ( 'CodeRunner.path.fget',         (1,0,0) ),
        ( 'CodeRunner.source.fget',       (1,0,0) ),

        ( 'CodeRunner.new_module',        (1,0,0) ),
        ( 'CodeRunner.run',               (1,0,0) ),

    )

}

Test_api = verify_api(bahc, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# General API
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Dev API
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Private API

Beispiel #3

Datei: test_hsl.py Projekt: FourtekIT-incubator/bokeh

        ( 'HSL',          (1, 0, 0) ),
        ( 'HSL.copy',     (1, 0, 0) ),
        ( 'HSL.from_hsl', (1, 0, 0) ),
        ( 'HSL.from_rgb', (1, 0, 0) ),
        ( 'HSL.to_css',   (1, 0, 0) ),
        ( 'HSL.to_hsl',   (1, 0, 0) ),
        ( 'HSL.to_rgb',   (1, 0, 0) ),

    ), DEV: (

    )

}

Test_api = verify_api(bch, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# General API
#-----------------------------------------------------------------------------

class Test_HSL(object):

    def test_init(self):
        c = bch.HSL(10, 0.2, 0.3)
        assert c
        assert c.a == 1.0

Beispiel #4

Datei: test_function.py Projekt: william27wp/python-udemy

    GENERAL: (

        ( 'FunctionHandler',                   (1,0,0) ),

        ( 'FunctionHandler.safe_to_fork.fget', (1,0,0) ),

        ( 'FunctionHandler.modify_document',   (1,0,0) ),

    ), DEV: (

    )

}

Test_api = verify_api(bahf, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

class AnotherModelInTestFunction(Model):
    bar = Int(1)

class SomeModelInTestFunction(Model):
    foo = Int(2)
    child = Instance(Model)

#-----------------------------------------------------------------------------
# General API
#-----------------------------------------------------------------------------

Beispiel #5

Datei: test_bundle.py Projekt: FourtekIT-incubator/bokeh

# API Definition
#-----------------------------------------------------------------------------

api = {

    GENERAL: (

    ), DEV: (

        ( 'bundle_for_objs_and_resources', (1,0,0) ),

    )

}

Test_api = verify_api(beb, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

@pytest.fixture
def test_plot():
    from bokeh.plotting import figure
    test_plot = figure()
    test_plot.circle([1, 2], [2, 3])
    return test_plot

@pytest.fixture
def test_glplot():
    from bokeh.plotting import figure

Beispiel #6

Datei: test_transform.py Projekt: yuanhsin8311/Python-BokehServer

        ( 'dodge',       (1, 0, 0) ),
        ( 'factor_cmap', (1, 0, 0) ),
        ( 'jitter',      (1, 0, 0) ),
        ( 'linear_cmap', (1, 0, 0) ),
        ( 'log_cmap',    (1, 0, 0) ),
        ( 'stack',       (1, 0, 0) ),
        ( 'transform',   (1, 0, 0) ),

    ), INTERNAL: (

    )

}

Test_api = verify_api(bt, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

ALL = (
    'dodge',
    'factor_cmap',
    'jitter',
    'linear_cmap',
    'log_cmap',
    'stack',
    'transform',
)

Beispiel #7

Datei: test_rgb.py Projekt: jsalcal/bokeh

        ( 'RGB',          (1, 0, 0) ),
        ( 'RGB.copy',     (1, 0, 0) ),
        ( 'RGB.from_hsl', (1, 0, 0) ),
        ( 'RGB.from_rgb', (1, 0, 0) ),
        ( 'RGB.to_css',   (1, 0, 0) ),
        ( 'RGB.to_hex',   (1, 0, 0) ),
        ( 'RGB.to_hsl',   (1, 0, 0) ),
        ( 'RGB.to_rgb',   (1, 0, 0) ),

    ), INTERNAL: (

    )

}

Test_api = verify_api(bcr, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Public API
#-----------------------------------------------------------------------------

class Test_RGB(object):

    def test_init(self):
        c = bcr.RGB(10, 20, 30)
        assert c
        assert c.a == 1.0

Beispiel #8

Datei: test_bundle.py Projekt: william27wp/python-udemy

# External imports

# Bokeh imports
from bokeh.document import Document

# Module under test
import bokeh.embed.bundle as beb

#-----------------------------------------------------------------------------
# API Definition
#-----------------------------------------------------------------------------

api = {GENERAL: (), DEV: (('bundle_for_objs_and_resources', (1, 0, 0)), )}

Test_api = verify_api(beb, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------


@pytest.fixture
def test_plot():
    from bokeh.plotting import figure
    test_plot = figure()
    test_plot.circle([1, 2], [2, 3])
    return test_plot


@pytest.fixture

Beispiel #9

Datei: test_hex.py Projekt: zhaopw0411/bokeh

import bokeh.util.hex as buh

#-----------------------------------------------------------------------------
# API Definition
#-----------------------------------------------------------------------------

api = {
    GENERAL: (
        ('axial_to_cartesian', (1, 0, 0)),
        ('cartesian_to_axial', (1, 0, 0)),
        ('hexbin', (1, 0, 0)),
    ),
    DEV: ()
}

Test_api = verify_api(buh, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

np.random.seed(0)
n = 500
x = 2 + np.random.standard_normal(n)
y = 2 + np.random.standard_normal(n)

#-----------------------------------------------------------------------------
# General API
#-----------------------------------------------------------------------------

Beispiel #10

Datei: test_notebook.py Projekt: FourtekIT-incubator/bokeh

# API Definition
#-----------------------------------------------------------------------------

api = {

    GENERAL: (

        ( 'NotebookHandler', (1,0,0) ),

    ), DEV: (

    )

}

Test_api = verify_api(bahn, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

def with_script_contents(contents, func):
    def with_file_object(f):
        nbsource = nbformat.writes(contents)
        f.write(nbsource.encode("UTF-8"))
        f.flush()
        func(f.name)
    with_temporary_file(with_file_object)

#-----------------------------------------------------------------------------
# General API

Beispiel #11

Datei: test_rgb.py Projekt: yuanhsin8311/Python-BokehServer

api = {
    PUBLIC: (
        ('RGB', (1, 0, 0)),
        ('RGB.copy', (1, 0, 0)),
        ('RGB.from_hsl', (1, 0, 0)),
        ('RGB.from_rgb', (1, 0, 0)),
        ('RGB.to_css', (1, 0, 0)),
        ('RGB.to_hex', (1, 0, 0)),
        ('RGB.to_hsl', (1, 0, 0)),
        ('RGB.to_rgb', (1, 0, 0)),
    ),
    INTERNAL: ()
}

Test_api = verify_api(bcr, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Public API
#-----------------------------------------------------------------------------


class Test_RGB(object):
    def test_init(self):
        c = bcr.RGB(10, 20, 30)
        assert c
        assert c.a == 1.0

Beispiel #12

Datei: test_output.py Projekt: FourtekIT-incubator/bokeh

api = {

    GENERAL: (

        ( 'output_file',     (1, 0, 0) ),
        ( 'output_notebook', (1, 0, 0) ),
        ( 'reset_output',    (1, 0, 0) ),

    ), DEV: (

    )

}

Test_api = verify_api(bio, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# General API
#-----------------------------------------------------------------------------

class Test_output_file(object):

    @patch('bokeh.io.state.State.output_file')
    def test_no_args(self, mock_output_file):
        default_kwargs = dict(title="Bokeh Plot", mode="cdn", root_dir=None)
        bio.output_file("foo.html")

Beispiel #13

import nbformat

# Bokeh imports
from bokeh.document import Document
from bokeh.util.testing import with_temporary_file

# Module under test
import bokeh.application.handlers.notebook as bahn

#-----------------------------------------------------------------------------
# API Definition
#-----------------------------------------------------------------------------

api = {GENERAL: (('NotebookHandler', (1, 0, 0)), ), DEV: ()}

Test_api = verify_api(bahn, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------


def with_script_contents(contents, func):
    def with_file_object(f):
        nbsource = nbformat.writes(contents)
        f.write(nbsource.encode("UTF-8"))
        f.flush()
        func(f.name)

    with_temporary_file(with_file_object)

Beispiel #14

Datei: test_handler.py Projekt: FourtekIT-incubator/bokeh

        ( 'Handler.modify_document',      (1,0,0) ),
        ( 'Handler.on_server_loaded',     (1,0,0) ),
        ( 'Handler.on_server_unloaded',   (1,0,0) ),
        ( 'Handler.on_session_created',   (1,0,0) ),
        ( 'Handler.on_session_destroyed', (1,0,0) ),
        ( 'Handler.static_path',          (1,0,0) ),
        ( 'Handler.url_path',             (1,0,0) ),

    ), DEV: (

    )

}

Test_api = verify_api(bahh, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# General API
#-----------------------------------------------------------------------------

class Test_Handler(object):

    def test_create(self):
        h = bahh.Handler()
        assert h.failed == False
        assert h.url_path() is None

Beispiel #15

Datei: test_application.py Projekt: FourtekIT-incubator/bokeh

        ( 'ServerContext.add_timeout_callback',      (1,0,0) ),
        ( 'ServerContext.remove_next_tick_callback', (1,0,0) ),
        ( 'ServerContext.remove_periodic_callback',  (1,0,0) ),
        ( 'ServerContext.remove_timeout_callback',   (1,0,0) ),

        ( 'SessionContext',                      (1,0,0) ),
        ( 'SessionContext.destroyed.fget',       (1,0,0) ),
        ( 'SessionContext.id.fget',              (1,0,0) ),
        ( 'SessionContext.server_context.fget',  (1,0,0) ),
        ( 'SessionContext.with_locked_document', (1,0,0) ),

    )

}

Test_api = verify_api(baa, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

class AnotherModelInTestApplication(Model):
    baar = Int(1)

class SomeModelInTestApplication(Model):
    foo = Int(2)
    child = Instance(Model)

#-----------------------------------------------------------------------------
# General API
#-----------------------------------------------------------------------------

Beispiel #16

Datei: test_directory.py Projekt: william27wp/python-udemy

        ('DirectoryHandler', (1, 0, 0)),
        ('DirectoryHandler.error.fget', (1, 0, 0)),
        ('DirectoryHandler.error_detail.fget', (1, 0, 0)),
        ('DirectoryHandler.failed.fget', (1, 0, 0)),
        ('DirectoryHandler.safe_to_fork.fget', (1, 0, 0)),
        ('DirectoryHandler.modify_document', (1, 0, 0)),
        ('DirectoryHandler.on_server_loaded', (1, 0, 0)),
        ('DirectoryHandler.on_server_unloaded', (1, 0, 0)),
        ('DirectoryHandler.on_session_created', (1, 0, 0)),
        ('DirectoryHandler.on_session_destroyed', (1, 0, 0)),
        ('DirectoryHandler.url_path', (1, 0, 0)),
    ),
    DEV: ()
}

Test_api = verify_api(bahd, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

script_adds_two_roots_template = """
from bokeh.io import curdoc
from bokeh.model import Model
from bokeh.core.properties import Int, Instance

class %s(Model):
    bar = Int(1)

class %s(Model):
    foo = Int(2)

Beispiel #17

Datei: test_directory.py Projekt: FourtekIT-incubator/bokeh

        ( 'DirectoryHandler.safe_to_fork.fget',    (1,0,0) ),

        ( 'DirectoryHandler.modify_document',      (1,0,0) ),
        ( 'DirectoryHandler.on_server_loaded',     (1,0,0) ),
        ( 'DirectoryHandler.on_server_unloaded',   (1,0,0) ),
        ( 'DirectoryHandler.on_session_created',   (1,0,0) ),
        ( 'DirectoryHandler.on_session_destroyed', (1,0,0) ),
        ( 'DirectoryHandler.url_path',             (1,0,0) ),

    ), DEV: (

    )

}

Test_api = verify_api(bahd, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

script_adds_two_roots_template = """
from bokeh.io import curdoc
from bokeh.model import Model
from bokeh.core.properties import Int, Instance

class %s(Model):
    bar = Int(1)

class %s(Model):
    foo = Int(2)

Beispiel #18

Datei: test_export.py Projekt: FourtekIT-incubator/bokeh

        ( 'export_png',  (1, 0, 0) ),
        ( 'export_svgs', (1, 0, 0) ),

    ), DEV: (

        ( 'get_screenshot_as_png',      (1, 0, 0) ),
        ( 'get_svgs',                   (1, 0, 0) ),
        ( 'save_layout_html',           (1, 0, 0) ),
        ( 'wait_until_render_complete', (1, 0, 0) ),

    ),

}

Test_api = verify_api(bie, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# General API
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Dev API
#-----------------------------------------------------------------------------

@pytest.mark.unit
@pytest.mark.selenium

Beispiel #19

# External imports

# Bokeh imports
from bokeh.document import Document
from bokeh.util.testing import with_file_contents

# Module under test
import bokeh.application.handlers.script as bahs

#-----------------------------------------------------------------------------
# API Definition
#-----------------------------------------------------------------------------

api = {GENERAL: (('ScriptHandler', (1, 0, 0)), ), DEV: ()}

Test_api = verify_api(bahs, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# General API
#-----------------------------------------------------------------------------


class Test_ScriptHandler(object):
    def test_runner_uses_source_from_filename(self):
        doc = Document()
        source = "# Test contents for script"
        result = {}

Beispiel #20

Datei: test_script.py Projekt: FourtekIT-incubator/bokeh

# API Definition
#-----------------------------------------------------------------------------

api = {

    GENERAL: (

        ( 'ScriptHandler', (1,0,0) ),

    ), DEV: (

    )

}

Test_api = verify_api(bahs, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# General API
#-----------------------------------------------------------------------------

class Test_ScriptHandler(object):

    def test_runner_uses_source_from_filename(self):
        doc = Document()
        source = "# Test contents for script"
        result = {}

Beispiel #21

Datei: test_websocket.py Projekt: yuanhsin8311/Python-BokehServer

#-----------------------------------------------------------------------------
# API Definition
#-----------------------------------------------------------------------------

api = {
    PUBLIC: (),
    INTERNAL: (
        ('WebSocketClientConnectionWrapper', (1, 0, 0)),
        ('WebSocketClientConnectionWrapper.write_message', (1, 0, 0)),
        ('WebSocketClientConnectionWrapper.close', (1, 0, 0)),
        ('WebSocketClientConnectionWrapper.read_message', (1, 0, 0)),
    )
}

Test_api = verify_api(bcw, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Public API
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Internal API
#-----------------------------------------------------------------------------


class Test_WebSocketClientConnectionWrapper(object):

Beispiel #22

Datei: test_util.py Projekt: jsalcal/bokeh

api = {

    PUBLIC: (

    ), INTERNAL: (

        ( 'ColorGroup' ,        (1, 0, 0) ),
        ( 'NamedColor' ,        (1, 0, 0) ),
        ( 'NamedColor.to_css' , (1, 0, 0) ),

    )

}

Test_api = verify_api(bcu, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

class _TestGroup(bcu.ColorGroup):
    _colors = ("Red", "Green", "Blue")


#-----------------------------------------------------------------------------
# Public API
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Internal API

Beispiel #23

Datei: test_standalone.py Projekt: jsalcal/bokeh

api = {

    PUBLIC: (

        ( 'autoload_static', (1,0,0) ),
        ( 'components',      (1,0,0) ),
        ( 'file_html',       (1,0,0) ),

    ), INTERNAL: (

    )

}

Test_api = verify_api(bes, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

class SomeModelInTestObjects(Model):
    child = Instance(Model)

def stable_id():
    return 'ID'

@pytest.fixture
def test_plot():
    from bokeh.plotting import figure
    test_plot = figure()

Beispiel #24

Datei: test_notebook.py Projekt: philippjfr/bokeh

        ( 'CommsHandle.comms.fget', (1, 0, 0) ),
        ( 'CommsHandle.doc.fget',   (1, 0, 0) ),
        ( 'destroy_server',         (1, 0, 0) ),
        ( 'get_comms',              (1, 0, 0) ),
        ( 'install_jupyter_hooks',  (1, 0, 0) ),
        ( 'load_notebook',          (1, 0, 0) ),
        ( 'publish_display_data',   (1, 0, 0) ),
        ( 'show_app',               (1, 0, 0) ),
        ( 'show_doc',               (1, 0, 0) ),

    )

}

Test_api = verify_api(binb, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Public API
#-----------------------------------------------------------------------------

def test_install_notebook_hook():
    binb.install_notebook_hook("foo", "load", "doc", "app")
    assert binb._HOOKS["foo"]['load'] == "load"
    assert binb._HOOKS["foo"]['doc'] == "doc"
    assert binb._HOOKS["foo"]['app'] == "app"
    with pytest.raises(RuntimeError):

Beispiel #25

Datei: test_util.py Projekt: philippjfr/bokeh

api = {

    PUBLIC: (

    ), INTERNAL: (

        ( 'default_filename',        (1, 0, 0) ),
        ( 'detect_current_filename', (1, 0, 0) ),
        ( 'temp_filename',           (1, 0, 0) ),

    )

}

Test_api = verify_api(biu, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Public API
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Internal API
#-----------------------------------------------------------------------------

def test_detect_current_filename():
    assert biu.detect_current_filename().endswith("py.test")

Beispiel #26

Datei: test_websocket.py Projekt: alamont/bokeh

api = {

    PUBLIC: (

    ), INTERNAL: (

        ( 'WebSocketClientConnectionWrapper',               (1, 0, 0) ),
        ( 'WebSocketClientConnectionWrapper.write_message', (1, 0, 0) ),
        ( 'WebSocketClientConnectionWrapper.close',         (1, 0, 0) ),
        ( 'WebSocketClientConnectionWrapper.read_message',  (1, 0, 0) ),

    )

}

test_public_api, test_internal_api, test_all_declared, test_all_tested = verify_api(bcw, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Public API
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Internal API
#-----------------------------------------------------------------------------

class Test_WebSocketClientConnectionWrapper(object):

Beispiel #27

Datei: test_connection.py Projekt: zedred46/bokeh

        ('ClientConnection', (1, 0, 0)),
        ('ClientConnection.connected.fget', (1, 0, 0)),
        ('ClientConnection.io_loop.fget', (1, 0, 0)),
        ('ClientConnection.url.fget', (1, 0, 0)),
        ('ClientConnection.connect', (1, 0, 0)),
        ('ClientConnection.close', (1, 0, 0)),
        ('ClientConnection.force_roundtrip', (1, 0, 0)),
        ('ClientConnection.loop_until_closed', (1, 0, 0)),
        ('ClientConnection.pull_doc', (1, 0, 0)),
        ('ClientConnection.push_doc', (1, 0, 0)),
        ('ClientConnection.request_server_info', (1, 0, 0)),
        ('ClientConnection.send_message', (1, 0, 0)),
    )
}

Test_api = verify_api(bcc, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Public API
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Internal API
#-----------------------------------------------------------------------------


class Test_ClientConnection(object):

Beispiel #28

Datei: test_rgb.py Projekt: victorfcsouza/bokeh

api = {
    PUBLIC: (
        ('RGB', (1, 0, 0)),
        ('RGB.copy', (1, 0, 0)),
        ('RGB.from_hsl', (1, 0, 0)),
        ('RGB.from_rgb', (1, 0, 0)),
        ('RGB.to_css', (1, 0, 0)),
        ('RGB.to_hex', (1, 0, 0)),
        ('RGB.to_hsl', (1, 0, 0)),
        ('RGB.to_rgb', (1, 0, 0)),
    ),
    INTERNAL: ()
}

test_public_api, test_internal_api, test_all_declared, test_all_tested = verify_api(
    bcr, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Public API
#-----------------------------------------------------------------------------


class Test_RGB(object):
    def test_init(self):
        c = bcr.RGB(10, 20, 30)
        assert c
        assert c.a == 1.0

Beispiel #29

Datei: test_server.py Projekt: yuanhsin8311/Python-BokehServer

# Module under test
import bokeh.embed.server as bes

#-----------------------------------------------------------------------------
# API Definition
#-----------------------------------------------------------------------------

api = {
    PUBLIC: (
        ('server_document', (1, 0, 0)),
        ('server_session', (1, 0, 0)),
    ),
    INTERNAL: (('server_html_page_for_session', (1, 0, 0)), )
}

Test_api = verify_api(bes, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------


@pytest.fixture
def test_plot():
    from bokeh.plotting import figure
    test_plot = figure()
    test_plot.circle([1, 2], [2, 3])
    return test_plot


#-----------------------------------------------------------------------------

Beispiel #30

Datei: test_util.py Projekt: yuanhsin8311/Python-BokehServer

        ( 'check_models_or_docs',                  (1,0,0) ),
        ( 'check_one_model_or_doc',                (1,0,0) ),
        ( 'div_for_render_item',                   (1,0,0) ),
        ( 'find_existing_docs',                    (1,0,0) ),
        ( 'html_page_for_render_items',            (1,0,0) ),
        ( 'script_for_render_items',               (1,0,0) ),
        ( 'standalone_docs_json_and_render_items', (1,0,0) ),
        ( 'wrap_in_onload',                        (1,0,0) ),
        ( 'wrap_in_safely',                        (1,0,0) ),
        ( 'wrap_in_script_tag',                    (1,0,0) ),

    )

}

Test_api = verify_api(beu, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Public API
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Internal API
#-----------------------------------------------------------------------------

class Test_FromCurdoc(object):

Beispiel #31

Datei: test_connection.py Projekt: jsalcal/bokeh

        ( 'ClientConnection.io_loop.fget',        (1, 0, 0) ),
        ( 'ClientConnection.url.fget',            (1, 0, 0) ),
        ( 'ClientConnection.connect',             (1, 0, 0) ),
        ( 'ClientConnection.close',               (1, 0, 0) ),
        ( 'ClientConnection.force_roundtrip',     (1, 0, 0) ),
        ( 'ClientConnection.loop_until_closed',   (1, 0, 0) ),
        ( 'ClientConnection.pull_doc',            (1, 0, 0) ),
        ( 'ClientConnection.push_doc',            (1, 0, 0) ),
        ( 'ClientConnection.request_server_info', (1, 0, 0) ),
        ( 'ClientConnection.send_message',        (1, 0, 0) ),

    )

}

Test_api = verify_api(bcc, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Public API
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Internal API
#-----------------------------------------------------------------------------

class Test_ClientConnection(object):

Beispiel #32

Datei: test_application.py Projekt: zhaopw0411/bokeh

        ('ServerContext.sessions.fget', (1, 0, 0)),
        ('ServerContext.add_next_tick_callback', (1, 0, 0)),
        ('ServerContext.add_periodic_callback', (1, 0, 0)),
        ('ServerContext.add_timeout_callback', (1, 0, 0)),
        ('ServerContext.remove_next_tick_callback', (1, 0, 0)),
        ('ServerContext.remove_periodic_callback', (1, 0, 0)),
        ('ServerContext.remove_timeout_callback', (1, 0, 0)),
        ('SessionContext', (1, 0, 0)),
        ('SessionContext.destroyed.fget', (1, 0, 0)),
        ('SessionContext.id.fget', (1, 0, 0)),
        ('SessionContext.server_context.fget', (1, 0, 0)),
        ('SessionContext.with_locked_document', (1, 0, 0)),
    )
}

Test_api = verify_api(baa, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

# needed for caplog tests to function
basicConfig()


class AnotherModelInTestApplication(Model):
    baar = Int(1)


class SomeModelInTestApplication(Model):
    foo = Int(2)

Beispiel #33

# External imports

# Bokeh imports
from bokeh.core.templates import DOC_NB_JS, PLOT_DIV
from bokeh.core.json_encoder import serialize_json

# Module under test
import bokeh.embed.notebook as ben

#-----------------------------------------------------------------------------
# API Definition
#-----------------------------------------------------------------------------

api = {PUBLIC: (), INTERNAL: (('notebook_content', (1, 0, 0)), )}

Test_api = verify_api(ben, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------


@pytest.fixture
def test_plot():
    from bokeh.plotting import figure
    test_plot = figure()
    test_plot.circle([1, 2], [2, 3])
    return test_plot


#-----------------------------------------------------------------------------

Beispiel #34

#-----------------------------------------------------------------------------

api = {
    PUBLIC: (
        ('HSL', (1, 0, 0)),
        ('HSL.copy', (1, 0, 0)),
        ('HSL.from_hsl', (1, 0, 0)),
        ('HSL.from_rgb', (1, 0, 0)),
        ('HSL.to_css', (1, 0, 0)),
        ('HSL.to_hsl', (1, 0, 0)),
        ('HSL.to_rgb', (1, 0, 0)),
    ),
    INTERNAL: ()
}

Test_api = verify_api(bch, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Public API
#-----------------------------------------------------------------------------


class Test_HSL(object):
    def test_init(self):
        c = bch.HSL(10, 0.2, 0.3)
        assert c
        assert c.a == 1.0

Beispiel #35

Datei: test_states.py Projekt: FourtekIT-incubator/bokeh

        ( 'CONNECTED_BEFORE_ACK',         (1, 0, 0) ),
        ( 'CONNECTED_BEFORE_ACK.run',     (1, 0, 0) ),
        ( 'CONNECTED_AFTER_ACK',          (1, 0, 0) ),
        ( 'CONNECTED_AFTER_ACK.run',      (1, 0, 0) ),
        ( 'DISCONNECTED',                 (1, 0, 0) ),
        ( 'DISCONNECTED.run',             (1, 0, 0) ),
        ( 'WAITING_FOR_REPLY',            (1, 0, 0) ),
        ( 'WAITING_FOR_REPLY.reply.fget', (1, 0, 0) ),
        ( 'WAITING_FOR_REPLY.reqid.fget', (1, 0, 0) ),
        ( 'WAITING_FOR_REPLY.run',        (1, 0, 0) ),

    )

}

Test_api = verify_api(bcs, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

class MockConnection(object):
    def __init__(self, to_pop=None): self._to_pop = to_pop

    def _connect_async(self): raise gen.Return("_connect_async")
    def _wait_for_ack(self): raise gen.Return("_wait_for_ack")
    def _handle_messages(self): raise gen.Return("_handle_messages")
    def _transition(self, arg): raise gen.Return(("_transition", arg))
    def _transition_to_disconnected(self): raise gen.Return("_transition_to_disconnected")
    def _next(self): raise gen.Return("_next")

Beispiel #36

Datei: test_util.py Projekt: yuanhsin8311/Python-BokehServer

import bokeh.io.util as biu

#-----------------------------------------------------------------------------
# API Definition
#-----------------------------------------------------------------------------

api = {
    PUBLIC: (),
    INTERNAL: (
        ('default_filename', (1, 0, 0)),
        ('detect_current_filename', (1, 0, 0)),
        ('temp_filename', (1, 0, 0)),
    )
}

Test_api = verify_api(biu, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Public API
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Internal API
#-----------------------------------------------------------------------------


def test_detect_current_filename():

Beispiel #37

        ('ClientSession.connected.fget', (1, 0, 0)),
        ('ClientSession.document.fget', (1, 0, 0)),
        ('ClientSession.id.fget', (1, 0, 0)),
        ('ClientSession.connect', (1, 0, 0)),
        ('ClientSession.close', (1, 0, 0)),
        ('ClientSession.force_roundtrip', (1, 0, 0)),
        ('ClientSession.loop_until_closed', (1, 0, 0)),
        ('ClientSession.pull', (1, 0, 0)),
        ('ClientSession.push', (1, 0, 0)),
        ('ClientSession.request_server_info', (1, 0, 0)),
        ('ClientSession.show', (1, 0, 0)),
    ),
    DEV: ()
}

Test_api = verify_api(bcs, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# General API
#-----------------------------------------------------------------------------


def test_module_docstring_warning():
    assert bcs._BOKEH_CLIENT_APP_WARNING_BODY in bcs.__doc__


def test_DEFAULT_SESSION_ID():

Beispiel #38

from bokeh.application.application import Application
from bokeh.io.doc import curdoc
from bokeh.io.output import output_notebook
from bokeh.io.state import curstate, State
from bokeh.models.plots import Plot

# Module under test
import bokeh.io.showing as bis

#-----------------------------------------------------------------------------
# API Definition
#-----------------------------------------------------------------------------

api = {PUBLIC: (('show', (1, 0, 0)), ), INTERNAL: ()}

Test_api = verify_api(bis, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Public API
#-----------------------------------------------------------------------------


@patch('bokeh.io.showing._show_with_state')
def test_show_with_default_args(mock__show_with_state):
    curstate().reset()
    default_kwargs = dict(browser=None, new="tab", notebook_handle=False)
    p = Plot()

Beispiel #39

        ( 'CommsHandle.comms.fget', (1, 0, 0) ),
        ( 'CommsHandle.doc.fget',   (1, 0, 0) ),
        ( 'destroy_server',         (1, 0, 0) ),
        ( 'get_comms',              (1, 0, 0) ),
        ( 'install_jupyter_hooks',  (1, 0, 0) ),
        ( 'load_notebook',          (1, 0, 0) ),
        ( 'publish_display_data',   (1, 0, 0) ),
        ( 'show_app',               (1, 0, 0) ),
        ( 'show_doc',               (1, 0, 0) ),

    )

}

Test_api = verify_api(binb, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# General API
#-----------------------------------------------------------------------------

def test_install_notebook_hook():
    binb.install_notebook_hook("foo", "load", "doc", "app")
    assert binb._HOOKS["foo"]['load'] == "load"
    assert binb._HOOKS["foo"]['doc'] == "doc"
    assert binb._HOOKS["foo"]['app'] == "app"
    with pytest.raises(RuntimeError):

Beispiel #40

Datei: test_driving.py Projekt: yuanhsin8311/Python-BokehServer

        ( 'bounce', (1, 0, 0) ),
        ( 'cosine', (1, 0, 0) ),
        ( 'count',  (1, 0, 0) ),
        ( 'force',  (1, 0, 0) ),
        ( 'linear', (1, 0, 0) ),
        ( 'repeat', (1, 0, 0) ),
        ( 'sine',   (1, 0, 0) ),

    ), INTERNAL: (

    )

}

Test_api = verify_api(bd, api)


#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

ALL = (
    'bounce',
    'cosine',
    'count',
    'force',
    'linear',
    'repeat',
    'sine',
)

Beispiel #41

Datei: test_websocket.py Projekt: FourtekIT-incubator/bokeh

api = {

    GENERAL: (

    ), DEV: (

        ( 'WebSocketClientConnectionWrapper',               (1, 0, 0) ),
        ( 'WebSocketClientConnectionWrapper.write_message', (1, 0, 0) ),
        ( 'WebSocketClientConnectionWrapper.close',         (1, 0, 0) ),
        ( 'WebSocketClientConnectionWrapper.read_message',  (1, 0, 0) ),

    )

}

Test_api = verify_api(bcw, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# General API
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Dev API
#-----------------------------------------------------------------------------

class Test_WebSocketClientConnectionWrapper(object):

Beispiel #42

api = {
    GENERAL: (
        ('export_png', (1, 0, 0)),
        ('export_svgs', (1, 0, 0)),
    ),
    DEV: (
        ('get_screenshot_as_png', (1, 0, 0)),
        ('get_svgs', (1, 0, 0)),
        ('save_layout_html', (1, 0, 0)),
        ('wait_until_render_complete', (1, 0, 0)),
        ('terminate_web_driver', (1, 0, 0)),
    ),
}

Test_api = verify_api(bie, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# General API
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Dev API
#-----------------------------------------------------------------------------


@pytest.mark.unit

Beispiel #43

Datei: test_notebook.py Projekt: FourtekIT-incubator/bokeh

# API Definition
#-----------------------------------------------------------------------------

api = {

    GENERAL: (

    ), DEV: (

        ( 'notebook_content', (1,0,0) ),

    )

}

Test_api = verify_api(ben, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

@pytest.fixture
def test_plot():
    from bokeh.plotting import figure
    test_plot = figure()
    test_plot.circle([1, 2], [2, 3])
    return test_plot

#-----------------------------------------------------------------------------
# General API
#-----------------------------------------------------------------------------

Beispiel #44

import bokeh.colors.util as bcu

#-----------------------------------------------------------------------------
# API Definition
#-----------------------------------------------------------------------------

api = {
    GENERAL: (),
    DEV: (
        ('ColorGroup', (1, 0, 0)),
        ('NamedColor', (1, 0, 0)),
        ('NamedColor.to_css', (1, 0, 0)),
    )
}

Test_api = verify_api(bcu, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------


class _TestGroup(bcu.ColorGroup):
    _colors = ("Red", "Green", "Blue")


#-----------------------------------------------------------------------------
# General API
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------

Beispiel #45

Datei: test_output.py Projekt: william27wp/python-udemy

import bokeh.io.output as bio

#-----------------------------------------------------------------------------
# API Definition
#-----------------------------------------------------------------------------

api = {
    GENERAL: (
        ('output_file', (1, 0, 0)),
        ('output_notebook', (1, 0, 0)),
        ('reset_output', (1, 0, 0)),
    ),
    DEV: ()
}

Test_api = verify_api(bio, api)

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# General API
#-----------------------------------------------------------------------------


class Test_output_file(object):
    @patch('bokeh.io.state.State.output_file')
    def test_no_args(self, mock_output_file):
        default_kwargs = dict(title="Bokeh Plot", mode="cdn", root_dir=None)
        bio.output_file("foo.html")