db_conn = sqlite3.connect(os.fspath(repo_path / cls.db_path))

        except (OSError, sqlite3.Error):

            columns['db_email'] = DBEmail

            columns['db_id'] = DBId

            columns['db_postal'] = DBPostal

        else:

            columns['db_email'] = DBEmail.with_db(db_conn)

            columns['db_id'] = DBId.with_db(db_conn)

            columns['db_postal'] = DBPostal.with_db(db_conn)

        rt_credentials = config.rt_credentials()

        rt_client = config.rt_client(rt_credentials)

        if rt_client is None:

            rt_ticket = RTTicket

        else:

            rt_ticket = RTTicket.with_client(rt_client, rt_credentials.idstr())

        functions = cls.functions.copy()

        functions[('rt_ticket', str, str)] = rt_ticket

        functions[('rt_ticket', str, str, int)] = rt_ticket

        return type(cls.__name__, (cls,), {

            'columns': columns,

            'functions': functions,

        })

class FilterPostingsEnvironment(bc_query_env.FilterPostingsEnvironment, _EnvironmentMixin):

    columns: EnvironmentColumns  # type:ignore[assignment]

    functions: EnvironmentFunctions = bc_query_env.FilterPostingsEnvironment.functions.copy()  # type:ignore[assignment]

    functions['meta_docs'] = MetaDocs

    functions['str_meta'] = StrMeta

class TargetsEnvironment(bc_query_env.TargetsEnvironment, _EnvironmentMixin):

    columns: EnvironmentColumns  # type:ignore[assignment]

    functions: EnvironmentFunctions = FilterPostingsEnvironment.functions.copy()  # type:ignore[assignment]

    functions.update(bc_query_env.AGGREGATOR_FUNCTIONS)

    functions['set'] = AggregateSet

class BooksLoader:

    """Closure to load books with a zero-argument callable

    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,

            config: configmod.Config,

            is_interactive: bool,

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

            outfile: TextIO,

            default_format: str='text',

            do_numberify: bool=False,

    ) -> None:

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

        rt_credentials = config.rt_credentials()

        rt_key = rt_credentials.idstr()

        rt_client = config.rt_client(rt_credentials)

        self.env_postings = FilterPostingsEnvironment.with_config(config)()

        self.env_targets = TargetsEnvironment.with_config(config)()

        self.ods = QueryODS(config.rt_wrapper(rt_credentials))

        self.last_line_parsed = ''

    def run_parser(

            self,

            line: str,

            default_close_date: Optional[datetime.datetime]=None,

    ) -> None:

        self.last_line_parsed = line

        super().run_parser(line, default_close_date)

    @functools.wraps(bc_query_shell.BQLShell.on_Select, ('__doc__',))

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

            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:

        self.ods.write_query(statement, row_types, rows, self.last_line_parsed)

        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 _link_string_cell(self, value: str) -> odf.table.TableCell:

        return self.meta_links_cell(value.split())

    def _metadata_cell(self, value: MetaValue) -> odf.table.TableCell:

        return self._cell_type(type(value))(value)

    def _position_cell(self, value: Position) -> odf.table.TableCell:

        return self.currency_cell(value.units)

    def _cell_type(self, row_type: Type) -> CellFunc:

        """Return a function to create a cell, for non-metadata row types."""

        if issubclass(row_type, Inventory):

            return self._inventory_cell

        elif issubclass(row_type, Position):

            return self._position_cell

        elif issubclass(row_type, BeancountAmount):

            return self.currency_cell

        elif issubclass(row_type, (int, float, Decimal)):

            return self.float_cell

        elif issubclass(row_type, datetime.date):

            return self.date_cell

        elif issubclass(row_type, str):

            return self.string_cell

        else:

            return self._generic_cell

    def _link_cell_type(self, row_type: Type) -> CellFunc:

        """Return a function to create a cell from metadata with documentation links."""

        if issubclass(row_type, str):

            return self._link_string_cell

        elif issubclass(row_type, tuple):

            return self._generic_cell

        elif issubclass(row_type, Iterable):

            return self.meta_links_cell

        else:

            return self._generic_cell

    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

#!/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',

        'python-dateutil>=2.7',  # Debian:python3-dateutil

        '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',

            'reconcile-paypal = conservancy_beancount.reconcile.paypal:entry_point',

            'reconcile-statement = conservancy_beancount.reconcile.statement:entry_point',

            'split-ods-links = conservancy_beancount.tools.split_ods_links:entry_point',

        ],

    },

)