import abc

import datetime

import beancount.core.data as bc_data

from typing import (

    TYPE_CHECKING,

    Any,

    Dict,

    FrozenSet,

    Iterable,

    List,

    Mapping,

    NamedTuple,

    Optional,

    Set,

    Tuple,

    Type,

    Union,

)

if TYPE_CHECKING:

    from . import errors as errormod

Account = bc_data.Account

Currency = bc_data.Currency

Meta = bc_data.Meta

MetaKey = str

MetaValue = Any

MetaValueEnum = str

Posting = bc_data.Posting

class Directive(NamedTuple):

    meta: Meta

    date: datetime.date

class Close(Directive):

    account: str

class Error(NamedTuple):

    source: Mapping[MetaKey, MetaValue]

    message: str

    entry: Optional[Directive]

import re

import signal

import subprocess

import sys

import traceback

import types

from pathlib import Path

import rt.exceptions as rt_error

import yaml

from . import data

from . import errors

from . import filters

from . import rtutil

from typing import (

    cast,

    Any,

    BinaryIO,

    Callable,

    Container,

    Generic,

    IO,

    Iterable,

    Iterator,

    List,

    NamedTuple,

    NoReturn,

    Optional,

    Sequence,

    TextIO,

    Type,

    TypeVar,

    Union,

)

from .beancount_types import (

    MetaKey,

)

ET = TypeVar('ET', bound=enum.Enum)

OutputFile = Union[int, IO]

CPU_COUNT = len(os.sched_getaffinity(0))

STDSTREAM_PATH = Path('-')

VERSION = pkg_resources.require(PKGNAME)[0].version

class EnumArgument(Generic[ET]):

    """Wrapper class to use an enum as argument values

    Use this class when the user can choose one of some arbitrary enum names

    as an argument. It will let user abbreviate and use any case, and will

    return the correct value as long as it's unambiguous. Typical usage

    looks like::

        enum_arg = EnumArgument(Enum)

        arg_parser.add_argument(

          '--choice',

          type=enum_arg.enum_type,  # or .value_type

          help=f"Choices are {enum_arg.choices_str()}",

          …

        )

        self.base = base

    def enum_type(self, arg: str) -> ET:

        """Return a single enum whose name matches the user argument"""

        regexp = re.compile(re.escape(arg), re.IGNORECASE)

        matches = frozenset(

            choice

            for name, choice in self.base.__members__.items()

            if regexp.match(name)

        )

        count = len(matches)

        if count == 1:

            return next(iter(matches))

        elif count:

            names = ', '.join(repr(choice.name) for choice in matches)

            raise ValueError(f"ambiguous argument {arg!r}: matches {names}")

        else:

            raise ValueError(f"unknown argument {arg!r}")

    def value_type(self, arg: str) -> Any:

        return self.enum_type(arg).value

    def choices_str(self, sep: str=', ', fmt: str='{!r}') -> str:

        """Return a user-formatted string of enum names"""

            self.base, '_choices_sortkey', self._choices_sortkey,

        )

        return sep.join(

            fmt.format(choice.name.lower())

            for choice in sorted(self.base, key=sortkey)

        )

        return choice.name

class ExceptHook:

    def __init__(self, logger: Optional[logging.Logger]=None) -> None:

        if logger is None:

            logger = logging.getLogger()

        self.logger = logger

    def __call__(self,

                 exc_type: Type[BaseException],

                 exc_value: BaseException,

                 exc_tb: types.TracebackType,

    ) -> NoReturn:

        error_type = type(exc_value).__name__

        msg = ": ".join(str(arg) for arg in exc_value.args)

        if isinstance(exc_value, KeyboardInterrupt):

            signal.signal(signal.SIGINT, signal.SIG_DFL)

            os.kill(0, signal.SIGINT)

            signal.pause()

        elif isinstance(exc_value, (

                rt_error.AuthorizationError,

                rt_error.NotAllowed,

        )):

    # BSD exit codes commonly used

    NoConfiguration = os.EX_CONFIG

    NoConfig = NoConfiguration

    NoDataFiltered = os.EX_DATAERR

    NoDataLoaded = os.EX_NOINPUT

    OK = os.EX_OK

    Ok = OK

    RewriteRulesError = os.EX_DATAERR

    # Our own exit codes, working down from that range

    BeancountErrors = 63

class ExtendAction(argparse.Action):

    """argparse action to let a user build a list from a string

    This is a fancier version of argparse's built-in ``action='append'``.

    The user's input is turned into a list of strings, split by a regexp

    pattern you provide. Typical usage looks like::

        parser = argparse.ArgumentParser()

        parser.add_argument(

          '--option', ...,

          action=ExtendAction,

          ...,

        )

    """

    DEFAULT_PATTERN = r'\s*,\s*'

    def __call__(self,

                 parser: argparse.ArgumentParser,

                 namespace: argparse.Namespace,

                 values: Union[Sequence[Any], str, None]=None,

                 option_string: Optional[str]=None,

    ) -> None:

        pattern: str = self.const or self.DEFAULT_PATTERN

        value: Optional[List[str]] = getattr(namespace, self.dest, None)

        if value is None:

            value = []

            setattr(namespace, self.dest, value)

        if values is None:

            values = []

        elif isinstance(values, str):

            values = [values]

        for s in values:

            value.extend(re.split(pattern, s))

                 parser: argparse.ArgumentParser,

                 namespace: argparse.Namespace,

                 values: Union[Sequence[Any], str, None]=None,

                 option_string: Optional[str]=None,

    ) -> NoReturn:

        if isinstance(self.const, str):

            info = self.const

            exitcode = 0

        else:

            info, exitcode = self.const

        print(info)

        raise SystemExit(exitcode)

class LogLevel(enum.IntEnum):

    DEBUG = logging.DEBUG

    INFO = logging.INFO

    WARNING = logging.WARNING

    ERROR = logging.ERROR

    CRITICAL = logging.CRITICAL

    WARN = WARNING

    ERR = ERROR

    CRIT = CRITICAL

        return self.value

class SearchTerm(NamedTuple):

    """NamedTuple representing a user's metadata filter

    SearchTerm knows how to parse and store posting metadata filters provided

    by the user in `key=value` format. Reporting tools can use this to filter

    postings that match the user's criteria, to report on subsets of the books.

    Typical usage looks like::

      argument_parser.add_argument(

        'search_terms',

        type=SearchTerm.arg_parser(),

        …,

      )

      args = argument_parser.parse_args(…)

      for query in args.search_terms:

        postings = query.filter_postings(postings)

    """

    meta_key: MetaKey

    pattern: str

            return None

        cache_dir_path = self.cache_dir_path()

        if cache_dir_path is None:

            cache_db = None

        else:

            cache_name = '{}@{}.sqlite3'.format(

                credentials.user,

                urlparse.quote(str(credentials.server), ''),

            )

            cache_path = cache_dir_path / cache_name

            try:

                cache_path.touch(0o600)

            except OSError:

                # RTLinkCache.setup() will handle the problem.

                pass

            cache_db = rtutil.RTLinkCache.setup(cache_path)

        return rtutil.RT(wrapper_client, cache_db)

    def rt_wrapper(self,

                  credentials: RTCredentials=None,

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

    ) -> Optional[rtutil.RT]:

        if credentials is None:

            credentials = self.rt_credentials()

import enum

import logging

import operator

import os

import sys

import unicodedata

from decimal import Decimal

from pathlib import Path

import odf.style  # type:ignore[import]

import odf.table  # type:ignore[import]

from beancount.parser import printer as bc_printer

from .. import books

from .. import cliutil

from .. import config as configmod

from .. import data

from ..ranges import DateRange

from ..reports import core

from typing import (

    Any,

    Iterable,

    Iterator,

    List,

    Mapping,

    NamedTuple,

    Optional,

    Sequence,

    TextIO,

    Tuple,

    Union,

)

PROGNAME = 'reconcile-paypal'

logger = logging.getLogger('conservancy_beancount.reconcile.paypal')

class ReconcileProblems(enum.IntFlag):

    NOT_IN_STATEMENT = enum.auto()

    DUP_IN_STATEMENT = enum.auto()

    AMOUNT_DIFF = enum.auto()

    MONTH_DIFF = enum.auto()

    DATE_DIFF = enum.auto()

class PayPalPosting(NamedTuple):

    filename: str

    lineno: int

    txn_id: str

    date: datetime.date

    amount: data.Amount

    description: str

    entity: Optional[str]

    @classmethod

    def from_books(cls, post: data.Posting) -> 'PayPalPosting':

        return cls(

                statement_post = self.books_posts[0]

            except IndexError:

                return

        for post in self.books_posts:

            yield (post, statement_post.compare(post))

    def problems(self) -> int:

        stmt_count = len(self.statement_posts)

        if stmt_count == 0:

            return ReconcileProblems.NOT_IN_STATEMENT

        elif stmt_count > 1:

            return ReconcileProblems.DUP_IN_STATEMENT

        else:

            balance = core.Balance(post.amount for post in self.books_posts)

            if not (balance - self.statement_posts[0].amount).is_zero():

                return ReconcileProblems.AMOUNT_DIFF

            worst_problem = 0

            for _, problems in self.post_problems():

                if problems & ~ReconcileProblems.DATE_DIFF:

                    return problems

                else:

                    worst_problem = worst_problem or problems

            return worst_problem

        try:

            post = self.statement_posts[0]

        except IndexError:

            post = self.books_posts[0]

        return post.date

class PayPalReconciliationReport(core.BaseODS[PayPalPosting, str]):

    COLUMN_WIDTHS = {

        'Source': 1.5,

        'Transaction ID': 1.5,

        'Date': None,

        'Amount': 1,

        'Description': 2.5,

        'Entity': 1.5,

    }

    def __init__(self) -> None:

        super().__init__()

        self.bad_sheet = self.start_sheet("Reconciliation")

        self.good_sheet = self.start_sheet("Matched Postings")

    def init_styles(self) -> None:

        super().init_styles()

"""balance_sheet.py - Balance sheet report"""

# Copyright © 2020  Brett Smith

# License: AGPLv3-or-later WITH Beancount-Plugin-Additional-Permission-1.0

#

# Full copyright and licensing details can be found at toplevel file

# LICENSE.txt in the repository.

import argparse

import collections

import datetime

import enum

import logging

import operator

import sys

from decimal import Decimal

from pathlib import Path

from typing import (

    Any,

    Callable,

    Collection,

    Dict,

    Iterable,

    Iterator,

    List,

    Mapping,

    NamedTuple,

    Optional,

    Sequence,

    TextIO,

    Tuple,

    Union,

)

import odf.style  # type:ignore[import]

import odf.table  # type:ignore[import]

from beancount.parser import printer as bc_printer

from . import core

from . import rewrite

from .. import books

from .. import cliutil

from .. import config as configmod

from .. import data

from .. import ranges

using account classifications in the account definitions.

"""

# Copyright © 2020  Brett Smith

# License: AGPLv3-or-later WITH Beancount-Plugin-Additional-Permission-1.0

#

# Full copyright and licensing details can be found at toplevel file

# LICENSE.txt in the repository.

import argparse

import collections

import datetime

import enum

import logging

import operator

import sys

from decimal import Decimal

from pathlib import Path

from typing import (

    Any,

    Callable,

    Collection,

    Dict,

    Iterable,

    Iterator,

    List,

    Mapping,

    NamedTuple,

    Optional,

    Sequence,

    TextIO,

    Tuple,

    Union,

)

import odf.style  # type:ignore[import]

import odf.table  # type:ignore[import]

from beancount.parser import printer as bc_printer

from . import core

from . import rewrite

from .. import books

from .. import cliutil

from .. import config as configmod

from .. import data

from .. import ranges

import odf.table  # type:ignore[import]

import odf.text  # type:ignore[import]

from decimal import Decimal

from pathlib import Path

from beancount.core import amount as bc_amount

from odf.namespaces import TOOLSVERSION  # type:ignore[import]

from .. import cliutil

from .. import data

from .. import filters

from .. import ranges

from .. import rtutil

from typing import (

    cast,

    overload,

    Any,

    BinaryIO,

    Callable,

    Collection,

    Dict,

    Generic,

    Iterable,

    Iterator,

    List,

    Mapping,

    MutableMapping,

    NamedTuple,

    Optional,

    Sequence,

    Set,

    Tuple,

    Type,

    TypeVar,

    Union,

)

from ..beancount_types import (

    MetaKey,

    MetaValue,

)

OPENING_BALANCE_NAME = "OPENING BALANCE"

ENDING_BALANCE_NAME = "ENDING BALANCE"

DecimalCompat = data.DecimalCompat

BalanceType = TypeVar('BalanceType', bound='Balance')

ElementType = Callable[..., odf.element.Element]

LinkType = Union[str, Tuple[str, Optional[str]]]

RelatedType = TypeVar('RelatedType', bound='RelatedPostings')

RT = TypeVar('RT', bound=Sequence)

ST = TypeVar('ST')

T = TypeVar('T')

class Balance(Mapping[str, data.Amount]):

    """A collection of amounts mapped by currency

    Each key is a Beancount currency string, and each value represents the

    balance in that currency.

    """

    __slots__ = ('_currency_map', 'tolerance')

    TOLERANCE = Decimal('0.01')

    def __init__(self,

    ) -> Sequence[data.Account]:

        """Return a sequence of seen account classifications

        Given an account name, returns a sequence of all the account

        classifications seen in the postings under that part of the account

        hierarchy. The classifications are sorted in descending order by the

        balance of postings under them for the ``sort_period`` time period.

        """

        if sort_period is None:

            if account in data.EQUITY_ACCOUNTS:

                sort_period = Period.PERIOD

            else:

                sort_period = Period.ANY

        class_bals: Mapping[data.Account, MutableBalance] \

            = collections.defaultdict(MutableBalance)

        for key, balance in self.balances.items():

            if not key.account.is_under(account):

                pass

            elif key.period & sort_period:

                class_bals[key.classification] += balance

            else:

                # Ensure the balance exists in the mapping

                class_bals[key.classification]

        norm_func = normalize_amount_func(f'{account}:RootsOK')

            prefix, _, _ = acct.rpartition(':')

            balance = norm_func(class_bals[acct])

            try:

                max_bal = max(amount.number for amount in balance.values())

            except ValueError:

                max_bal = Decimal(0)

            return prefix, -max_bal

        return sorted(class_bals, key=sortkey)

    def iter_accounts(self, root: Optional[str]=None) -> Sequence[data.Account]:

        """Return a sequence of accounts open during the reporting period

        The sequence is sorted by account name.

        """

        start_date = self.period_range.start

        stop_date = self.period_range.stop

        return sorted(

            account

            for account in data.Account.iter_accounts(root)

            if account.meta.open_date < stop_date

            and (account.meta.close_date is None

                 or account.meta.close_date > start_date)

        )

Get all Assets postings for a given month to help with reconciliation::

    ledger-report -a Assets -b 2018-05-01 -e 2018-06-01

"""

# Copyright © 2020  Brett Smith

# License: AGPLv3-or-later WITH Beancount-Plugin-Additional-Permission-1.0

#

# Full copyright and licensing details can be found at toplevel file

# LICENSE.txt in the repository.

import argparse

import collections

import datetime

import enum

import itertools

import operator

import logging

import sys

from typing import (

    Any,

    Callable,

    Dict,

    Iterable,

    Iterator,

    List,

    Mapping,

    Optional,

    Sequence,

    Set,

    TextIO,

    Tuple,

    Type,

    Union,

    cast,

)

from ..beancount_types import (

    Transaction,

)

from pathlib import Path

import odf.table  # type:ignore[import]

import odf.text  # type:ignore[import]

from beancount.core import data as bc_data

from beancount.parser import printer as bc_printer

from . import core

from . import rewrite

from .. import books

from .. import cliutil

from .. import config as configmod

from .. import data

from .. import ranges

from .. import rtutil

PostTally = List[Tuple[int, data.Account]]

PROGNAME = 'ledger-report'

logger = logging.getLogger('conservancy_beancount.reports.ledger')

class ReportType(enum.IntFlag):

    ZERO_TRANSACTIONS = enum.auto()

    ZERO_TXNS = ZERO_TRANSACTIONS

    CREDIT_TRANSACTIONS = enum.auto()

    CREDIT_TXNS = CREDIT_TRANSACTIONS

    DEBIT_TRANSACTIONS = enum.auto()

    DEBIT_TXNS = DEBIT_TRANSACTIONS

    ALL_TRANSACTIONS = ZERO_TRANSACTIONS | CREDIT_TRANSACTIONS | DEBIT_TRANSACTIONS

    ALL_TXNS = ALL_TRANSACTIONS

    FULL_LEDGER = enum.auto()

    FUND_LEDGER = enum.auto()

    PROJECT_LEDGER = FUND_LEDGER

    @classmethod

    def post_flag(cls, post: data.Posting) -> int:

        norm_func = core.normalize_amount_func(post.account)

        number = norm_func(post.units.number)

        if not number:

            return cls.ZERO_TRANSACTIONS

        elif number > 0:

            return cls.CREDIT_TRANSACTIONS

        else:

            return cls.DEBIT_TRANSACTIONS

        subtype, _, maintype = self.name.partition('_')

        return (maintype, subtype)

class TransactionODS(LedgerODS):

    CORE_COLUMNS: Sequence[str] = [

        'Date',

        'Description',

        'Account',

        data.Metadata.human_name('entity'),

        'Original Amount',

        'Booked Amount',

    ]

    METADATA_COLUMNS: Sequence[str] = [

        'project',

        'rt-id',

        'receipt',

        'check',

        'invoice',

        'contract',

        'approval',

        'paypal-id',

        'check-number',

        'bank-statement',

balances for that year.

Run it without arguments to generate opening balances for the current fiscal

year. You can also specify a fiscal year to generate opening balances for, or

even a specific date (which can be helpful for testing or debugging).

"""

# SPDX-FileCopyrightText: © 2020 Martin Michlmayr <tbm@cyrius.com>

# SPDX-FileCopyrightText: © 2020 Brett Smith

# License: AGPLv3-or-later WITH Beancount-Plugin-Additional-Permission-1.0

#

# Full copyright and licensing details can be found at toplevel file

# LICENSE.txt in the repository.

import argparse

import collections

import copy

import datetime

import enum

import locale

import logging

import sys

from typing import (

    Dict,

    Iterable,

    Iterator,

    Mapping,

    NamedTuple,

    Optional,

    Sequence,

    TextIO,

    Tuple,

)

from ..beancount_types import (

    Error,

    MetaKey,

    MetaValue,

    Transaction,

)

from decimal import Decimal, ROUND_HALF_EVEN, ROUND_HALF_UP

from .. import books

from .. import cliutil

from .. import config as configmod

from .. import data

from ..reports.core import Balance

from beancount.core import data as bc_data

from beancount.core import display_context as bc_dcontext

from beancount.parser import printer as bc_printer

from beancount.core.convert import get_cost

from beancount.core.inventory import Inventory

from beancount.core.position import Position, get_position

RESTRICTED_ACCOUNT = data.Account('Equity:Funds:Restricted')

UNRESTRICTED_ACCOUNT = data.Account('Equity:Funds:Unrestricted')

PROGNAME = 'opening-balances'

logger = logging.getLogger('conservancy_beancount.tools.opening_balances')

def quantize_amount(

        amount: data.Amount,

        exp: Decimal=Decimal('.01'),

        rounding: str=ROUND_HALF_EVEN,

) -> data.Amount:

    return amount._replace(number=amount.number.quantize(exp, rounding=rounding))

class AccountWithFund(NamedTuple):

    account: data.Account

    fund: Optional[MetaValue]

        account, fund = self

        return (

            0 if fund is None else 1,

            locale.strxfrm(account),

            locale.strxfrm(str(fund).casefold()),

        )

class Posting(data.Posting):

    @staticmethod

    def _position_sortkey(position: Position) -> str:

        units, cost = position

        if cost is None:

            # Beancount type-declares that position.cost must be a Cost, but