import argparse

import configparser

import datetime

import decimal

import os.path

import pathlib

import babel

import babel.numbers

from . import cache, loaders

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

def currency_code(s):

    if not ((len(s) == 3) and s.isalpha()):

        raise ValueError("bad currency code: {!r}".format(s))

    return s.upper()

def currency_list(s):

    return [currency_code(code.strip()) for code in s.split(',')]

class Configuration:

    DATE_SEPS = frozenset('.-/ ')

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

    LOCALE = babel.core.Locale.default()

    SENTINEL = object()

    PREPOSITIONS = frozenset(['in', 'to', 'into'])

    TODAY = datetime.date.today()

    def __init__(self, arglist):

        argparser = self._build_argparser()

            post_hook()

    def _date_from_s(self, s):

        clean_s = s.strip()

        numbers = []

        seen_seps = set()

        start_index = 0

        for index, c in (pair for pair in enumerate(clean_s) if pair[1] in self.DATE_SEPS):

            seen_seps.add(c)

            numbers.append(int(clean_s[start_index:index], 10))

            start_index = index + 1

        numbers.append(int(clean_s[start_index:], 10))

        if (len(numbers) > 3) or (len(seen_seps) > 1):

            raise ValueError("can't parse date from {!r}".format(s))

        replacements = dict(zip(['day', 'month', 'year'], reversed(numbers)))

        retval = self.TODAY.replace(**replacements)

        if retval > self.TODAY:

            if 'year' in replacements:

                pass

            elif 'month' in replacements:

                retval = retval.replace(year=retval.year - 1)

            else:

                retval -= datetime.timedelta(days=replacements['day'])

                retval = retval.replace(**replacements)

    def _build_argparser(self):

        prog_parser = argparse.ArgumentParser()

        prog_parser.add_argument(

            '--config-file', '-c',

            action='append', type=pathlib.Path,

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

        )

        subparsers = prog_parser.add_subparsers()

        hist_parser = subparsers.add_parser(

            'historical', aliases=['hist'],

            usage='%(prog)s [[YYYY-]MM-]DD [[amount] code] [[in] code]',

            help="Show a currency conversion or rate from a past date",

        )

        hist_parser.set_defaults(

            command='historical',

            amount=None,

            from_currency=None,

            ledger=None,

        )

        hist_parser.add_argument(

            '--base',

            metavar='CODE', type=currency_code,

            value = self._convert_or_error(convert_to, value, confname)

        setattr(self.args, argname, value)

    def _convert_or_error(self, argtype, s_value, argname=None, typename=None):

        try:

            return argtype(s_value)

        except (decimal.InvalidOperation, TypeError, ValueError):

            errmsg = []

            if argname:

                errmsg.append("argument {}".format(argname))

            if typename is None:

                typename = argtype.__name__.replace('_', ' ')

            errmsg.append("invalid {} value".format(typename))

            errmsg.append(repr(s_value))

            self.error(': '.join(errmsg))

    def _user_currency(self, default=SENTINEL):

        try:

            return babel.numbers.get_territory_currencies(

                self.LOCALE.territory, start_date=self.TODAY)[0]

        except IndexError:

            return default

    def _post_hook_historical(self):

        year = self.args.date.year

        if year < 100:

            # Don't let the user specify ambiguous dates.

            self.error("historical data not available from year {}".format(year))

        self._read_from_conffile('base', 'Historical', 'USD', currency_code)

        if self.args.denomination is self.SENTINEL:

            self.args.denomination = None

        else:

            self._read_from_conffile('denomination', 'Historical', None, currency_code)

        pref_currency = self.args.denomination or self._user_currency(self.args.base)

        self._read_from_conffile('signed_currencies', 'Historical', pref_currency,

                                 currency_list, convert_fallback=True)

        self._read_from_conffile('ledger', 'Historical', False, getter='getboolean')

        raw_words = iter(getattr(self.args, 'word' + c) for c in '1234')

        words = iter(word for word in raw_words if word is not None)

        try:

            next_word = next(words)

            try:

                self.args.amount = decimal.Decimal(next_word)

            except decimal.InvalidOperation:

                pass

            else:

                # If an amount was given, a currency code must be given too.

                # If it wasn't, set a value that can't be parsed as a currency.

                next_word = next(words, 'none given')

            self.args.from_currency = self._convert_or_error(currency_code, next_word)

            next_word = next(words)

            if next_word.lower() in self.PREPOSITIONS:

                next_word = next(words, next_word)

            self.args.to_currency = self._convert_or_error(currency_code, next_word)

        except StopIteration:

            self.args.to_currency = pref_currency

    def _build_cache_loader(self):

        kwargs = dict(self.conffile.items('Cache'))

        try:

            kwargs['dir_path'] = pathlib.Path(kwargs.pop('directory'))

        except KeyError:

            pass

        self.cache = cache.CacheWriter(**kwargs)

        return loaders.FileCache(**kwargs)

    def _build_oxrapi_loader(self):

        kwargs = dict(self.conffile.items('OXR'))

        return loaders.OXRAPIRequest(**kwargs)

    def get_loaders(self):

        loader_chain = loaders.LoaderChain()

        for build_func in [

                self._build_cache_loader,

                self._build_oxrapi_loader,

        ]:

            try:

                loader = build_func()

            except (TypeError, ValueError, configparser.NoSectionError):

                pass

#!/usr/bin/env python3

from setuptools import setup

setup(

    name='oxrlib',

    description="Library to query the Open Exchange Rates (OXR) API",

    author='Brett Smith',

    author_email='brettcsmith@brettcsmith.org',

    license='GNU AGPLv3+',

    install_requires=['babel'],

    setup_requires=['pytest-runner'],

    tests_require=['pytest'],

    packages=['oxrlib', 'oxrlib.commands'],

    entry_points={

        'console_scripts': ['oxrquery = oxrlib.__main__:main'],

    },

)

    config = config_from(os.devnull, ['historical', date_s])

    actual_date = config.args.date

    assert actual_date.year == expect_year

    assert actual_date.month == expect_month

    assert actual_date.day == expect_day

@pytest.mark.parametrize('date_s', [

    '99',

    '8-88',

    '77-7',

    '0xf-1-2',

    '0b1-3-4',

    '2017/5.9',

    '2018-6/10',

    '1-2-3-4',

    '12/11/10',

])

def test_bad_date_parsing(date_s):

    try:

        config = config_from(os.devnull, ['historical', date_s])

    except SystemExit:

        pass

    else:

        assert not config.args.date, "date parsed from {!r}".format(date_s)