dcicutils 7.6.0.2b9__tar.gz → 7.7.0.1b1__tar.gz

{dcicutils-7.6.0.2b9 → dcicutils-7.7.0.1b1}/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright 2017-2023 President and Fellows of Harvard College
+Copyright 2017 President and Fellows of Harvard College.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{dcicutils-7.6.0.2b9 → dcicutils-7.7.0.1b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dcicutils
-Version: 7.6.0.2b9
+Version: 7.7.0.1b1
 Summary: Utility package for interacting with the 4DN Data Portal and other 4DN resources
 Home-page: https://github.com/4dn-dcic/utils
 License: MIT

dcicutils-7.7.0.1b1/dcicutils/item_model_utils.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from functools import lru_cache
+from typing import Any, Dict, Iterable, List, Mapping, Optional, Tuple, Union
+
+import structlog
+
+from . import ff_utils
+
+
+logger = structlog.getLogger(__name__)
+
+LinkTo = Union[str, Dict[str, Any]]
+
+
+def get_link_to(
+    existing_item: PortalItem,
+    link_to: LinkTo,
+    item_to_create: PortalItem,
+) -> Union[str, PortalItem]:
+    """Create new item model from existing one for given linkTo.
+
+    LinkTos be identifiers (e.g. UUIDs) or (partially) embedded objects.
+
+    Follow rules of existing item model for fetching linkTo via
+    request. If not fetching via request, then make item model from
+    existing properties if possible.
+    """
+    fetch_links = existing_item.should_fetch_links()
+    identifier = get_item_identifier(link_to)
+    if fetch_links and identifier:
+        return item_to_create.from_identifier_and_existing_item(
+            identifier, existing_item
+        )
+    if isinstance(link_to, Mapping):
+        return item_to_create.from_properties_and_existing_item(link_to, existing_item)
+    return link_to
+
+
+def get_item_identifier(item: LinkTo) -> str:
+    if isinstance(item, str):
+        return item
+    if isinstance(item, Mapping):
+        return item.get(PortalItem.UUID, "")
+
+
+@dataclass(frozen=True)
+class PortalItem:
+    ACCESSION = "accession"
+    AT_ID = "@id"
+    TYPE = "@type"
+    UUID = "uuid"
+
+    properties: Dict[str, Any]
+    auth: Optional[Dict[str, Any]] = field(default=None, hash=False)
+    fetch_links: Optional[bool] = field(default=False, hash=False)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self._uuid})"
+
+    @property
+    def _uuid(self) -> str:
+        return self.properties.get(self.UUID, "")
+
+    @property
+    def _at_id(self) -> str:
+        return self.properties.get(self.AT_ID, "")
+
+    @property
+    def _accession(self) -> str:
+        return self.properties.get(self.ACCESSION, "")
+
+    @property
+    def _types(self) -> List[str]:
+        return self.properties.get(self.TYPE, [])
+
+    def should_fetch_links(self) -> bool:
+        return self.fetch_links
+
+    def get_auth(self) -> Union[Dict[str, Any], None]:
+        return self.auth
+
+    def get_properties(self) -> Dict[str, Any]:
+        return self.properties
+
+    def get_accession(self) -> str:
+        return self._accession
+
+    def get_uuid(self) -> str:
+        return self._uuid
+
+    def get_at_id(self) -> str:
+        return self._at_id
+
+    def get_types(self) -> List[str]:
+        return self._types
+
+    def _get_link_tos(
+        self, link_tos: Iterable[LinkTo], item_to_create: PortalItem
+    ) -> List[Union[str, PortalItem]]:
+        return [self._get_link_to(link_to, item_to_create) for link_to in link_tos]
+
+    def _get_link_to(
+        self,
+        link_to: LinkTo,
+        item_to_create: PortalItem,
+    ) -> Union[str, PortalItem]:
+        return get_link_to(self, link_to, item_to_create)
+
+    @classmethod
+    def from_properties(
+        cls,
+        properties: Dict[str, Any],
+        fetch_links: bool = False,
+        auth: Dict[str, Any] = None,
+        **kwargs: Any,
+    ) -> PortalItem:
+        return cls(properties, fetch_links=fetch_links, auth=auth)
+
+    @classmethod
+    def from_identifier_and_auth(
+        cls, identifier: str, auth: Dict[str, Any], fetch_links=False, **kwargs: Any
+    ) -> PortalItem:
+        properties = cls._get_item_via_auth(identifier, auth)
+        return cls.from_properties(properties, auth=auth, fetch_links=fetch_links)
+
+    @classmethod
+    def _get_item_via_auth(
+        cls,
+        identifier: str,
+        auth: Dict[str, Any],
+        add_on: Optional[str] = "frame=object",
+    ) -> Dict[str, Any]:
+        hashable_auth = cls._make_hashable_auth(auth)
+        return cls._get_and_cache_item_via_auth(identifier, hashable_auth, add_on)
+
+    @classmethod
+    def _make_hashable_auth(cls, auth: Mapping[str, str]) -> Tuple[Tuple[str, str]]:
+        """Assuming nothing nested here."""
+        return tuple(auth.items())
+
+    @classmethod
+    def _undo_make_hashable_auth(
+        cls, hashable_auth: Tuple[Tuple[str, str]]
+    ) -> Dict[str, Any]:
+        return dict(hashable_auth)
+
+    @classmethod
+    @lru_cache(maxsize=256)
+    def _get_and_cache_item_via_auth(
+        cls,
+        identifier: str,
+        hashable_auth: Tuple[Tuple[str, Any]],
+        add_on: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Save on requests by caching items."""
+        auth = cls._undo_make_hashable_auth(hashable_auth)
+        try:
+            result = ff_utils.get_metadata(identifier, key=auth, add_on=add_on)
+        except Exception as e:
+            result = {}
+            logger.error(f"Error getting metadata for {identifier}: {e}")
+        return result
+
+    @classmethod
+    def from_identifier_and_existing_item(
+        cls, identifier: str, existing_item: PortalItem, **kwargs: Any
+    ) -> PortalItem:
+        fetch_links = existing_item.should_fetch_links()
+        auth = existing_item.get_auth()
+        if auth:
+            return cls.from_identifier_and_auth(
+                identifier, auth, fetch_links=fetch_links
+            )
+        raise RuntimeError("Unable to fetch given identifier without auth key")
+
+    @classmethod
+    def from_properties_and_existing_item(
+        cls, properties: Dict[str, Any], existing_item: PortalItem, **kwargs: Any
+    ) -> PortalItem:
+        fetch_links = existing_item.should_fetch_links()
+        auth = existing_item.get_auth()
+        return cls.from_properties(properties, fetch_links=fetch_links, auth=auth)
+
+
+@dataclass(frozen=True)
+class NestedProperty:
+    properties: Dict[str, Any]
+    parent_item: Optional[PortalItem] = field(default=None, hash=False)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(parent={self.parent_item.__repr__()})"
+
+    def get_properties(self) -> Dict[str, Any]:
+        return self.properties
+
+    def get_parent_item(self) -> Union[PortalItem, None]:
+        return self.parent_item
+
+    def _get_link_tos(
+        self, link_tos: LinkTo, item_to_create: PortalItem
+    ) -> List[Union[str, PortalItem]]:
+        return [self._get_link_to(link_to, item_to_create) for link_to in link_tos]
+
+    def _get_link_to(
+        self,
+        link_to: LinkTo,
+        item_to_create: PortalItem,
+    ) -> Union[str, PortalItem]:
+        if self.parent_item:
+            return get_link_to(self.parent_item, link_to, item_to_create)
+        if isinstance(link_to, Mapping):
+            return item_to_create.from_properties(link_to)
+        return link_to
+
+    @classmethod
+    def from_properties(
+        cls,
+        properties: Dict[str, Any],
+        parent_item: Optional[PortalItem] = None,
+        **kwargs: Any,
+    ) -> NestedProperty:
+        return cls(properties, parent_item=parent_item)

{dcicutils-7.6.0.2b9 → dcicutils-7.7.0.1b1}/dcicutils/lang_utils.py

@@ -198,13 +198,13 @@ class EnglishUtils:
     _PREFIX_PATTERN_FOR_A = re.compile("^(%s)" % "|".join({
         "[^aeioux]",  # Consonants other than x need 'a' (bicycle, dog, etc.)
         "x[aeiouy]",  # x followed by any vowel makes it pronounceable like a consonant (xylophone), so needs 'a'
-        "uni([^aeiuym]|[aeiuy][^aeiy])",  # things starting with "uni" are pronounced like "yuni", so need "a"
+        "uni([^aeiuym]|[aeiuy][^aeiy])",  # things starting with with "uni" are pronounced like "yuni", so need "a"
     }), flags=re.IGNORECASE)
 
     @classmethod
     def select_a_or_an(cls, word):
         """
-        Uses a heuristic to try to select the appropriate article ("a" or "an") for a given English noun.
+        Uses a heuristic to try to select the appropriate article ('a' or 'an') for a given English noun.
         select_a_or_an("gene") => 'a'
         select_a_or_an("accession") => 'an'
         """
@@ -278,7 +278,7 @@ class EnglishUtils:
         "Possible options are foo, bar and baz."
 
         :param items: the items to enumerate
-        :param possible: whether to use the word 'possible' before the given kind (default True), or a string to use
+        :param possible: whether to use the word 'possible' before the given kind (default True), or an string to use
         :param kind: the kind of items being enumerated (default "option")
         :param quote: whether to put quotes around each option
         :param capitalize: whether to capitalize the first letter of the sentence (default True)
@@ -351,7 +351,7 @@ class EnglishUtils:
     @classmethod
     def there_are(cls, items, *, kind: str = "thing", count: Optional[int] = None, there: str = "there",
                   capitalize=True, joiner=None, zero: object = "no", punctuate=None, punctuate_none=None,
-                  use_article=False, show=True, context=None, tense='present', punctuation_mark: str = ".",
+                  use_article=False, show=True, context=None, tense='present',
                   **joiner_options) -> str:
         """
         Constructs a sentence that enumerates a set of things.
@@ -366,7 +366,6 @@ class EnglishUtils:
         :param punctuate: in the case of one or more values (not zero), whether to end with a period (default False)
         :param punctuate_none: in the case of no values or not showing values, whether to end with a period
                (default True if show is True, and otherwise is the same as the value of punctuate)
-        :param punctuation_mark: if specified, something to use at the end if punctuating
         :param use_article: whether to put 'a' or 'an' in front of each option (default False)
         :param joiner_options: additional (keyword) options to be used with a joiner function if one is supplied
         :param show: whether to show the items if there are any (default True)
@@ -407,7 +406,7 @@ class EnglishUtils:
         if context:
             part1 += f" {context}"
         if n == 0 or not show:
-            punctuation = punctuation_mark if punctuate_none else ""
+            punctuation = "." if punctuate_none else ""
             return part1 + punctuation
         else:
             if use_article:
@@ -418,7 +417,7 @@ class EnglishUtils:
                 joined = ", ".join(items)
             else:
                 joined = joiner(items, **joiner_options)
-            punctuation = punctuation_mark if punctuate else ""
+            punctuation = "." if punctuate else ""
             return f"{part1}: {joined}{punctuation}"
 
     @classmethod
@@ -473,7 +472,7 @@ class EnglishUtils:
                              f" of the form '<n1> <unit1> <n2> <unit2>...': {s!r}")
         kwargs = {}
         for i in range(len(parts) // 2):
-            # Canonicalize "1 week" or "1 weeks" to "weeks": 1.0 for inclusion as kwarg to timedelta
+            # Canonicalize "1 week" or "1 weeks" to "weeks": 1.0 for inclusion as kwarg to to timedelta
             # Uses specialized knowledge that all time units don't end in "s" but pluralize with "+s"
             value = float(parts[2 * i])
             units = parts[2 * i + 1].rstrip(',s') + "s"

{dcicutils-7.6.0.2b9 → dcicutils-7.7.0.1b1}/dcicutils/qa_checkers.py

@@ -8,7 +8,6 @@ import warnings
 from collections import defaultdict
 from typing import Optional, List, Dict, Type
 from typing_extensions import Literal
-from .contribution_utils import Contributions
 from .lang_utils import conjoined_list, n_of, there_are
 from .misc_utils import PRINT, remove_prefix, remove_suffix, getattr_customized, CustomizableProperty
 
@@ -437,11 +436,3 @@ def confirm_no_uses(*, where: str, patterns: Dict[str, str],
             detail += f"\n In {file}, {summarize(matches)}."
         message = f"{n_of(n, 'problem')} detected:" + detail
         raise AssertionError(message)
-
-
-class ContributionsChecker:
-
-    @classmethod
-    def validate(cls):
-        contributions = Contributions()  # no repo specified, so use current directory
-        contributions.show_repo_contributors(error_class=AssertionError)

dcicutils-7.7.0.1b1/dcicutils/testing_utils.py

@@ -0,0 +1,37 @@
+from contextlib import contextmanager
+from types import ModuleType
+from typing import Any, Iterator, Optional
+from unittest import mock
+
+
+AN_UNLIKELY_RETURN_VALUE = "unlikely return value"
+
+
+@contextmanager
+def patch_context(
+    to_patch: object,
+    return_value: Any = AN_UNLIKELY_RETURN_VALUE,
+    module: Optional[ModuleType] = None,
+    **kwargs,
+) -> Iterator[mock.MagicMock]:
+    """Mock out the given object.
+
+    Essentially mock.patch_object with some hacks to enable linting
+    on the object to patch instead of providing as a string.
+
+    Depending on import structure, adding the module to patch may be
+    required.
+    """
+    if isinstance(to_patch, property):
+        to_patch = to_patch.fget
+        new_callable = mock.PropertyMock
+    else:
+        new_callable = mock.MagicMock
+    if module is None:
+        target = f"{to_patch.__module__}.{to_patch.__qualname__}"
+    else:
+        target = f"{module.__name__}.{to_patch.__qualname__}"
+    with mock.patch(target, new_callable=new_callable, **kwargs) as mocked_item:
+        if return_value != AN_UNLIKELY_RETURN_VALUE:
+            mocked_item.return_value = return_value
+        yield mocked_item

{dcicutils-7.6.0.2b9 → dcicutils-7.7.0.1b1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dcicutils"
-version = "7.6.0.2b9"
+version = "7.7.0.1b1"
 description = "Utility package for interacting with the 4DN Data Portal and other 4DN resources"
 authors = ["4DN-DCIC Team <support@4dnucleome.org>"]
 license = "MIT"
@@ -70,7 +70,6 @@ coverage = ">=7.2.3"
 # coveralls = ">=3.3.1"
 flake8 = ">=3.9.2"
 flaky = ">=3.7.0"
-pip-licenses = "^3.5.5"
 pytest = ">=4.5.0"
 pytest-cov = ">=2.7.1"
 pytest-mock = ">=1.11.0"
@@ -80,18 +79,13 @@ pytest-runner = ">=5.1"
 
 [tool.poetry.scripts]
 publish-to-pypi = "dcicutils.scripts.publish_to_pypi:main"
-show-contributors = "dcicutils.contribution_scripts:show_contributors_main"
+
 
 [tool.pytest.ini_options]
 addopts = "--basetemp=/tmp/pytest"
 redis_exec = "/usr/local/bin/redis-server"
 filterwarnings = [
-    # TODO: These next two are about use of the Version class:
-    "ignore:distutils Version classes are deprecated. Use packaging.version instead.:DeprecationWarning",
-    "ignore:Setuptools is replacing distutils.:UserWarning",
-    # This is a pip-licenses problem (still present in 3.5.5):
-    "ignore:pkg_resources is deprecated as an API:DeprecationWarning",
-    "ignore:Boto3 will no longer support Python 3.7 starting December 13, 2023.*:",
+    "ignore::DeprecationWarning: distutils Version classes are deprecated. Use packaging.version instead.",
 ]
 markers = [
     "working: test should work",

{dcicutils-7.6.0.2b9 → dcicutils-7.7.0.1b1}/setup.py

@@ -33,13 +33,12 @@ install_requires = \
  'webtest>=2.0.34,<3.0.0']
 
 entry_points = \
-{'console_scripts': ['publish-to-pypi = dcicutils.scripts.publish_to_pypi:main',
-                     'show-contributors = '
-                     'dcicutils.contribution_scripts:show_contributors_main']}
+{'console_scripts': ['publish-to-pypi = '
+                     'dcicutils.scripts.publish_to_pypi:main']}
 
 setup_kwargs = {
     'name': 'dcicutils',
-    'version': '7.6.0.2b9',
+    'version': '7.7.0.1b1',
     'description': 'Utility package for interacting with the 4DN Data Portal and other 4DN resources',
     'long_description': '=====\nutils\n=====\n\nCheck out our full documentation `here <https://dcic-utils.readthedocs.io/en/latest/>`_\n\nThis repository contains various utility modules shared amongst several projects in the 4DN-DCIC. It is meant to be used internally by the DCIC team and externally as a Python API to `Fourfront <https://data.4dnucleome.org>`_\\ , the 4DN data portal.\n\npip installable as the ``dcicutils`` package with: ``pip install dcicutils``\n\nSee `this document <https://dcic-utils.readthedocs.io/en/latest/getting_started.html>`_ for tips on getting started. `Go here <https://dcic-utils.readthedocs.io/en/latest/examples.html>`_ for examples of some of the most useful functions.\n\n\n.. image:: https://travis-ci.org/4dn-dcic/utils.svg?branch=master\n   :target: https://travis-ci.org/4dn-dcic/utils\n   :alt: Build Status\n\n\n.. image:: https://coveralls.io/repos/github/4dn-dcic/utils/badge.svg?branch=master\n   :target: https://coveralls.io/github/4dn-dcic/utils?branch=master\n   :alt: Coverage\n\n.. image:: https://readthedocs.org/projects/dcic-utils/badge/?version=latest\n   :target: https://dcic-utils.readthedocs.io/en/latest/?badge=latest\n   :alt: Documentation Status\n',
     'author': '4DN-DCIC Team',

dcicutils-7.6.0.2b9/dcicutils/contribution_scripts.py

@@ -1,39 +0,0 @@
-import argparse
-
-from dcicutils.command_utils import script_catch_errors, ScriptFailure
-from .contribution_utils import Contributions, PROJECT_HOME
-
-
-EPILOG = __doc__
-
-
-def show_contributors(repo, exclude_fork=None, verbose=False, save_contributors=False, test=False):
-    contributions = Contributions(repo=repo, exclude_fork=exclude_fork, verbose=verbose)
-    if save_contributors:
-        contributions.save_contributor_data()
-    contributions.show_repo_contributors(error_class=ScriptFailure if test else None)
-
-
-def show_contributors_main(*, simulated_args=None):
-    parser = argparse.ArgumentParser(  # noqa - PyCharm wrongly thinks the formatter_class is specified wrong here.
-        description=(f"Show authors of a specified repository, which will be presumed"
-                     f" to have been cloned as a subdirectory of $PROJECT_HOME ({PROJECT_HOME})"),
-        epilog=EPILOG,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    parser.add_argument('repo', default=None,
-                        help="name of repository to show contributors for")
-    parser.add_argument('--exclude', '-x', default=None,
-                        help="name of repository that repo was forked from, whose contributors to exclude")
-    parser.add_argument('--save-contributors', '-s', action="store_true", default=False,
-                        help="whether to store contributor data to CONTRIBUTORS.json")
-    parser.add_argument('--test', '-t', action="store_true", default=False,
-                        help="whether to treat this as a test, erring if a cache update is needed")
-    parser.add_argument('--verbose', '-v', action="store_true", default=False,
-                        help="whether to do verbose output while working")
-    args = parser.parse_args(args=simulated_args)
-
-    with script_catch_errors():
-
-        show_contributors(repo=args.repo, exclude_fork=args.exclude, verbose=args.verbose,
-                          save_contributors=args.save_contributors, test=args.test)