range(2015)  # Iterate all fiscal years from 2015 to today, inclusive

          range(-1)  # Iterate the previous fiscal year and current fiscal year

        """

        if not isinstance(from_fy, int):

            from_fy = self.for_date(from_fy)

        if to_fy is None:

            to_fy = self.for_date()

        elif not isinstance(to_fy, int):

            to_fy = self.for_date(to_fy - datetime.timedelta(days=1))

        if from_fy < 1:

            from_fy += to_fy

        elif from_fy < 1000:

            from_fy, to_fy = to_fy, from_fy + to_fy

        return range(from_fy, to_fy + 1)

class Loader:

    """Load Beancount books organized by fiscal year"""

    def __init__(self,

                 books_root: Path,

                 fiscal_year: FiscalYear,

    ) -> None:

        """Set up a books loader

        Arguments:

        * books_root: A Path to a Beancount books checkout.

        * fiscal_year: A FiscalYear object, used to determine what books to

          load for a given date range.

        """

        self.books_root = books_root

        self.fiscal_year = fiscal_year

    def _iter_fy_books(self, fy_range: Iterable[int]) -> Iterator[Path]:

        for year in fy_range:

            if path.exists():

                yield path

        This method generates a range of fiscal years by calling

        FiscalYear.range() with its first two arguments. It returns a string of

        Beancount directives to load the books from the first available fiscal

        year through the end of the range.

        """

        try:

        except StopIteration:

option "title" "Books from 2018"

include "../2018.beancount"

option "title" "Books from 2019"

include "../2019.beancount"

option "title" "Books from 2020"

include "../2020.beancount"

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU Affero General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU Affero General Public License for more details.

#

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <https://www.gnu.org/licenses/>.

import hashlib

import re

from datetime import date

from pathlib import Path

import pytest

from . import testutil

from conservancy_beancount import books

books_path = testutil.test_path('books')

@pytest.fixture(scope='module')

def conservancy_loader():

    return books.Loader(books_path, books.FiscalYear(3))

])

    assert not errors

    narrations = {getattr(entry, 'narration', None) for entry in entries}

def test_load_fy_range_empty(conservancy_loader):

    entries, errors, options_map = conservancy_loader.load_fy_range(2020, 2019)

    assert not errors

    assert not entries

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

def test_books_loader_without_books():

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

    'Equity:Funds:Unrestricted',

    'Equity:Funds:Restricted',

    'Equity:OpeningBalance',

])

def balance_map(source=None, **kwargs):

    # The source and/or kwargs should map currency name strings to

    # things you can pass to Decimal (a decimal string, an int, etc.)

    # This returns a dict that maps currency name strings to Amount instances.

    retval = {}

    if source is not None:

        retval.update((currency, Amount(number, currency))

                      for currency, number in source)

    if kwargs:

        retval.update(balance_map(kwargs.items()))

    return retval

def OpeningBalance(acct=None, **txn_meta):

    if acct is None:

        acct = next(OPENING_EQUITY_ACCOUNTS)

    return Transaction(**txn_meta, postings=[

        ('Assets:Receivable:Accounts', 100),

        ('Assets:Receivable:Loans', 200),

        ('Liabilities:Payable:Accounts', -15),

        ('Liabilities:Payable:Vacation', -25),

        (acct, -260),

    ])

class TestBooksLoader(books.Loader):

    def __init__(self, source):

        self.source = source

class TestConfig:

    def __init__(self, *,

                 books_path=None,

                 payment_threshold=0,

                 repo_path=None,

                 rt_client=None,

    ):

        if books_path is None:

            self._books_loader = None

        else:

            self._books_loader = TestBooksLoader(books_path)

        self._payment_threshold = Decimal(payment_threshold)

        self.repo_path = test_path(repo_path)

        self._rt_client = rt_client

        if rt_client is None:

            self._rt_wrapper = None

        else:

            self._rt_wrapper = rtutil.RT(rt_client)

    def books_loader(self):

        return self._books_loader

    def config_file_path(self):

        return test_path('userconfig/conservancy_beancount/config.ini')

    def payment_threshold(self):

        return self._payment_threshold

    def repository_path(self):

        return self.repo_path