# 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/>.

from typing import (

    Iterable,

)

class Error(Exception):

        self.message = message

        self.entry = entry

        return "{clsname}<{source[filename]}:{source[lineno]}: {message}>".format(

            clsname=type(self).__name__,

            message=self.message,

            source=self.source,

        )

        source.setdefault('filename', filename)

        source.setdefault('lineno', lineno)

Iter = Iterable[Error]

class BrokenLinkError(Error):

        super().__init__(

            "{} not found in repository: {}".format(key, link),

            txn,

            source,

        )

class BrokenRTLinkError(Error):

        if parsed:

            msg_fmt = "{} not found in RT: {}"

        else:

            msg_fmt = "{} link is malformed: {}"

        super().__init__(

            msg_fmt.format(key, link),

            txn,

            source,

        )

class ConfigurationError(Error):

        if source is None:

            source = {}

        self._fill_source(source)

        super().__init__(message, entry, source)

class InvalidMetadataError(Error):

        if post is None:

            srcname = 'transaction'

        else:

            srcname = post.account

        if value is None:

            msg = "{} missing {}".format(srcname, key)

        elif isinstance(value, need_type):

            msg = "{} has invalid {}: {}".format(srcname, key, value)

        else:

            msg = "{} has wrong type of {}: expected {} but is a {}".format(

                srcname, key, need_type.__name__, type(value).__name__,

            )

class Hook(Generic[Entry], metaclass=abc.ABCMeta):

    DIRECTIVE: Type[Directive]

    HOOK_GROUPS: FrozenSet[HookName] = frozenset()

    def __init__(self, config: configmod.Config) -> None:

        pass

        # Subclasses that need configuration should override __init__ to check

        # and store it.

    @abc.abstractmethod

    def run(self, entry: Entry) -> errormod.Iter: ...

TransactionHook = Hook[Transaction]

### HELPER CLASSES

class LessComparable(metaclass=abc.ABCMeta):

    @abc.abstractmethod

    def __le__(self, other: Any) -> bool: ...

    @abc.abstractmethod

    def __lt__(self, other: Any) -> bool: ...

from . import core

from .. import config as configmod

from .. import data

from .. import errors as errormod

from ..beancount_types import (

    MetaValueEnum,

    Transaction,

)

from typing import (

    Any,

    Dict,

    Optional,

    Set,

)

class MetaProject(core._NormalizePostingMetadataHook):

    DEFAULT_PROJECT = 'Conservancy'

    PROJECT_DATA_PATH = Path('Projects', 'project-data.yml')

    VALUES_ENUM = core.MetadataEnum('project', {DEFAULT_PROJECT})

    def __init__(self, config: configmod.Config, source_path: Path=PROJECT_DATA_PATH) -> None:

        repo_path = config.repository_path()

        if repo_path is None:

        project_data_path = repo_path / source_path

        source = {'filename': str(project_data_path)}

        try:

            with project_data_path.open() as yaml_file:

                project_data: Dict[str, Dict[str, Any]] = yaml.safe_load(yaml_file)

            names: Set[MetaValueEnum] = {self.DEFAULT_PROJECT}

            aliases: Dict[MetaValueEnum, MetaValueEnum] = {}

            for key, params in project_data.items():

                name = params.get('accountName', key)

                names.add(name)

                human_name = params.get('humanName', name)

                if name != human_name:

                    aliases[human_name] = name

                if name != key:

                    aliases[key] = name

        except AttributeError:

            self._config_error("loaded YAML data not in project-data format", project_data_path)

        except OSError as error:

            self._config_error(error.strerror, project_data_path)

        except yaml.error.YAMLError as error:

            self._config_error(error.args[0] or "YAML load error", project_data_path)

        else:

            self.VALUES_ENUM = core.MetadataEnum(self.METADATA_KEY, names, aliases)

        source = {}

        if filename is not None:

            source['filename'] = str(filename)

        raise errormod.ConfigurationError(

            "cannot load project data: " + msg,

            source=source,

        )

    def _run_on_post(self, txn: Transaction, post: data.Posting) -> bool:

        return post.account.is_under('Assets', 'Liabilities') is None

    def _default_value(self, txn: Transaction, post: data.Posting) -> MetaValueEnum:

        self.url_base = urlparts._replace(path=base_path)

        self.rt = rt_client

        self._cache: _LinkCache

        if cache_db is None:

            self._cache = {}

        else:

            self._cache = RTLinkCache(cache_db)

    # mypy complains that the first argument isn't self, but this isn't meant

    # to be a method, it's just an internal decrator.

    def _cache_method(func: _URLLookup) -> _URLLookup:  # type:ignore[misc]

        @functools.wraps(func)

                            ticket_id: RTId,

                            attachment_id: Optional[RTId]=None,

        ) -> Optional[str]:

            url: Optional[str]

            try:

                url = self._cache[cache_key]

            except KeyError:

                if attachment_id is None:

                    url = func(self, ticket_id)

                else:

                    url = func(self, ticket_id, attachment_id)

                self._cache[cache_key] = url

            return url

        return caching_wrapper

[aliases]

test=pytest

typecheck=pytest --addopts="--mypy conservancy_beancount"

[mypy]

disallow_any_unimported = True

show_error_codes = True

strict_equality = True

warn_redundant_casts = True

warn_return_any = True

warn_unreachable = True

warn_unused_configs = True