Python properties.value方法代码示例

# 需要导入模块: from bokeh.core import properties [as 别名]
# 或者: from bokeh.core.properties import value [as 别名]
def _postprocess_hover(self, renderer, source):
        """
        Attaches renderer to hover tool and processes tooltips to
        ensure datetime data is displayed correctly.
        """
        hover = self.handles.get('hover')
        if hover is None:
            return
        if not isinstance(hover.tooltips, util.basestring) and 'hv_created' in hover.tags:
            for k, values in source.data.items():
                key = '@{%s}' % k
                if key in hover.formatters:
                    continue
                if ((isinstance(value, np.ndarray) and value.dtype.kind == 'M') or
                    (len(values) and isinstance(values[0], util.datetime_types))):
                    hover.tooltips = [(l, f+'{%F %T}' if f == key else f) for l, f in hover.tooltips]
                    hover.formatters[key] = "datetime"
        if hover.renderers == 'auto':
            hover.renderers = []
        hover.renderers.append(renderer) 

# 需要导入模块: from bokeh.core import properties [as 别名]
# 或者: from bokeh.core.properties import value [as 别名]
def _title_properties(self, key, plot, element):
        if self.show_title and self.adjoined is None:
            title = self._format_title(key, separator=' ')
        else:
            title = ''
        opts = dict(text=title)

        # this will override theme if not set to the default 12pt
        title_font = self._fontsize('title').get('fontsize')
        if title_font != '12pt':
            opts['text_font_size'] = value(title_font)
        return opts 

# 需要导入模块: from bokeh.core import properties [as 别名]
# 或者: from bokeh.core.properties import value [as 别名]
def _update_range(self, axis_range, low, high, factors, invert, shared, log, streaming=False):
        if isinstance(axis_range, (Range1d, DataRange1d)) and self.apply_ranges:
            if isinstance(low, util.cftime_types):
                pass
            elif (low == high and low is not None):
                if isinstance(low, util.datetime_types):
                    offset = np.timedelta64(500, 'ms')
                    low, high = np.datetime64(low), np.datetime64(high)
                    low -= offset
                    high += offset
                else:
                    offset = abs(low*0.1 if low else 0.5)
                    low -= offset
                    high += offset
            if shared:
                shared = (axis_range.start, axis_range.end)
                low, high = util.max_range([(low, high), shared])
            if invert: low, high = high, low
            if not isinstance(low, util.datetime_types) and log and (low is None or low <= 0):
                low = 0.01 if high < 0.01 else 10**(np.log10(high)-2)
                self.param.warning(
                    "Logarithmic axis range encountered value less "
                    "than or equal to zero, please supply explicit "
                    "lower-bound to override default of %.3f." % low)
            updates = {}
            if util.isfinite(low):
                updates['start'] = (axis_range.start, low)
                updates['reset_start'] = updates['start']
            if util.isfinite(high):
                updates['end'] = (axis_range.end, high)
                updates['reset_end'] = updates['end']
            for k, (old, new) in updates.items():
                if isinstance(new, util.cftime_types):
                    new = date_to_integer(new)
                axis_range.update(**{k:new})
                if streaming and not k.startswith('reset_'):
                    axis_range.trigger(k, old, new)
        elif isinstance(axis_range, FactorRange):
            factors = list(decode_bytes(factors))
            if invert: factors = factors[::-1]
            axis_range.factors = factors 

# 需要导入模块: from bokeh.core import properties [as 别名]
# 或者: from bokeh.core.properties import value [as 别名]
def get_first_value(name, field):
    return catalog[name][field][0]['value'] if field in catalog[
        name] and catalog[name][field] else '' 

# 需要导入模块: from bokeh.core import properties [as 别名]
# 或者: from bokeh.core.properties import value [as 别名]
def _create_events_table() -> DataTable:
    """Utility function for creating and styling the events table."""
    formatter = HTMLTemplateFormatter(
        template="""
    <style>
        .AS_POS {color: #0000FF; font-weight: bold;}
        .AS_NEG {color: #0000FF; font-weight: bold;}
        .OP_POS {color: #1aaa0d; font-style: bold;}
        .OP_NEG {color: #f40000;font-style: bold;}
        .NEG_POS {font-style: italic;}
        .NEG_NEG {color: #f40000; font-style: italic;}
        .INT_POS {color: #1aaa0d; font-style: italic;}
        .INT_NEG {color: #f40000; font-style: italic;}
    </style>
    <%= value %>"""
    )
    columns = [
        TableColumn(field="POS_events", title="Positive Examples", formatter=formatter),
        TableColumn(field="NEG_events", title="Negative Examples", formatter=formatter),
    ]
    return DataTable(
        source=ColumnDataSource(),
        columns=columns,
        height=400,
        index_position=None,
        width=2110,
        sortable=False,
        editable=True,
        reorderable=False,
    ) 

# 需要导入模块: from bokeh.core import properties [as 别名]
# 或者: from bokeh.core.properties import value [as 别名]
def _ui_format(sent: SentimentSentence, doc: SentimentDoc) -> str:
    """Get sentence as HTML with 4 classes: aspects, opinions, negations and intensifiers."""
    text = doc.doc_text[sent.start : sent.end + 1]
    seen = set()
    for term in sorted([t for e in sent.events for t in e], key=lambda t: t.start)[::-1]:
        if term.start not in seen:
            seen.add(term.start)
            start = term.start - sent.start
            end = start + term.len
            label = term.type.value + "_" + term.polarity.value
            text = "".join(
                (text[:start], '<span class="', label, '">', text[start:end], "</span>", text[end:])
            )
    return text 

# 需要导入模块: from bokeh.core import properties [as 别名]
# 或者: from bokeh.core.properties import value [as 别名]
def _create_examples_table() -> DataTable:
    """Utility function for creating and styling the events table."""

    formatter = HTMLTemplateFormatter(
        template="""
    <style>
        .AS {color: #0000FF; font-weight: bold;}
        .OP {color: #0000FF; font-weight: bold;}
    </style>
    <div><%= value %></div>"""
    )
    columns = [
        TableColumn(
            field="Examples", title='<span class="header">Examples</span>', formatter=formatter
        )
    ]
    empty_source = ColumnDataSource()
    empty_source.data = {"Examples": []}
    return DataTable(
        source=empty_source,
        columns=columns,
        height=500,
        index_position=None,
        width=1500,
        sortable=False,
        editable=False,
        reorderable=False,
        header_row=True,
    ) 

# 需要导入模块: from bokeh.core import properties [as 别名]
# 或者: from bokeh.core.properties import value [as 别名]
def _create_plot() -> (Figure, ColumnDataSource):
    """Utility function for creating and styling the bar plot."""
    global source, aspects, stats
    pos_counts, neg_counts = (
        [stats.loc[(asp, pol, False), "Quantity"] for asp in aspects] for pol in POLARITIES
    )
    np.seterr(divide="ignore")
    source = ColumnDataSource(
        data={
            "aspects": aspects,
            "POS": pos_counts,
            "NEG": neg_counts,
            "log-POS": np.log2(pos_counts),
            "log-NEG": np.log2(neg_counts),
        }
    )
    np.seterr(divide="warn")
    p = figure(
        plot_height=145,
        sizing_mode="scale_width",
        x_range=aspects,
        toolbar_location="right",
        tools="save, tap",
    )
    rs = [
        p.vbar(
            x=dodge("aspects", -0.207, range=p.x_range),
            top="log-POS",
            width=0.4,
            source=source,
            color="limegreen",
            legend=value("POS"),
            name="POS",
        ),
        p.vbar(
            x=dodge("aspects", 0.207, range=p.x_range),
            top="log-NEG",
            width=0.4,
            source=source,
            color="orangered",
            legend=value("NEG"),
            name="NEG",
        ),
    ]
    for r in rs:
        p.add_tools(
            HoverTool(tooltips=[("Aspect", "@aspects"), (r.name, "@" + r.name)], renderers=[r])
        )
    p.add_layout(
        Title(text=" " * 7 + "Sentiment Count (log scale)", align="left", text_font_size="23px"),
        "left",
    )
    p.yaxis.ticker = []
    p.y_range.start = 0
    p.xgrid.grid_line_color = None
    p.xaxis.major_label_text_font_size = "20pt"
    p.legend.label_text_font_size = "20pt"
    return p, source