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):

        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'],

            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)

                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'))

#!/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'],

    },

    '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)