Python cbook.is_string_like方法代码示例

# 需要导入模块: from matplotlib import cbook [as 别名]
# 或者: from matplotlib.cbook import is_string_like [as 别名]
def error_msg_gtk(msg, parent=None):
    if parent is not None: # find the toplevel gtk.Window
        parent = parent.get_toplevel()
        if parent.flags() & gtk.TOPLEVEL == 0:
            parent = None

    if not is_string_like(msg):
        msg = ','.join(map(str,msg))

    dialog = gtk.MessageDialog(
        parent         = parent,
        type           = gtk.MESSAGE_ERROR,
        buttons        = gtk.BUTTONS_OK,
        message_format = msg)
    dialog.run()
    dialog.destroy() 

# 需要导入模块: from matplotlib import cbook [as 别名]
# 或者: from matplotlib.cbook import is_string_like [as 别名]
def print_png(self, filename_or_obj, *args, **kwargs):
        FigureCanvasAgg.draw(self)
        renderer = self.get_renderer()
        original_dpi = renderer.dpi
        renderer.dpi = self.figure.dpi
        if is_string_like(filename_or_obj):
            filename_or_obj = open(filename_or_obj, 'wb')
            close = True
        else:
            close = False
        try:
            _png.write_png(renderer._renderer.buffer_rgba(),
                           renderer.width, renderer.height,
                           filename_or_obj, self.figure.dpi)
        finally:
            if close:
                filename_or_obj.close()
        renderer.dpi = original_dpi 

# 需要导入模块: from matplotlib import cbook [as 别名]
# 或者: from matplotlib.cbook import is_string_like [as 别名]
def error_msg_gtk(msg, parent=None):
    if parent is not None: # find the toplevel Gtk.Window
        parent = parent.get_toplevel()
        if not parent.is_toplevel():
            parent = None

    if not is_string_like(msg):
        msg = ','.join(map(str,msg))

    dialog = Gtk.MessageDialog(
        parent         = parent,
        type           = Gtk.MessageType.ERROR,
        buttons        = Gtk.ButtonsType.OK,
        message_format = msg)
    dialog.run()
    dialog.destroy() 

# 需要导入模块: from matplotlib import cbook [as 别名]
# 或者: from matplotlib.cbook import is_string_like [as 别名]
def print_pgf(self, fname_or_fh, *args, **kwargs):
        """
        Output pgf commands for drawing the figure so it can be included and
        rendered in latex documents.
        """
        if kwargs.get("dryrun", False):
            self._print_pgf_to_fh(None, *args, **kwargs)
            return

        # figure out where the pgf is to be written to
        if is_string_like(fname_or_fh):
            with codecs.open(fname_or_fh, "w", encoding="utf-8") as fh:
                self._print_pgf_to_fh(fh, *args, **kwargs)
        elif is_writable_file_like(fname_or_fh):
            raise ValueError("saving pgf to a stream is not supported, " +
                             "consider using the pdf option of the pgf-backend")
        else:
            raise ValueError("filename must be a path") 

# 需要导入模块: from matplotlib import cbook [as 别名]
# 或者: from matplotlib.cbook import is_string_like [as 别名]
def print_pdf(self, fname_or_fh, *args, **kwargs):
        """
        Use LaTeX to compile a Pgf generated figure to PDF.
        """
        if kwargs.get("dryrun", False):
            self._print_pgf_to_fh(None, *args, **kwargs)
            return

        # figure out where the pdf is to be written to
        if is_string_like(fname_or_fh):
            with open(fname_or_fh, "wb") as fh:
                self._print_pdf_to_fh(fh, *args, **kwargs)
        elif is_writable_file_like(fname_or_fh):
            self._print_pdf_to_fh(fname_or_fh, *args, **kwargs)
        else:
            raise ValueError("filename must be a path or a file-like object") 

# 需要导入模块: from matplotlib import cbook [as 别名]
# 或者: from matplotlib.cbook import is_string_like [as 别名]
def is_frame_like(self):
        """return True if directly on axes frame

        This is useful for determining if a spine is the edge of an
        old style MPL plot. If so, this function will return True.
        """
        self._ensure_position_is_set()
        position = self._position
        if cbook.is_string_like(position):
            if position == 'center':
                position = ('axes', 0.5)
            elif position == 'zero':
                position = ('data', 0)
        assert len(position) == 2, "position should be 2-tuple"
        position_type, amount = position
        if position_type == 'outward' and amount == 0:
            return True
        else:
            return False 

# 需要导入模块: from matplotlib import cbook [as 别名]
# 或者: from matplotlib.cbook import is_string_like [as 别名]
def _process_linestyles(self):
        linestyles = self.linestyles
        Nlev = len(self.levels)
        if linestyles is None:
            tlinestyles = ['solid'] * Nlev
            if self.monochrome:
                neg_ls = mpl.rcParams['contour.negative_linestyle']
                eps = - (self.zmax - self.zmin) * 1e-15
                for i, lev in enumerate(self.levels):
                    if lev < eps:
                        tlinestyles[i] = neg_ls
        else:
            if cbook.is_string_like(linestyles):
                tlinestyles = [linestyles] * Nlev
            elif cbook.iterable(linestyles):
                tlinestyles = list(linestyles)
                if len(tlinestyles) < Nlev:
                    nreps = int(np.ceil(Nlev / len(linestyles)))
                    tlinestyles = tlinestyles * nreps
                if len(tlinestyles) > Nlev:
                    tlinestyles = tlinestyles[:Nlev]
            else:
                raise ValueError("Unrecognized type for linestyles kwarg")
        return tlinestyles 

# 需要导入模块: from matplotlib import cbook [as 别名]
# 或者: from matplotlib.cbook import is_string_like [as 别名]
def from_any(size, fraction_ref=None):
    """
    Creates Fixed unit when the first argument is a float, or a
    Fraction unit if that is a string that ends with %. The second
    argument is only meaningful when Fraction unit is created.::

      >>> a = Size.from_any(1.2) # => Size.Fixed(1.2)
      >>> Size.from_any("50%", a) # => Size.Fraction(0.5, a)

    """
    if cbook.is_numlike(size):
        return Fixed(size)
    elif cbook.is_string_like(size):
        if size[-1] == "%":
            return Fraction(float(size[:-1])/100., fraction_ref)

    raise ValueError("Unknown format") 

# 需要导入模块: from matplotlib import cbook [as 别名]
# 或者: from matplotlib.cbook import is_string_like [as 别名]
def safe_isnan(x):
    ':func:`numpy.isnan` for arbitrary types'
    if cbook.is_string_like(x):
        return False
    try: b = np.isnan(x)
    except NotImplementedError: return False
    except TypeError: return False
    else: return b 

# 需要导入模块: from matplotlib import cbook [as 别名]
# 或者: from matplotlib.cbook import is_string_like [as 别名]
def safe_isinf(x):
    ':func:`numpy.isinf` for arbitrary types'
    if cbook.is_string_like(x):
        return False
    try: b = np.isinf(x)
    except NotImplementedError: return False
    except TypeError: return False
    else: return b 

# 需要导入模块: from matplotlib import cbook [as 别名]
# 或者: from matplotlib.cbook import is_string_like [as 别名]
def rec_append_fields(rec, names, arrs, dtypes=None):
    """
    Return a new record array with field names populated with data
    from arrays in *arrs*.  If appending a single field, then *names*,
    *arrs* and *dtypes* do not have to be lists. They can just be the
    values themselves.
    """
    if (not cbook.is_string_like(names) and cbook.iterable(names) \
            and len(names) and cbook.is_string_like(names[0])):
        if len(names) != len(arrs):
            raise ValueError("number of arrays do not match number of names")
    else: # we have only 1 name and 1 array
        names = [names]
        arrs = [arrs]
    arrs = map(np.asarray, arrs)
    if dtypes is None:
        dtypes = [a.dtype for a in arrs]
    elif not cbook.iterable(dtypes):
        dtypes = [dtypes]
    if len(arrs) != len(dtypes):
        if len(dtypes) == 1:
            dtypes = dtypes * len(arrs)
        else:
            raise ValueError("dtypes must be None, a single dtype or a list")

    newdtype = np.dtype(rec.dtype.descr + zip(names, dtypes))
    newrec = np.recarray(rec.shape, dtype=newdtype)
    for field in rec.dtype.fields:
        newrec[field] = rec[field]
    for name, arr in zip(names, arrs):
        newrec[name] = arr
    return newrec 

# 需要导入模块: from matplotlib import cbook [as 别名]
# 或者: from matplotlib.cbook import is_string_like [as 别名]
def rec_keep_fields(rec, names):
    """
    Return a new numpy record array with only fields listed in names
    """

    if cbook.is_string_like(names):
        names = names.split(',')

    arrays = []
    for name in names:
        arrays.append(rec[name])

    return np.rec.fromarrays(arrays, names=names) 

# 需要导入模块: from matplotlib import cbook [as 别名]
# 或者: from matplotlib.cbook import is_string_like [as 别名]
def get_family(self):
        """
        Return a list of font names that comprise the font family.
        """
        if self._family is None:
            family = rcParams['font.family']
            if is_string_like(family):
                return [family]
            return family
        return self._family 

# 需要导入模块: from matplotlib import cbook [as 别名]
# 或者: from matplotlib.cbook import is_string_like [as 别名]
def set_family(self, family):
        """
        Change the font family.  May be either an alias (generic name
        is CSS parlance), such as: 'serif', 'sans-serif', 'cursive',
        'fantasy', or 'monospace', a real font name or a list of real
        font names.  Real font names are not supported when
        `text.usetex` is `True`.
        """
        if family is None:
            family = rcParams['font.family']
        if is_string_like(family):
            family = [family]
        self._family = family 

# 需要导入模块: from matplotlib import cbook [as 别名]
# 或者: from matplotlib.cbook import is_string_like [as 别名]
def findfont(prop, fontext='ttf'):
        if not is_string_like(prop):
            prop = prop.get_fontconfig_pattern()
        cached = _fc_match_cache.get(prop)
        if cached is not None:
            return cached

        result = fc_match(prop, fontext)
        if result is None:
            result = fc_match(':', fontext)

        _fc_match_cache[prop] = result
        return result