self.hooks = [hook(config) for hook in hooks.load_all()]

        self.stdout = stdout

    def import_file(self, in_file):

        importers = []

        for importer in self.importers:

            in_file.seek(0)

            if importer.can_import(in_file):

                importers.append(importer)

        if not importers:

            raise errors.UserInputFileError("no importers available", in_file.name)

        with contextlib.ExitStack() as exit_stack:

            output_path = self.config.get_output_path()

            if output_path is None:

                out_file = self.stdout

            else:

                out_file = exit_stack.enter_context(output_path.open('a'))

            for importer in importers:

                template = self.config.get_template(importer.TEMPLATE_KEY)

                default_date = self.config.get_default_date()

                in_file.seek(0)

                for entry_data in importer(in_file):

                    for hook in self.hooks:

                        hook.run(entry_data)

    def import_path(self, in_path):

        if in_path is None:

            raise errors.UserInputFileError("only seekable files are supported", '<stdin>')

        with in_path.open() as in_file:

            if not in_file.seekable():

                raise errors.UserInputFileError("only seekable files are supported", in_path)

            return self.import_file(in_file)

    def import_paths(self, path_seq):

        for in_path in path_seq:

            try:

                retval = self.import_path(in_path)

            except (OSError, errors.UserInputError) as error:

                yield in_path, error

            else:

                yield in_path, retval

def setup_logger(logger, main_config, stream):

    formatter = logging.Formatter('%(name)s: %(levelname)s: %(message)s')

    handler = logging.StreamHandler(stream)

    handler.setFormatter(formatter)

    logger.addHandler(handler)

import argparse

import configparser

import contextlib

import datetime

import locale

import logging

import os.path

import pathlib

import babel

import babel.numbers

from . import errors, template, util

class Configuration:

    HOME_PATH = pathlib.Path(os.path.expanduser('~'))

    DEFAULT_CONFIG_PATH = pathlib.Path(HOME_PATH, '.config', 'import2ledger.ini')

    DEFAULT_ENCODING = locale.getpreferredencoding()

    LOCALE = babel.core.Locale.default()

    TODAY = datetime.date.today()

    CONFIG_DEFAULTS = {

        'date_format': '%%Y/%%m/%%d',

        'loglevel': 'WARNING',

        'output_path': '-',

        'signed_currencies': ','.join(babel.numbers.get_territory_currencies(

            LOCALE.territory, start_date=TODAY)),

        'signed_currency_format': '¤#,##0.###;¤-#,##0.###',

        'unsigned_currency_format': '#,##0.### ¤¤',

    }

    def __init__(self, arglist):

        argparser = self._build_argparser()

        self.error = argparser.error

        self.args = argparser.parse_args(arglist)

        if self.args.config_file is None:

            self.args.config_file = []

            if self.DEFAULT_CONFIG_PATH.exists():

                self.args.config_file.append(self.DEFAULT_CONFIG_PATH)

        self.conffile = self._build_conffile()

        conffile_paths = [path.as_posix() for path in self.args.config_file]

        read_files = self.conffile.read(conffile_paths)

        for expected_path, read_path in zip(conffile_paths, read_files):

            if read_path != expected_path:

                self.error("failed to read configuration file {!r}".format(expected_path))

        self.finalize()

    def _build_argparser(self):

        parser = argparse.ArgumentParser()

        parser.add_argument(

            '--config-file', '-C', metavar='PATH', type=pathlib.Path,

            action='append',

            help="Path of a configuration file to read",

        )

        parser.add_argument(

            '--use-config', '-c', metavar='SECTION',

            help="Read settings from this section of the configuration file",

        )

        parser.add_argument(

            'input_paths', metavar='PATH',

            nargs='+',

            help="Path to generate Ledger entries from.",

        )

        out_args = parser.add_argument_group(

            "default overrides",

            description="These options take priority over settings in the "

            "[DEFAULT] section of your config file, but not other sections.",

        )

        out_args.add_argument(

            '--date', '-d', metavar='DATE',

            help="Date to use in Ledger entries when the source doesn't "

            "provide one. Write this in your configured date format. "

            "Default today.",

        )

        out_args.add_argument(

            '--date-format', '-D', metavar='FORMAT',

            help="Date format to use in Ledger entries",

        )

        out_args.add_argument(

            '--output-path', '-O', metavar='PATH',

            help="Path of file to append entries to, or '-' for stdout (default).",

        )

        out_args.add_argument(

            '--signed-currency', '--sign', metavar='CODE',

            action='append', dest='signed_currencies',

            help="Currency code to use currency sign for in Ledger entry amounts. "

            "Can be specified multiple times.",

        )

        out_args.add_argument(

            '--signed-currency-format', '--sign-format', '-S', metavar='FORMAT',

            help="Unicode number pattern to use for signed currencies in Ledger entry amounts",

        )

        out_args.add_argument(

            '--unsigned-currency-format', '--unsign-format', '-U', metavar='FORMAT',

            help="Unicode number pattern to use for unsigned currencies in Ledger entry amounts",

        )

        return parser

    def _build_conffile(self):

        return configparser.ConfigParser(

            comment_prefixes='#',

            defaults=self.CONFIG_DEFAULTS,

        )

    def _s_to_path(self, s):

        return None if s == '-' else pathlib.Path(s)

    def _strpdate(self, date_s, date_fmt):

        try:

            return util.strpdate(date_s, date_fmt)

        except ValueError as error:

            raise errors.UserInputConfigurationError(error.args[0], date_s)

    def _parse_section_date(self, section_name, default=TODAY):

        section = self.conffile[section_name]

        try:

            return self._strpdate(section['date'], section['date_format'])

        except KeyError:

            return default

    def finalize(self):

        if self.args.use_config is None:

        elif not self.conffile.has_section(self.args.use_config):

            self.error("section {!r} not found in config file".format(self.args.use_config))

        self.args.input_paths = [self._s_to_path(s) for s in self.args.input_paths]

        for key in self.CONFIG_DEFAULTS:

            value = getattr(self.args, key)

            if value is None:

                pass

            elif key == 'signed_currencies':

                defaults[key] = ','.join(value)

            else:

        # We parse all the dates now to make sure they're valid.

        if self.args.date is not None:

            default_date = self._strpdate(self.args.date, defaults['date_format'])

        elif 'date' in defaults:

            default_date = self._strpdate(defaults['date'], defaults['date_format'])

        else:

            default_date = self.TODAY

        self.dates = {secname: self._parse_section_date(secname, default_date)

                      for secname in self.conffile}

    @contextlib.contextmanager

    def from_section(self, section_name):

        prev_section = self.args.use_config

        self.args.use_config = section_name

        try:

            yield self

        finally:

            self.args.use_config = prev_section

    def _get_section(self, section_name):

        if section_name is None:

            section_name = self.args.use_config

        return self.conffile[section_name]

        if section_name is None:

            section_name = self.args.use_config

        try:

        except KeyError:

    def get_loglevel(self, section_name=None):

        section_config = self._get_section(section_name)

        level_name = section_config['loglevel']

        try:

            return getattr(logging, level_name.upper())

        except AttributeError:

            raise errors.UserInputConfigurationError("not a valid loglevel", level_name)

    def get_output_path(self, section_name=None):

        section_config = self._get_section(section_name)

        return self._s_to_path(section_config['output_path'])

    def get_template(self, config_key, section_name=None, factory=template.Template):

        section_config = self._get_section(section_name)

        try:

            template_s = section_config[config_key]

        except KeyError:

            raise errors.UserInputConfigurationError(

                "template not defined in [{}]".format(section_name or self.args.use_config),

                config_key,

            )

        return factory(

            template_s,

import contextlib

import datetime

import logging

import os

import pathlib

START_DATE = datetime.date.today()

from unittest import mock

import pytest

from import2ledger import config, errors

from . import DATA_DIR

def config_from_file(path, arglist=[]):

    path = pathlib.Path(path)

    if not path.is_absolute():

        path = DATA_DIR / path

    arglist = ['-C', path.as_posix(), *arglist, os.devnull]

    return config.Configuration(arglist)

def test_defaults():

    config = config_from_file('test_config.ini', ['--sign', 'GBP', '-O', 'out_arg'])

    factory = mock.Mock(name='Template')

    template = config.get_template('one', 'Templates', factory)

    except IndexError as error:

        assert False, error

    assert "\n;Tag1: {value}\n" in tmpl_s

    assert "\nIncome:Donations  -100%\n" in tmpl_s

    assert "\n;IncomeTag: Donations\n" in tmpl_s

@pytest.mark.parametrize('arg_s', [None, '-', 'output.ledger'])

def test_output_path(arg_s):

    arglist = [] if arg_s is None else ['-O', arg_s]

    config = config_from_file(os.devnull, arglist)

    output_path = config.get_output_path()

    if (arg_s is None) or (arg_s == '-'):

        assert output_path is None

    else:

        assert output_path == pathlib.Path(arg_s)

def test_output_path_from_section():

    expected_path = pathlib.Path('Template.output')

    config = config_from_file('test_config.ini', ['-O', 'output.ledger'])

    assert config.get_output_path('Templates') == expected_path

    assert config.get_output_path() != expected_path

    with config.from_section('Templates'):

        assert config.get_output_path() == expected_path

@pytest.mark.parametrize('arglist,expect_date', [

    ([], None),

    (['-d', '2017-10-12'], datetime.date(2017, 10, 12)),

    (['-c', 'Date'], datetime.date(2017, 10, 8)),

])

def test_default_date(arglist, expect_date):

    config = config_from_file('test_config.ini', arglist)

    default_date = config.get_default_date()

    if expect_date is None:

        assert START_DATE <= default_date <= datetime.date.today()

    else:

        assert default_date == expect_date

    assert config.get_default_date('Date') == datetime.date(2017, 10, 8)

@pytest.mark.parametrize('level_s,expect_level', [

    (s, getattr(logging, s.upper()))

    for s in ['critical', 'debug', 'error', 'info', 'warning']

])

def test_loglevel(level_s, expect_level):

    config = config_from_file(os.devnull, ['--loglevel', level_s])

    assert config.get_loglevel() == expect_level

@contextlib.contextmanager

def bad_config(expect_input):

import argparse

import datetime

import itertools

import pytest

from import2ledger import hooks

def test_load_all():

    all_hooks = list(hooks.load_all())

    assert add_entity.AddEntityHook in all_hooks

@pytest.mark.parametrize('payee,expected', [

    ('Alex Smith', 'Smith-Alex'),

    ('Dakota D.  Doe', 'Doe-Dakota-D'),

    ('Björk', 'Bjork'),

    ('Fran Doe-Smith', 'Doe-Smith-Fran'),

    ('Alex(Nickname) Smith', 'Smith-Alex'),

    ('稲荷', '稲荷'),

    ('Pøweł', 'Powel'),

    ('Elyse Jan Smith', 'Smith-Elyse-Jan'),

    ('Jan van Smith', 'van-Smith-Jan'),

    ('Francis da Silva', 'da-Silva-Francis'),

])

def test_add_entity(payee, expected):

    data = {'payee': payee}

    hook = add_entity.AddEntityHook(argparse.Namespace())

    hook.run(data)

    assert data['entity'] == expected

class DefaultDateConfig:

    ONE_DAY = datetime.timedelta(days=1)

    def __init__(self, start_date=None):

        if start_date is None:

            start_date = datetime.date(2016, 3, 5)

        self.date = start_date - self.ONE_DAY

    def get_default_date(self, section_name=None):

        self.date += self.ONE_DAY

        return self.date

class TestDefaultDate:

    def test_simple_case(self):

        expect_date = datetime.date(2016, 2, 4)

        config = DefaultDateConfig(expect_date)

        data = {}

        hook = default_date.DefaultDateHook(config)

        hook.run(data)

        assert data['date'] == expect_date

    def test_no_caching(self):

        config = DefaultDateConfig()

        else:

            lines.append(line)

    if lines:

        yield ''.join(lines)

def entries2set(in_file):

    return set(normalize_whitespace(e) for e in iter_entries(in_file))

def expected_entries(path):

    path = pathlib.Path(path)

    if not path.is_absolute():

        path = DATA_DIR / path

    with path.open() as in_file:

        return entries2set(in_file)

def test_fees_import():

    arglist = ARGLIST + [

        '-c', 'One',

        pathlib.Path(DATA_DIR, 'PatreonEarnings.csv').as_posix(),

    ]

    exitcode, stdout, _ = run_main(arglist)

    assert exitcode == 0

    actual = entries2set(stdout)

    assert actual == expected_entries('test_main_fees_import.ledger')