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

    cast,

    Any,

    BinaryIO,

    Callable,

    Container,

    Generic,

    IO,

    Iterable,

    Iterator,

    List,

    NamedTuple,

    NoReturn,

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

    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:

    pattern you provide. Typical usage looks like::

        parser = argparse.ArgumentParser()

        parser.add_argument(

          '--option', ...,

          action=ExtendAction,

          ...,

        )

    """

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

    def __call__(self,

    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

    def rt_wrapper(self,

                  credentials: RTCredentials=None,

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

    ) -> Optional[rtutil.RT]:

        if credentials is None:

            credentials = self.rt_credentials()

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

                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

from typing import (

    Any,

    Callable,

    Collection,

    Dict,

    Iterable,

    Iterator,

    List,

    Mapping,

    NamedTuple,

    Optional,

from typing import (

    Any,

    Callable,

    Collection,

    Dict,

    Iterable,

    Iterator,

    List,

    Mapping,

    NamedTuple,

    Optional,

    Any,

    BinaryIO,

    Callable,

    Collection,

    Dict,

    Generic,

    Iterable,

    Iterator,

    List,

    Mapping,

    MutableMapping,

    NamedTuple,

    TypeVar,

    Union,

)

from ..beancount_types import (

    MetaKey,

    MetaValue,

)

OPENING_BALANCE_NAME = "OPENING BALANCE"

ENDING_BALANCE_NAME = "ENDING BALANCE"

DecimalCompat = data.DecimalCompat

            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)

import sys

from typing import (

    Any,

    Callable,

    Dict,

    Iterable,

    Iterator,

    List,

    Mapping,

    Optional,

    Sequence,

    Tuple,

    Type,

    Union,

    cast,

)

from ..beancount_types import (

    Transaction,

)

from pathlib import Path

import odf.table  # type:ignore[import]

            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] = [

import locale

import logging

import sys

from typing import (

    Dict,

    Iterable,

    Iterator,

    Mapping,

    NamedTuple,

    Optional,

    Sequence,

    Tuple,

)

from ..beancount_types import (

    Error,

    MetaKey,

    MetaValue,

    Transaction,

)

from decimal import Decimal, ROUND_HALF_EVEN, ROUND_HALF_UP

from .. import books

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

        )

from beancount.core import display_context as bc_dcontext

from beancount import loader as bc_loader

from beancount.parser import printer as bc_printer

from typing import (

    Optional,

    Sequence,

    TextIO,

)

from ..beancount_types import (

    Directive,

    Entries,

    Errors,

)

from .. import cliutil

PROGNAME = 'bean-sort'

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

        type=Path,

        nargs=argparse.ONE_OR_MORE,

        help="""Beancount path(s) to read entries from

""")

    return parser.parse_args(arglist)

    type_name = type(entry).__name__

    if type_name == 'Transaction':

        return (entry.date, type_name, entry.narration, entry.payee or '')  # type:ignore[attr-defined]

    else:

        return (entry.date, type_name)