def _tag(value):
     if isinstance(value, CheckerSessionObject):
         return {" ch": dict((k, _tag(v)) for k, v in iteritems(value))}
     elif isinstance(value, MeansTest):
         return {" mt": dict((k, _tag(v)) for k, v in iteritems(value))}
     elif isinstance(value, tuple):
         return {" t": [_tag(x) for x in value]}
     elif isinstance(value, uuid.UUID):
         return {" u": value.hex}
     elif isinstance(value, bytes):
         return {" b": b64encode(value).decode("ascii")}
     elif callable(getattr(value, "__html__", None)):
         return {" m": text_type(value.__html__())}
     elif isinstance(value, list):
         return [_tag(x) for x in value]
     elif isinstance(value, datetime):
         return {" d": http_date(value)}
     elif isinstance(value, dict):
         return dict((k, _tag(v)) for k, v in iteritems(value))
     elif isinstance(value, str):
         try:
             return text_type(value)
         except UnicodeError:
             raise UnexpectedUnicodeError(
                 u"A byte string with "
                 u"non-ASCII data was passed to the session system "
                 u"which can only store unicode strings.  Consider "
                 u"base64 encoding your string (String was %r)" % value
             )
     return value
Exemple #2
0
 def _tag(value):
     if isinstance(value, CheckerSessionObject):
         return {" ch": dict((k, _tag(v)) for k, v in iteritems(value))}
     elif isinstance(value, MeansTest):
         return {" mt": dict((k, _tag(v)) for k, v in iteritems(value))}
     elif isinstance(value, tuple):
         return {" t": [_tag(x) for x in value]}
     elif isinstance(value, uuid.UUID):
         return {" u": value.hex}
     elif isinstance(value, bytes):
         return {" b": b64encode(value).decode("ascii")}
     elif callable(getattr(value, "__html__", None)):
         return {" m": text_type(value.__html__())}
     elif isinstance(value, list):
         return [_tag(x) for x in value]
     elif isinstance(value, datetime):
         return {" d": http_date(value)}
     elif isinstance(value, dict):
         return dict((k, _tag(v)) for k, v in iteritems(value))
     elif isinstance(value, str):
         try:
             return text_type(value)
         except UnicodeError:
             raise UnexpectedUnicodeError(
                 u"A byte string with "
                 u"non-ASCII data was passed to the session system "
                 u"which can only store unicode strings.  Consider "
                 u"base64 encoding your string (String was %r)" % value)
     return value
Exemple #3
0
 def get_namespace(self, namespace, lowercase=True, trim_namespace=True):
     """Returns a dictionary containing a subset of configuration options
     that match the specified namespace/prefix. Example usage::
         app.config['IMAGE_STORE_TYPE'] = 'fs'
         app.config['IMAGE_STORE_PATH'] = '/var/app/images'
         app.config['IMAGE_STORE_BASE_URL'] = 'http://img.website.com'
         image_store_config = app.config.get_namespace('IMAGE_STORE_')
     The resulting dictionary `image_store` would look like::
         {
             'type': 'fs',
             'path': '/var/app/images',
             'base_url': 'http://img.website.com'
         }
     This is often useful when configuration options map directly to
     keyword arguments in functions or class constructors.
     :param namespace: a configuration namespace
     :param lowercase: a flag indicating if the keys of the resulting
                       dictionary should be lowercase
     :param trim_namespace: a flag indicating if the keys of the resulting
                       dictionary should not include the namespace
     .. versionadded:: 1.0
     """
     rv = {}
     for k, v in iteritems(self):
         if not k.startswith(namespace):
             continue
         if trim_namespace:
             key = k[len(namespace):]
         else:
             key = k
         if lowercase:
             key = key.lower()
         rv[key] = v
     return rv
    def merge_branches(self, dictionary, sep='_'):
        '''Merge the branches where a key has only one value.
        This resolves the problem of getting a plain dictionary
        with any key containing the 'sep' element.

        Parameters
        ----------
        dictionary: dict
            dictionary for which we want to merge branches
        sep: string, optional
            string used to merge the key and the value of the
            elements of a dictionary in different layers.
            Default is '_'.

        Returns
        -------
        new_dict: dict
            a new dictionary with the branches merged

        '''

        for k, v in iteritems(dictionary):
            if isinstance(v, dict):
                if len(dictionary.keys()) == 1:
                    for vkey in v.keys():
                        dictionary[k + sep + vkey] = v[vkey]
                    dictionary.pop(k)

                self.merge_branches(v)

        return dictionary
Exemple #5
0
 def get_namespace(self, namespace, lowercase=True, trim_namespace=True):
     """Returns a dictionary containing a subset of configuration options
     that match the specified namespace/prefix. Example usage::
         app.config['IMAGE_STORE_TYPE'] = 'fs'
         app.config['IMAGE_STORE_PATH'] = '/var/app/images'
         app.config['IMAGE_STORE_BASE_URL'] = 'http://img.website.com'
         image_store_config = app.config.get_namespace('IMAGE_STORE_')
     The resulting dictionary `image_store` would look like::
         {
             'type': 'fs',
             'path': '/var/app/images',
             'base_url': 'http://img.website.com'
         }
     This is often useful when configuration options map directly to
     keyword arguments in functions or class constructors.
     :param namespace: a configuration namespace
     :param lowercase: a flag indicating if the keys of the resulting
                       dictionary should be lowercase
     :param trim_namespace: a flag indicating if the keys of the resulting
                       dictionary should not include the namespace
     .. versionadded:: 1.0
     """
     rv = {}
     for k, v in iteritems(self):
         if not k.startswith(namespace):
             continue
         if trim_namespace:
             key = k[len(namespace):]
         else:
             key = k
         if lowercase:
             key = key.lower()
         rv[key] = v
     return rv
    def get_namespace(self, namespace, lowercase=True, trim_namespace=True):
        """根据字符串返回和前缀相符合的Flask选项。

        示例用法:
        >>> app.config['IMAGE_STORE_TYPE'] = 'fs'
        >>> app.config['IMAGE_STORE_PATH'] = '/var/app/images'
        >>> app.config['IMAGE_STORE_BASE_URL'] = 'http://img.website.com'
        >>> image_store_config = app.config.get_namespace('IMAGE_STORE_')

        结果字典`image_store`看上去像这样:
            {
                'type': 'fs',
                'path': '/var/app/images',
                'base_url': 'http://img.website.com'
            }
        当需要根据配置的参数,渲染为作为函数或类的传入参数时,这个方法
        十分不错。

        :param namespace: 配置的namespace
        :param lowercase: 选项是否转为小写的
        :param trim_namespace: 是否去除选项中的空格
        """
        rv = {}
        for k, v in iteritems(self):
            if not k.startswith(namespace):
                continue
            if trim_namespace:
                key = k[len(namespace) :]
            else:
                key = k
            if lowercase:
                key = key.lower()
            rv[key] = v
        return rv
Exemple #7
0
 def list_templates(self):
     res = []
     ctx = _request_ctx_stack.top
     for ident, theme in iteritems(ctx.app.theme_manager.themes):
         res.extend('_themes/%s/%s' % (ident, t)
                    for t in theme.jinja_loader.list_templates())
     return res
Exemple #8
0
 def _iter_app_blueprint_loaders(self):
     for name, blueprint in iteritems(self.app.blueprints):
         if name in self.app.feature_blueprint_names:
             continue
         loader = blueprint.jinja_loader
         if loader is not None:
             yield loader
Exemple #9
0
 def get_namespace(self, namespace, lowercase=True, trim_namespace=True):
     """获取命名空间"""
     rv = {}
     for k, v in iteritems(self):
         if not k.startswith(namespace):
             continue
         if trim_namespace:
             key = k[len(namespace):]
         else:
             key = k
         if lowercase:
             key = key.lower()
         rv[key] = v
     return rv
Exemple #10
0
    def _get_environment(self, env, config):
        """Return a dictionary containing the top level values updated with
        those from the environment.

        :param env: The name of the environment as a string
        :param config: the configuration mapping
        :return: a dictionary
        """
        # Get the top level keys
        defaults = {k: v for k, v in iteritems(config) if k != 'environments'}

        try:
            defaults.update(config['environments'][env])
            return defaults
        except KeyError as e:
            msg = 'Unable to find %s environment in configuration file' % env
            raise ConfigError(msg)
Exemple #11
0
    def _get_environment(self, env, config):
        """Return a dictionary containing the top level values updated with
        those from the environment.

        :param env: The name of the environment as a string
        :param config: the configuration mapping
        :return: a dictionary
        """
        # Get the top level keys
        defaults = {k: v for k, v in iteritems(config) if k != 'environments'}

        try:
            defaults.update(config['environments'][env])
            return defaults
        except KeyError as e:
            msg = 'Unable to find %s environment in configuration file' % env
            raise ConfigError(msg)
Exemple #12
0
def find_best_app(module):
    """Given a module instance this tries to find the best possible
    application in the module or raises an exception.
    """
    from . import Flask

    # Search for the most common names first.
    for attr_name in 'app', 'application':
        app = getattr(module, attr_name, None)
        if app is not None and isinstance(app, Flask):
            return app

    # Otherwise find the only object that is a Flask instance.
    matches = [v for k, v in iteritems(module.__dict__)
               if isinstance(v, Flask)]

    if len(matches) == 1:
        return matches[0]
    raise NoAppException('Failed to find application in module "%s".  Are '
                         'you sure it contains a Flask application?  Maybe '
                         'you wrapped it in a WSGI middleware or you are '
                         'using a factory function.' % module.__name__)
Exemple #13
0
def find_best_app(module):
    """Given a module instance this tries to find the best possible
    application in the module or raises an exception.
    """
    from . import Flask

    # Search for the most common names first.
    for attr_name in 'app', 'application':
        app = getattr(module, attr_name, None)
        if app is not None and isinstance(app, Flask):
            return app

    # Otherwise find the only object that is a Flask instance.
    matches = [
        v for k, v in iteritems(module.__dict__) if isinstance(v, Flask)
    ]

    if len(matches) == 1:
        return matches[0]
    raise NoAppException('Failed to find application in module "%s".  Are '
                         'you sure it contains a Flask application?  Maybe '
                         'you wrapped it in a WSGI middleware or you are '
                         'using a factory function.' % module.__name__)
 def object_hook(obj):
     if len(obj) != 1:
         return obj
     the_key, the_value = next(iteritems(obj))
     if the_key == " t":
         return tuple(the_value)
     elif the_key == " u":
         return uuid.UUID(the_value)
     elif the_key == " b":
         return b64decode(the_value)
     elif the_key == " m":
         return Markup(the_value)
     elif the_key == " d":
         return parse_date(the_value)
     elif the_key == " ch":
         c = CheckerSessionObject()
         c.update(the_value)
         return c
     elif the_key == " mt":
         m = MeansTest()
         m.update(the_value)
         return m
     return obj
    def remove_null_elements(self, dictionary):
        '''This methods removes the null elements of a
        plain dictionary

        Parameters
        ----------
        dictionary: dict
            dictionary for which we want to remove the null elements

        Returns
        -------
        new_dict: dict
            a new dictionary without the null elements

        '''

        new_dict = OrderedDict()

        for k, v in iteritems(dictionary):
            if v != 0.:
                new_dict[k] = dictionary[k]

        return new_dict
 def object_hook(obj):
     if len(obj) != 1:
         return obj
     the_key, the_value = next(iteritems(obj))
     if the_key == " t":
         return tuple(the_value)
     elif the_key == " u":
         return uuid.UUID(the_value)
     elif the_key == " b":
         return b64decode(the_value)
     elif the_key == " m":
         return Markup(the_value)
     elif the_key == " d":
         return parse_date(the_value)
     elif the_key == " ch":
         c = CheckerSessionObject()
         c.update(the_value)
         return c
     elif the_key == " mt":
         m = MeansTest()
         m.update(the_value)
         return m
     return obj
Exemple #17
0
 def to_json(self, value):
     # JSON objects may only have string keys, so don't bother tagging the
     # key here.
     return dict((k, self.serializer.tag(v)) for k, v in iteritems(value))
Exemple #18
0
 def to_json(self, value):
     # JSON objects may only have string keys, so don't bother tagging the
     # key here.
     return dict((k, self.serializer.tag(v)) for k, v in iteritems(value))
    def plot_nested_pie(self,
                        dictionary,
                        ax=None,
                        radius=1.,
                        delta=0.2,
                        dontlabel=None,
                        breakdonut=True,
                        metric='energy use',
                        units='kW*h'):
        '''This method appends a pie plot from a nested dictionary
        to an axes of matplotlib object. If all the elements
        of the dictionary are float values it will make a simple
        pie plot with those values. If there are other nested
        dictionaries it will continue plotting them in a nested
        pie plot.

        Parameters
        ----------
        dictionary: dict
            dictionary containing other dictionaries and/or
            float numbers for which the pie plot is going to be
            created.
        ax: matplotlib axes object, optional
            axes object where the plot is going to be appended.
            Default is None.
        radius: float, optional
            radius of the outer layer of the pie plot.
            Default is 1.
        delta: float, optional
            desired difference between the radius of two
            consecutive pie plot layers.
            Default is 0.2.
        dontlabel: list, optional
            list of items to not be labeled for more clarity.
            Default is None.
        breakdonut: boolean, optional
            if true it will not show the non labeled slices.
            Default is True.
        metric: string, optional
            indicates the metric that is being plotted. Notice that
            this is only used for the title of the plot.
            Default is 'energy use'.
        units: string, optional
            indicates the units used for the metric. Notice that
            this is only used for the title of the plot.
            Default is 'kW*h'.

        '''

        # Initialize the pie plot if not initialized yet
        if ax is None:
            _, ax = plt.subplots()
        if dontlabel is None:
            dontlabel = []
        # Get the color map to be used in this pie
        cmap = plt.get_cmap('rainbow')
        labels = []
        # Parse the color indexes to be used in this pie
        color_indexes = self.parse_color_indexes(dictionary)
        # Initialize the color indexes to be used in this layer
        cindexes_layer = [0]
        # Initialize the list of values to plot in this layer
        vals = []
        # Initialize a new dictionary for the next inner layer
        new_dict = OrderedDict()
        # Initialize the shifts for the required indices
        shift = np.zeros(len(dictionary.keys()))
        # Initialize a counter for the loop
        i = 0
        # Go through every component in this layer
        for k_outer, v_outer in iteritems(dictionary):
            # Calculate the slice size of this component
            vals.append(self.sum_dict(v_outer))
            # Append the new label if not end point (if not in dontlabel)
            last_key = k_outer.split('__')[-1]
            label = last_key if not any(k_outer.startswith(dntlbl) \
                                        for dntlbl in dontlabel) else ''
            labels.append(label)
            # Check if this component has nested dictionaries
            if isinstance(v_outer, dict):
                # If it has, add them to the new dictionary
                for k_inner, v_inner in iteritems(v_outer):
                    # Give a unique nested key name to it
                    new_dict[k_outer + '__' + k_inner] = v_inner
            # Check if this component is already a float end point
            elif isinstance(v_outer, float):
                # If it is, add it to the new dictionary
                new_dict[k_outer] = v_outer
            # Count the number of elements in this component
            n = self.count_elements(v_outer)
            # Append the index of this component according to its
            # number of components in order to follow a progressive
            # chromatic circle
            cindexes_layer.append(cindexes_layer[-1] + n)
            # Make a shift if this is not an end point to do not use
            # the same color as the underlying end points. Make this
            # shift something characteristic of this layer by making
            # use of its radius
            shift[i] = 0 if n == 1 else 60 * radius
            # Do not label this slice in the next layer if this was
            # already an end point or a null slice
            if n == 1:
                dontlabel.append(k_outer)
            # Increase counter
            i += 1

        # Assign the colors to every component in this layer
        colors = cmap((color_indexes[[cindexes_layer[:-1]]] + \
                       shift).astype(int))

        # If breakdonut=True show a blank in the unlabeled items
        if breakdonut:
            for j, l in enumerate(labels):
                if l is '': colors[j] = [0., 0., 0., 0.]

        # Append the obtained slice values of this layer to the axes
        ax.pie(np.array(vals),
               radius=radius,
               labels=labels,
               labeldistance=radius,
               colors=colors,
               wedgeprops=dict(width=0.2, edgecolor='w', linewidth=0.3))

        # Keep nesting if there is still any dictionary between the values
        if not all(isinstance(v, float) for v in dictionary.values()):
            self.plot_nested_pie(new_dict,
                                 ax,
                                 radius=radius - delta,
                                 dontlabel=dontlabel,
                                 metric=metric,
                                 units=units)

        # Don't continue nesting if all components were float end points
        else:
            plt.title('Total {metric} = {value:.2f} {units}'.format(\
                metric=metric, value=self.sum_dict(dictionary), units=units))
            # Equal aspect ratio ensures that pie is drawn as a circle
            ax.axis('equal')
            plt.show()
 def serialize_dict(self, value):
     return dict((k, self.checkTag(v)) for k, v in iteritems(value))
 def serialize_means_test(self, value):
     return {
         " mt": dict((k, self.checkTag(v)) for k, v in iteritems(value))
     }
 def serialize_checker_session_object(self, value):
     return {
         " ch": dict((k, self.checkTag(v)) for k, v in iteritems(value))
     }
Exemple #23
0
 def load_config(self):
     config = dict([(key, value) for key, value in iteritems(self.options)
                    if key in self.cfg.settings and value is not None])
     for key, value in iteritems(config):
         self.cfg.set(key.lower(), value)