"""core.py - Common data classes for reporting functionality"""

# 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 abc

import collections

import copy

import datetime

import enum

import itertools

import operator

import re

import shlex

import sys

import urllib.parse as urlparse

import babel.core  # type:ignore[import]

import babel.numbers  # type:ignore[import]

import git  # type:ignore[import]

import odf.config  # type:ignore[import]

import odf.element  # type:ignore[import]

import odf.meta  # type:ignore[import]

import odf.number  # type:ignore[import]

import odf.opendocument  # type:ignore[import]

import odf.style  # type:ignore[import]

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,

    Sortable,

)

OPENING_BALANCE_NAME = "OPENING BALANCE"

ENDING_BALANCE_NAME = "ENDING BALANCE"

            self.set_custom_property('ReportCommand', command_s)

    def set_custom_property(self,

                            name: str,

                            value: Any,

                            valuetype: Optional[str]=None,

    ) -> odf.meta.UserDefined:

        if valuetype is None:

            if isinstance(value, bool):

                valuetype = 'boolean'

            elif isinstance(value, (datetime.date, datetime.datetime)):

                valuetype = 'date'

            elif isinstance(value, (int, float, Decimal)):

                valuetype = 'float'

        if not isinstance(value, str):

            if valuetype == 'boolean':

                value = 'true' if value else 'false'

            elif valuetype == 'date':

                value = value.isoformat()

            else:

                value = str(value)

        retval = self.ensure_child(self.document.meta, odf.meta.UserDefined, name=name)

        if valuetype is None:

            try:

                retval.removeAttribute('valuetype')

            except KeyError:

                pass

        else:

            retval.setAttribute('valuetype', valuetype)

        retval.childNodes.clear()

        retval.addText(value)

        return retval

    def set_properties(self, *,

                       created: Optional[datetime.datetime]=None,

                       generator: str='conservancy_beancount',

    ) -> None:

        if created is None:

            created = datetime.datetime.now()

        created_elem = self.ensure_child(self.document.meta, odf.meta.CreationDate)

        created_elem.childNodes.clear()

        created_elem.addText(created.isoformat())

        generator_elem = self.ensure_child(self.document.meta, odf.meta.Generator)

        generator_elem.childNodes.clear()

        generator_elem.addText(f'{generator}/{cliutil.VERSION} {TOOLSVERSION}')

    ### Rows and cells

    def add_row(self, *cells: odf.table.TableCell, **attrs: Any) -> odf.table.TableRow:

        row = odf.table.TableRow(**attrs)

        for cell in cells:

            row.addElement(cell)

        self.sheet.addElement(row)

        return row

    def row_count(self, sheet: Optional[odf.table.Table]=None) -> int:

        if sheet is None:

            sheet = self.sheet

        TableRow = odf.table.TableRow

        return sum(1 for cell in sheet.childNodes if cell.isInstanceOf(TableRow))

    def balance_cell(self, balance: Balance, **attrs: Any) -> odf.table.TableCell:

        balance = balance.clean_copy() or balance

        balance_currency_count = len(balance)

        if balance_currency_count == 0:

            return self.float_cell(0, **attrs)

        elif balance_currency_count == 1:

            amount = next(iter(balance.values()))

            attrs['stylename'] = self.merge_styles(

                attrs.get('stylename'), self.currency_style(amount.currency),

            )

            return self.currency_cell(amount, **attrs)

        else:

            lines = [babel.numbers.format_currency(number, currency, get_commodity_format(

                self.locale, currency, None, self.currency_fmt_key,

            )) for number, currency in balance.values()]

            attrs['stylename'] = self.merge_styles(

                attrs.get('stylename'), self.style_endtext,

            )

            return self.multiline_cell(lines, **attrs)

    def currency_cell(self, amount: bc_amount._Amount, **attrs: Any) -> odf.table.TableCell:

        if 'stylename' not in attrs:

            attrs['stylename'] = self.currency_style(amount.currency)

        number, currency = amount

        cell = odf.table.TableCell(valuetype='currency', value=number, **attrs)

        cell.addElement(odf.text.P(text=babel.numbers.format_currency(

            number, currency, locale=self.locale, format_type=self.currency_fmt_key,

        )))

        return cell

    def date_cell(self, date: datetime.date, **attrs: Any) -> odf.table.TableCell:

        attrs.setdefault('stylename', self.style_date)

        cell = odf.table.TableCell(valuetype='date', datevalue=date, **attrs)

        cell.addElement(odf.text.P(text=date.isoformat()))

        return cell

    This matches the load interface that BQLShell expects.

    """

    def __init__(

            self,

            books_loader: Optional[books.Loader],

            start_date: Optional[datetime.date]=None,

            stop_date: Optional[datetime.date]=None,

            rewrite_rules: Sequence[rewrite.RewriteRuleset]=(),

    ) -> None:

        self.books_loader = books_loader

        self.start_date = start_date

        self.stop_date = stop_date

        self.rewrite_rules = rewrite_rules

    def __call__(self) -> books.LoadResult:

        logger.debug("BooksLoader called")

        result = books.Loader.dispatch(self.books_loader, self.start_date, self.stop_date)

        logger.debug("books loaded from Beancount")

        if self.rewrite_rules:

            for index, entry in enumerate(result.entries):

                # entry might not be a Transaction; we catch that later.

                # The type ignores are because the underlying Beancount type isn't

                # type-checkable.

                postings = data.Posting.from_txn(entry)  # type:ignore[arg-type]

                for ruleset in self.rewrite_rules:

                    postings = ruleset.rewrite(postings)

                try:

                    result.entries[index] = entry._replace(postings=list(postings))  # type:ignore[call-arg]

                except AttributeError:

                    pass

            logger.debug("rewrite rules applied")

        return result

class BQLShell(bc_query_shell.BQLShell):

    def __init__(

            self,

            is_interactive: bool,

            loadfun: Callable[[], books.LoadResult],

            outfile: TextIO,

            default_format: str='text',

            do_numberify: bool=False,

            rt_wrapper: Optional[rtutil.RT]=None,

    ) -> None:

        super().__init__(is_interactive, loadfun, outfile, default_format, do_numberify)

        self.env_postings = FilterPostingsEnvironment()

        self.env_targets = TargetsEnvironment()

        self.ods = QueryODS(rt_wrapper)

    def on_Select(self, statement: QueryStatement) -> None:

        output_format: str = self.vars['format']

        try:

            render_func = getattr(self, f'_render_{output_format}')

        except AttributeError:

            logger.error("unknown output format %r", output_format)

            return

        try:

            logger.debug("compiling query")

            compiled_query = bc_query_compile.compile(

                statement, self.env_targets, self.env_postings, self.env_entries,

            )

            logger.debug("executing query")

            row_types, rows = bc_query_execute.execute_query(

                compiled_query, self.entries, self.options_map,

            )

            if self.vars['numberify']:

                logger.debug("numberifying query")

                row_types, rows = bc_query_numberify.numberify_results(

                    row_types, rows, self.options_map['dcontext'].build(),

                )

        except Exception as error:

            logger.error(str(error), exc_info=logger.isEnabledFor(logging.DEBUG))

            if (isinstance(error, TypeError)

                and error.args

                and ' not supported between instances ' in error.args[0]):

                logger.info(

                    "HINT: Are you using ORDER BY or comparisons with metadata "

                    "that isn't consistently set?\n  "

                    "Try looking up that metadata with str_meta() instead to "

                    "ensure your comparisons use a consistent data type.",

                )

            return

        if not rows and output_format != 'ods':

            print("(empty)", file=self.outfile)

        else:

            logger.debug("rendering query as %s", output_format)

            render_func(statement, row_types, rows)

    def _render_csv(self, statement: QueryStatement, row_types: RowTypes, rows: Rows) -> None:

        bc_query_render.render_csv(

            row_types,

            rows,

            self.options_map['dcontext'],

            self.outfile,

            self.vars['expand'],

        )

    def _render_ods(self, statement: QueryStatement, row_types: RowTypes, rows: Rows) -> None:

        logger.info(

            "%s rows of results saved in sheet %s",

            len(rows),

            self.ods.sheet.getAttribute('name'),

        )

    def _render_text(self, statement: QueryStatement, row_types: RowTypes, rows: Rows) -> None:

        with contextlib.ExitStack() as stack:

            if self.is_interactive:

                output = stack.enter_context(self.get_pager())

            else:

                output = self.outfile

            bc_query_render.render_text(

                row_types,

                rows,

                self.options_map['dcontext'],

                output,

                self.vars['expand'],

                self.vars['boxed'],

                self.vars['spaced'],

            )

class QueryODS(core.BaseODS[NamedTuple, None]):

    META_FNAMES = frozenset([

        # Names of functions, as defined in Environments, that look up

        # posting metadata that could contain documentation links

        'any_meta',

        'entry_meta',

        'meta',

        'meta_docs',

        'str_meta',

    ])

    def is_empty(self) -> bool:

        return not self.sheet.childNodes

    def section_key(self, row: NamedTuple) -> None:

        return None

    def _generic_cell(self, value: Any) -> odf.table.TableCell:

        if isinstance(value, Iterable) and not isinstance(value, (str, tuple)):

            return self.multiline_cell(value)

        else:

            return self.string_cell('' if value is None else str(value))

    def _inventory_cell(self, value: Inventory) -> odf.table.TableCell:

        return self.balance_cell(core.Balance(pos.units for pos in value))

    def _meta_target(self, target: QueryExpression) -> Optional[MetaKey]:

        """Return the metadata key looked up by this target, if any

        This function takes a parsed target (i.e., what we're SELECTing) and

        recurses it to see whether it's looking up any metadata. If so, it

        returns the key of that metadata. Otherwise it returns None.

        """

        if isinstance(target, bc_query_parser.UnaryOp):

            return self._meta_target(target.operand)

        elif not isinstance(target, bc_query_parser.Function):

            return None

        try:

            operand = target.operands[0]

        except IndexError:

            return None

        if (target.fname in self.META_FNAMES

            and isinstance(operand, bc_query_parser.Constant)):

            return operand.value  # type:ignore[no-any-return]

        else:

            for operand in target.operands:

                retval = self._meta_target(operand)

                if retval is not None:

                    break

            return retval

    def _cell_types(self, statement: QueryStatement, row_types: RowTypes) -> Iterator[CellFunc]:

        """Return functions to create table cells from result rows

        Given a parsed query and the types of return rows, yields a function

        to create a cell for each column in the row, in order. The returned

        functions vary in order to provide the best available formatting for

        different data types.

        """

        if (isinstance(statement, bc_query_parser.Select)

            and isinstance(statement.targets, Sequence)):

            targets = [t.expression for t in statement.targets]

        else:

            # Synthesize something that makes clear we're not loading metadata.

            targets = [bc_query_parser.Column(name) for name, _ in row_types]

        for target, (_, row_type) in zip(targets, row_types):

            meta_key = self._meta_target(target)

            if meta_key is None:

                yield self._cell_type(row_type)

            elif meta_key in data.LINK_METADATA:

                yield self._link_cell_type(row_type)

            else:

                yield self._metadata_cell

        if self.is_empty():

            self.sheet.setAttribute('name', "Query 1")

        else:

            self.use_sheet(f"Query {len(self.document.spreadsheet.childNodes) + 1}")

        for name, row_type in row_types:

            if issubclass(row_type, datetime.date):

                col_width = 1.0

            elif issubclass(row_type, (BeancountAmount, Inventory, Position)):

                col_width = 1.5

            else:

                col_width = 2.0

            col_style = self.column_style(col_width)

            self.sheet.addElement(odf.table.TableColumn(stylename=col_style))

        self.add_row(*(

            self.string_cell(data.Metadata.human_name(name), stylename=self.style_bold)

            for name, _ in row_types

        ))

        self.lock_first_row()

        cell_funcs = list(self._cell_types(statement, row_types))

        for row in rows:

            self.add_row(*(

                cell_func(value)

                for cell_func, value in zip(cell_funcs, row)

            ))

class ReportFormat(enum.Enum):

    TEXT = 'text'

    TXT = TEXT

    CSV = 'csv'

    ODS = 'ods'

class SetCYDates(argparse.Action):

    def __call__(self,

                 parser: argparse.ArgumentParser,

                 namespace: argparse.Namespace,

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

                 option_string: Optional[str]=None,

    ) -> None:

        value = cliutil.year_or_date_arg(str(values))

        if isinstance(value, int):

            value = datetime.date(value, 1, 1)

        namespace.start_date = value

        namespace.stop_date = cliutil.diff_year(value, 1)

class SetFYDates(argparse.Action):

    def __call__(self,

                 parser: argparse.ArgumentParser,

                 namespace: argparse.Namespace,

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

                 option_string: Optional[str]=None,

    ) -> None:

        value = cliutil.year_or_date_arg(str(values))

        namespace.start_date = value

        # The configuration hasn't been loaded, so we don't know the boundaries

        # of a fiscal year yet. But that's okay, because we just need to set

        # enough so that when these arguments are passed to a BooksLoader,

        # it'll load the right fiscal year.

        if isinstance(value, int):

            namespace.stop_date = value

        else:

            namespace.stop_date = value + datetime.timedelta(days=1)

        default=[],

        help="""Query to run non-interactively. If none is provided, and

standard input is not a terminal, reads the query from stdin instead.

""")

    return parser.parse_args(arglist)

def main(arglist: Optional[Sequence[str]]=None,

         stdout: TextIO=sys.stdout,

         stderr: TextIO=sys.stderr,

         config: Optional[configmod.Config]=None,

) -> int:

    args = parse_arguments(arglist)

    cliutil.set_loglevel(logger, args.loglevel)

    if config is None:

        config = configmod.Config()

        config.load_file()

    query = ' '.join(args.query).strip()

    if not query and not sys.stdin.isatty():

        query = sys.stdin.read().strip()

    if args.report_type is None:

        try:

            args.report_type = ReportFormat[args.output_file.suffix[1:].upper()]

        except (AttributeError, KeyError):

            args.report_type = ReportFormat.ODS if query else ReportFormat.TEXT

    load_func = BooksLoader(

        config.books_loader(),

        args.start_date,

        args.stop_date,

        [rewrite.RewriteRuleset.from_yaml(path) for path in args.rewrite_rules],

    )

    shell = BQLShell(

        not query,

        load_func,

        stdout,

        args.report_type.value,

        args.numberify,

        config.rt_wrapper(),

    )

    shell.on_Reload()

    if query:

        shell.onecmd(query)

    else:

        shell.cmdloop()

    if not shell.ods.is_empty():

        shell.ods.set_common_properties(config.books_repo())

        if args.output_file is None:

            out_dir_path = config.repository_path() or Path()

            args.output_file = out_dir_path / 'QueryResults_{}.ods'.format(

                datetime.datetime.now().isoformat(timespec='seconds'),

            )

            logger.info("Writing spreadsheet to %s", args.output_file)

        ods_file = cliutil.bytes_output(args.output_file, stdout)

        shell.ods.save_file(ods_file)

    return cliutil.ExitCode.OK

entry_point = cliutil.make_entry_point(__name__, PROGNAME)

if __name__ == '__main__':

    exit(entry_point())

#!/usr/bin/env python3

from setuptools import setup

setup(

    name='conservancy_beancount',

    description="Plugin, library, and reports for reading Conservancy's books",

    author='Software Freedom Conservancy',

    author_email='info@sfconservancy.org',

    license='GNU AGPLv3+',

    install_requires=[

        'babel>=2.6',  # Debian:python3-babel

        'beancount>=2.2',  # Debian:beancount

        'GitPython>=2.0',  # Debian:python3-git

        # 1.4.1 crashes when trying to save some documents.

        'odfpy>=1.4.0,!=1.4.1',  # Debian:python3-odf

        'pdfminer.six>=20200101',

        'PyYAML>=3.0',  # Debian:python3-yaml

        'regex',  # Debian:python3-regex

        'rt>=2.0',

    ],

    setup_requires=[

        'pytest-mypy',

        'pytest-runner',  # Debian:python3-pytest-runner

    ],

    tests_require=[

        'mypy>=0.770',  # Debian:python3-mypy

        'pytest',  # Debian:python3-pytest

    ],

    packages=[

        'conservancy_beancount',

        'conservancy_beancount.pdfforms',

        'conservancy_beancount.pdfforms.extract',

        'conservancy_beancount.plugin',

        'conservancy_beancount.reconcile',

        'conservancy_beancount.reports',

        'conservancy_beancount.tools',

    ],

    entry_points={

        'console_scripts': [

            'accrual-report = conservancy_beancount.reports.accrual:entry_point',

            'assemble-audit-reports = conservancy_beancount.tools.audit_report:entry_point',

            'balance-sheet-report = conservancy_beancount.reports.balance_sheet:entry_point',

            'budget-report = conservancy_beancount.reports.budget:entry_point',

            'bean-sort = conservancy_beancount.tools.sort_entries:entry_point',

            'extract-odf-links = conservancy_beancount.tools.extract_odf_links:entry_point',

            'fund-report = conservancy_beancount.reports.fund:entry_point',

            'ledger-report = conservancy_beancount.reports.ledger:entry_point',

            'opening-balances = conservancy_beancount.tools.opening_balances:entry_point',

            'pdfform-extract = conservancy_beancount.pdfforms.extract:entry_point',

            'pdfform-extract-irs990scheduleA = conservancy_beancount.pdfforms.extract.irs990scheduleA:entry_point',

            'pdfform-fill = conservancy_beancount.pdfforms.fill:entry_point',

            'query-report = conservancy_beancount.reports.query:entry_point',