_load() - Code Metrics - Inspection of "refactor: split a bit complex functions, .backend...." - ssato/python-anyconfig - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 613b11...22be07 )

by Satoru

created 2017-02-12 05:00 UTC

_load() B

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	2	Features	0

Metric	Value
cc	6
dl	0
loc	27
rs	7.5384
c	2
b	2
f	0

#
# Copyright (C) 2011 - 2017 Satoru SATOH <ssato @ redhat.com>
# License: MIT
#
#  pylint: disable=unused-argument
"""INI or INI like config files backend.

- Format to support: INI or INI like ones
- Requirements: It should be available always.

  - ConfigParser in python 2 standard library:
    https://docs.python.org/2.7/library/configparser.html

  - configparser in python 3 standard library:
    https://docs.python.org/3/library/configparser.html

- Development Status :: 4 - Beta
- Limitations: It cannot process nested configuration dicts correctly due to
  the limitation of configparser module.

- Special options:

  - Use 'ac_parse_value' boolean keyword option if you want to parse values by
    custom parser, anyconfig.backend.ini._parse.

History:

.. versionchanged:: 0.3
   Introduce 'ac_parse_value' keyword option to switch behaviors, same as
   original configparser and rich backend parsing each parameter values.
"""
from __future__ import absolute_import

import anyconfig.backend.base
import anyconfig.parser as P
import anyconfig.utils

from anyconfig.compat import configparser, iteritems, OrderedDict
from anyconfig.backend.base import mk_opt_args


_SEP = ','


def _noop(val, *args, **kwargs):
    """
    Parser does nothing.
    """
    # It means nothing but can suppress 'Unused argument' pylint warns.
    # (val, args, kwargs)[0]
    return val


def _parse(val_s, sep=_SEP):
    """
    FIXME: May be too naive implementation.

    :param val_s: A string represents some value to parse
    :param sep: separator between values

    >>> _parse(r'"foo string"')
    'foo string'
    >>> _parse("a, b, c")
    ['a', 'b', 'c']
    >>> _parse("aaa")
    'aaa'
    """
    if (val_s.startswith('"') and val_s.endswith('"')) or \
            (val_s.startswith("'") and val_s.endswith("'")):
        return val_s[1:-1]
    elif sep in val_s:
        return [P.parse(x) for x in P.parse_list(val_s)]
    else:
        return P.parse(val_s)


def _to_s(val, sep=", "):
    """Convert any to string.

    :param val: An object
    :param sep: separator between values

    >>> _to_s([1, 2, 3])
    '1, 2, 3'
    >>> _to_s("aaa")
    'aaa'
    """
    if anyconfig.utils.is_iterable(val):
        return sep.join(str(x) for x in val)
    else:
        return str(val)


def _make_parser(to_container, **kwargs):
    """
    :param to_container: any callable to make container
    :return: (to_container, keyword args to be used, parser object)
    """
    if kwargs.get("ac_ordered", False) or kwargs.get("dict_type", False):
        kwargs["dict_type"] = to_container = OrderedDict
    if "dict_type" not in kwargs and not kwargs.get("ac_ordered", True):
        kwargs["dict_type"] = to_container

    # Optional arguements for configparser.SafeConfigParser{,readfp}
    kwargs_0 = mk_opt_args(("defaults", "dict_type", "allow_no_value"), kwargs)
    kwargs_1 = mk_opt_args(("filename", ), kwargs)

    try:
        parser = configparser.SafeConfigParser(**kwargs_0)
    except TypeError:
        # .. note::
        #    It seems ConfigPaser.*ConfigParser in python 2.6 does not support
        #    'allow_no_value' option parameter, and TypeError will be thrown.
        kwargs_0 = mk_opt_args(("defaults", "dict_type"), kwargs)
        parser = configparser.SafeConfigParser(**kwargs_0)

    return (to_container, kwargs_1, parser)


def _load(stream, to_container=dict, sep=_SEP, **kwargs):
    """
    :param stream: File or file-like object provides ini-style conf
    :param to_container: any callable to make container
    :param sep: Seprator string

    :return: Dict or dict-like object represents config values
    """
    (to_container, kwargs_1, parser) = _make_parser(to_container, **kwargs)
    _parse_val = _parse if kwargs.get("ac_parse_value", False) else _noop

    cnf = to_container()
    parser.readfp(stream, **kwargs_1)

    # .. note:: Process DEFAULT config parameters as special ones.
    defaults = parser.defaults()
    if defaults:
        cnf["DEFAULT"] = to_container()
        for key, val in iteritems(defaults):
            cnf["DEFAULT"][key] = _parse_val(val, sep)

    for sect in parser.sections():
        cnf[sect] = to_container()
        for key, val in parser.items(sect):
            cnf[sect][key] = _parse_val(val, sep)

    return cnf


def _dumps_itr(cnf):
    """
    :param cnf: Configuration data to dump
    """
    dkey = "DEFAULT"
    for sect, params in iteritems(cnf):
        yield "[%s]" % sect

        for key, val in iteritems(params):
            if sect != dkey and dkey in cnf and cnf[dkey].get(key) == val:
                continue  # It should be in [DEFAULT] section.

            yield "%s = %s" % (key, _to_s(val))

        yield ''  # it will be a separator between each sections.


def _dumps(cnf, **kwargs):
    """
    :param cnf: Configuration data to dump
    :param kwargs: optional keyword parameters to be sanitized :: dict

    :return: String representation of `cnf` object in INI format
    """
    return '\n'.join(l for l in _dumps_itr(cnf))


class Parser(anyconfig.backend.base.FromStreamLoader,
             anyconfig.backend.base.ToStringDumper):
    """
    Ini config files parser.
    """
    _type = "ini"
    _extensions = ["ini"]
    _load_opts = ["defaults", "dict_type", "allow_no_value", "filename",
                  "ac_parse_value"]

    dump_to_string = anyconfig.backend.base.to_method(_dumps)

    def load_from_stream(self, stream, to_container, **options):
        """
        Load config from given file like object `stream`.

        :param stream:  Config file or file like object
        :param to_container: callble to make a container object
        :param options: optional keyword arguments

        :return: Dict-like object holding config parameters
        """
        return _load(stream, to_container=to_container, **options)

# vim:sw=4:ts=4:et:


1			#
2			# Copyright (C) 2011 - 2017 Satoru SATOH <ssato @ redhat.com>
3			# License: MIT
4			#
5			# pylint: disable=unused-argument
6			"""INI or INI like config files backend.
7
8			- Format to support: INI or INI like ones
9			- Requirements: It should be available always.
10
11			- ConfigParser in python 2 standard library:
12			https://docs.python.org/2.7/library/configparser.html
13
14			- configparser in python 3 standard library:
15			https://docs.python.org/3/library/configparser.html
16
17			- Development Status :: 4 - Beta
18			- Limitations: It cannot process nested configuration dicts correctly due to
19			the limitation of configparser module.
20
21			- Special options:
22
23			- Use 'ac_parse_value' boolean keyword option if you want to parse values by
24			custom parser, anyconfig.backend.ini._parse.
25
26			History:
27
28			.. versionchanged:: 0.3
29			Introduce 'ac_parse_value' keyword option to switch behaviors, same as
30			original configparser and rich backend parsing each parameter values.
31			"""
32			from __future__ import absolute_import
33
34			import anyconfig.backend.base
35			import anyconfig.parser as P
36			import anyconfig.utils
37
38			from anyconfig.compat import configparser, iteritems, OrderedDict
39			from anyconfig.backend.base import mk_opt_args
40
41
42			_SEP = ','
43
44
45			def _noop(val, args, *kwargs):
46			"""
47			Parser does nothing.
48			"""
49			# It means nothing but can suppress 'Unused argument' pylint warns.
50			# (val, args, kwargs)[0]
51			return val
52
53
54			def _parse(val_s, sep=_SEP):
55			"""
56			FIXME: May be too naive implementation.
57
58			:param val_s: A string represents some value to parse
59			:param sep: separator between values
60
61			>>> _parse(r'"foo string"')
62			'foo string'
63			>>> _parse("a, b, c")
64			['a', 'b', 'c']
65			>>> _parse("aaa")
66			'aaa'
67			"""
68			if (val_s.startswith('"') and val_s.endswith('"')) or \
69			(val_s.startswith("'") and val_s.endswith("'")):
70			return val_s[1:-1]
71			elif sep in val_s:
72			return [P.parse(x) for x in P.parse_list(val_s)]
73			else:
74			return P.parse(val_s)
75
76
77			def _to_s(val, sep=", "):
78			"""Convert any to string.
79
80			:param val: An object
81			:param sep: separator between values
82
83			>>> _to_s([1, 2, 3])
84			'1, 2, 3'
85			>>> _to_s("aaa")
86			'aaa'
87			"""
88			if anyconfig.utils.is_iterable(val):
89			return sep.join(str(x) for x in val)
90			else:
91			return str(val)
92
93
94			def _make_parser(to_container, **kwargs):
95			"""
96			:param to_container: any callable to make container
97			:return: (to_container, keyword args to be used, parser object)
98			"""
99			if kwargs.get("ac_ordered", False) or kwargs.get("dict_type", False):
100			kwargs["dict_type"] = to_container = OrderedDict
101			if "dict_type" not in kwargs and not kwargs.get("ac_ordered", True):
102			kwargs["dict_type"] = to_container
103
104			# Optional arguements for configparser.SafeConfigParser{,readfp}
105			kwargs_0 = mk_opt_args(("defaults", "dict_type", "allow_no_value"), kwargs)
106			kwargs_1 = mk_opt_args(("filename", ), kwargs)
107
108			try:
109			parser = configparser.SafeConfigParser(**kwargs_0)
110			except TypeError:
111			# .. note::
112			# It seems ConfigPaser.*ConfigParser in python 2.6 does not support
113			# 'allow_no_value' option parameter, and TypeError will be thrown.
114			kwargs_0 = mk_opt_args(("defaults", "dict_type"), kwargs)
115			parser = configparser.SafeConfigParser(**kwargs_0)
116
117			return (to_container, kwargs_1, parser)
118
119
120			def _load(stream, to_container=dict, sep=_SEP, **kwargs):
121			"""
122			:param stream: File or file-like object provides ini-style conf
123			:param to_container: any callable to make container
124			:param sep: Seprator string
125
126			:return: Dict or dict-like object represents config values
127			"""
128			(to_container, kwargs_1, parser) = _make_parser(to_container, **kwargs)
129			_parse_val = _parse if kwargs.get("ac_parse_value", False) else _noop
130
131			cnf = to_container()
132			parser.readfp(stream, **kwargs_1)
133
134			# .. note:: Process DEFAULT config parameters as special ones.
135			defaults = parser.defaults()
136			if defaults:
137			cnf["DEFAULT"] = to_container()
138			for key, val in iteritems(defaults):
139			cnf["DEFAULT"][key] = _parse_val(val, sep)
140
141			for sect in parser.sections():
142			cnf[sect] = to_container()
143			for key, val in parser.items(sect):
144			cnf[sect][key] = _parse_val(val, sep)
145
146			return cnf
147
148
149			def _dumps_itr(cnf):
150			"""
151			:param cnf: Configuration data to dump
152			"""
153			dkey = "DEFAULT"
154			for sect, params in iteritems(cnf):
155			yield "[%s]" % sect
156
157			for key, val in iteritems(params):
158			if sect != dkey and dkey in cnf and cnf[dkey].get(key) == val:
159			continue # It should be in [DEFAULT] section.
160
161			yield "%s = %s" % (key, _to_s(val))
162
163			yield '' # it will be a separator between each sections.
164
165
166			def _dumps(cnf, **kwargs):
167			"""
168			:param cnf: Configuration data to dump
169			:param kwargs: optional keyword parameters to be sanitized :: dict
170
171			:return: String representation of `cnf` object in INI format
172			"""
173			return '\n'.join(l for l in _dumps_itr(cnf))
174
175
176			class Parser(anyconfig.backend.base.FromStreamLoader,
177			anyconfig.backend.base.ToStringDumper):
178			"""
179			Ini config files parser.
180			"""
181			_type = "ini"
182			_extensions = ["ini"]
183			_load_opts = ["defaults", "dict_type", "allow_no_value", "filename",
184			"ac_parse_value"]
185
186			dump_to_string = anyconfig.backend.base.to_method(_dumps)
187
188			def load_from_stream(self, stream, to_container, **options):
189			"""
190			Load config from given file like object `stream`.
191
192			:param stream: Config file or file like object
193			:param to_container: callble to make a container object
194			:param options: optional keyword arguments
195
196			:return: Dict-like object holding config parameters
197			"""
198			return _load(stream, to_container=to_container, **options)
199
200			# vim:sw=4:ts=4:et:
201

ssato / python-anyconfig

Push — master ( 613b11...22be07 )

_load() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like