rtrc_path = Path.home() / '.rtrc'

        try:

            with rtrc_path.open() as rtrc_file:

                for line in rtrc_file:

                    try:

                        key, value = line.split(None, 1)

                    except ValueError:

                        pass

                    else:

                        if key in values:

                            values[key] = value.rstrip('\n')

        except OSError:

            return cls()

        else:

            return cls(**values)

class Config:

    _ENVIRON_DEFAULT_PATHS = {

        'XDG_CACHE_HOME': Path('.cache'),

        'XDG_CONFIG_HOME': Path('.config'),

    }

    def __init__(self) -> None:

        self.file_config = configparser.ConfigParser()

    def load_file(self, config_path: Optional[Path]=None) -> None:

        if config_path is None:

            config_path = self.config_file_path()

        with config_path.open() as config_file:

            self.file_config.read_file(config_file)

    def load_string(self, config_str: str) -> None:

        self.file_config.read_string(config_str)

    def _dir_or_none(self, path: Path) -> Optional[Path]:

        try:

            path.mkdir(exist_ok=True)

        except OSError:

            return None

        else:

            return path

    def _path_from_environ(self, key: str, default: Optional[Path]=None) -> Path:

        try:

            retval = Path(os.environ[key])

        except (KeyError, ValueError):

            ok = False

        else:

            # Per the spec, non-absolute paths should be ignored.

            ok = retval.is_absolute()

        if not ok:

            retval = default or (Path.home() / self._ENVIRON_DEFAULT_PATHS[key])

        return retval

    def books_loader(self) -> Optional[books.Loader]:

        books_path = self.books_path()

        if books_path is None:

            return None

        else:

            return books.Loader(books_path, self.fiscal_year_begin())

    def books_path(self) -> Optional[Path]:

        try:

        except (KeyError, ValueError):

            ok = False

        else:

            ok = retval.is_absolute()

        return retval if ok else None

    def cache_dir_path(self, name: str='conservancy_beancount') -> Optional[Path]:

        cache_root = self._path_from_environ('XDG_CACHE_HOME')

        return (

            self._dir_or_none(cache_root)

            and self._dir_or_none(cache_root / name)

        )

    def config_file_path(self, name: str='conservancy_beancount') -> Path:

        config_root = self._path_from_environ('XDG_CONFIG_HOME')

        return Path(config_root, name, 'config.ini')

    def fiscal_year_begin(self) -> books.FiscalYear:

        s = self.file_config.get('Beancount', 'fiscal year begin', fallback='3 1')

        match = re.match(r'([01]?[0-9])(?:\s*[-./ ]\s*([0-3]?[0-9]))?$', s.strip())

        if match is None:

            raise ValueError(f"fiscal year begin {s!r} has unknown format")

        try:

            month = int(match.group(1))

            day = int(match.group(2) or 1)

            # To check date validity we use an arbitrary year that's

            # 1. definitely using the modern calendar

            # 2. far enough in the past to not have books (pre-Unix epoch)

            # 3. not a leap year

            datetime.date(1959, month, day)

        except ValueError as e:

            raise ValueError(f"fiscal year begin {s!r} is invalid date: {e.args[0]}")

        else:

            return books.FiscalYear(month, day)

    def payment_threshold(self) -> decimal.Decimal:

        try:

            return decimal.Decimal(self.file_config['Beancount']['payment threshold'])

        except (KeyError, ValueError):

            return decimal.Decimal(10)

    def repository_path(self) -> Optional[Path]:

        try:

            return Path(os.environ['CONSERVANCY_REPOSITORY'])

        except (KeyError, ValueError):

            return None

    def rt_credentials(self) -> RTCredentials:

        all_creds = zip(

            RTCredentials.from_env(),

            RTCredentials.from_rtrc(),

            RTCredentials(auth='rt'),

        )

        return RTCredentials._make(v0 or v1 or v2 for v0, v1, v2 in all_creds)

    def rt_client(self,

                  credentials: RTCredentials=None,

                  client: Type[rt.Rt]=rt.Rt,

    ) -> Optional[rt.Rt]:

        if credentials is None:

            credentials = self.rt_credentials()

        if credentials.server is None:

            return None

        urlparts = urlparse.urlparse(credentials.server)

        cache_dir_path = config.cache_dir_path('TESTcache')

    assert cache_dir_path == tmp_path / '.cache/TESTcache'

def test_default_payment_threshold():

    threshold = config_mod.Config().payment_threshold()

    assert isinstance(threshold, (int, decimal.Decimal))

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

    '15',

    ' +15',

    '15. ',

    '15.0',

    '15.00',

])

def test_payment_threshold(config_threshold):

    config = config_mod.Config()

    config.load_string(f'[Beancount]\npayment threshold = {config_threshold}\n')

    assert config.payment_threshold() == decimal.Decimal(15)

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

    None,

    '',

    'nonexistent/relative/path',

])

def test_config_file_path(config_path):

    expected = Path('~/.config/conservancy_beancount/config.ini').expanduser()

    with update_environ(XDG_CONFIG_HOME=config_path):

        config = config_mod.Config()

        assert config.config_file_path() == expected

def test_config_file_path_respects_xdg_config_home():

    with update_environ(XDG_CONFIG_HOME='/etc'):

        config = config_mod.Config()

        assert config.config_file_path() == Path('/etc/conservancy_beancount/config.ini')

def test_config_file_path_with_subdir():

    expected = testutil.test_path('userconfig/conftest/config.ini')

    config = config_mod.Config()

    assert config.config_file_path('conftest') == expected

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

    None,

    testutil.test_path('userconfig/conservancy_beancount/config.ini'),

])

def test_load_file(path):

    config = config_mod.Config()

    config.load_file(path)

    assert config.books_path() == Path('/test/conservancy_beancount')

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

    lambda path: None,

    operator.methodcaller('touch', 0o200),

])

def test_load_file_error(tmp_path, path_func):

    config_path = tmp_path / 'nonexistent.ini'

    path_func(config_path)

    config = config_mod.Config()

    with pytest.raises(OSError):

        config.load_file(config_path)

def test_no_books_path():

    config = config_mod.Config()

    assert config.books_path() is None

@pytest.mark.parametrize('value,month,day', [

    ('2', 2, 1),

    ('3 ', 3, 1),

    ('  4', 4, 1),

    (' 5 ', 5, 1),

    ('6 1', 6, 1),

    ('  06  03  ', 6, 3),

    ('6-05', 6, 5),

    ('06 - 10', 6, 10),

    ('6/15', 6, 15),

    ('06  /  20', 6, 20),

    ('10.25', 10, 25),

    (' 10 . 30 ', 10, 30),

])

def test_fiscal_year_begin(value, month, day):

    config = config_mod.Config()

    config.load_string(f'[Beancount]\nfiscal year begin = {value}\n')

    assert config.fiscal_year_begin() == (month, day)

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

    'text',

    '1900',

    '13',

    '010',

    '2 30',

    '4-31',

])

def test_bad_fiscal_year_begin(value):

    config = config_mod.Config()

    config.load_string(f'[Beancount]\nfiscal year begin = {value}\n')

    with pytest.raises(ValueError):

        config.fiscal_year_begin()

def test_default_fiscal_year_begin():

    config = config_mod.Config()

    actual = config.fiscal_year_begin()

    assert actual.month == 3

    assert actual.day == 1

def test_books_loader():

    books_path = testutil.test_path('books')

    config = config_mod.Config()

    config.load_string(f'[Beancount]\nbooks dir = {books_path}\n')

    loader = config.books_loader()

    entries, errors, _ = loader.load_fy_range(2020, 2020)

    assert entries

    assert not errors

def test_books_loader_without_books():

    assert config_mod.Config().books_loader() is None