codegrade 16.1.89__tar.gz → 16.1.91__tar.gz

{codegrade-16.1.89 → codegrade-16.1.91}/PKG-INFO

@@ -1,20 +1,15 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: codegrade
-Version: 16.1.89
+Version: 16.1.91
 Summary: A client library for accessing CodeGrade
-License: AGPL-3.0-only OR BSD-3-Clause-Clear
-Requires-Python: >=3.9.0,<4.0
-Classifier: License :: Other/Proprietary License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Requires-Dist: httpx (>=0.19.0,<1.0.0)
-Requires-Dist: python-dateutil (>=2.8.1,<3.0.0)
-Requires-Dist: structlog (>=20.1.0,<21.0.0)
-Requires-Dist: typing-extensions (>=4.0.0.0,<5.0.0.0)
-Requires-Dist: validate-email (>=1.3,<2.0)
 Project-URL: Documentation, https://python.api.codegrade.com
+License-Expression: AGPL-3.0-only OR BSD-3-Clause-Clear
+Requires-Python: <4.0,>=3.8.0
+Requires-Dist: httpx<1.0.0,>=0.19.0
+Requires-Dist: python-dateutil<3,>=2.8.1
+Requires-Dist: structlog<21,>=20.1.0
+Requires-Dist: typing-extensions<5,>=4.13.2
+Requires-Dist: validate-email~=1.3
 Description-Content-Type: text/markdown
 
 # CodeGrade API
@@ -79,4 +74,4 @@ month. To upgrade simply run `pip install --upgrade codegrade`.
 We support python 3.6 and above, `pypy` is currently not tested but should work
 just fine.
 ## License
-The library is licensed under AGPL-3.0-only or BSD-3-Clause-Clear.
+The library is licensed under AGPL-3.0-only or BSD-3-Clause-Clear.

{codegrade-16.1.89 → codegrade-16.1.91}/cg_dt_utils/__init__.py

@@ -1,76 +1,71 @@
-"""This module defines functions and methods to work with datetime objects.
+"""This module defines functions and methods to work with datetime objects."""
 
-
-"""
+import datetime
 import enum
 import time
 import typing as t
-import datetime
 
-__all__ = ['DatetimeWithTimezone', 'now']
+# ruff: noqa: D101, D102
+
+__all__ = ('DatetimeWithTimezone', 'Months')
 
 if t.TYPE_CHECKING:  # pragma: no cover
 
-    # pylint: disable=all
     class DatetimeWithTimezone:
         max: t.ClassVar['DatetimeWithTimezone']
 
         @classmethod
-        def utcfromtimestamp(cls, timestamp: float) -> 'DatetimeWithTimezone':
-            ...
+        def utcfromtimestamp(
+            cls, timestamp: float
+        ) -> 'DatetimeWithTimezone': ...
 
         @classmethod
-        def utcnow(cls) -> 'DatetimeWithTimezone':
-            ...
+        def utcnow(cls) -> 'DatetimeWithTimezone': ...
 
         @t.overload
-        def __sub__(self, other: 'DatetimeWithTimezone') -> datetime.timedelta:
-            ...
+        def __sub__(
+            self, other: 'DatetimeWithTimezone'
+        ) -> datetime.timedelta: ...
 
         @t.overload
-        def __sub__(self, other: datetime.timedelta) -> 'DatetimeWithTimezone':
-            ...
+        def __sub__(
+            self, other: datetime.timedelta
+        ) -> 'DatetimeWithTimezone': ...
 
-        def __sub__(self, other: t.Any) -> t.Any:
-            ...
+        def __sub__(self, other: t.Any) -> t.Any: ...
 
-        def __add__(self, other: datetime.timedelta) -> 'DatetimeWithTimezone':
-            ...
+        def __add__(
+            self, other: datetime.timedelta
+        ) -> 'DatetimeWithTimezone': ...
 
-        def __lt__(self, other: 'DatetimeWithTimezone') -> bool:
-            ...
+        def __lt__(self, other: 'DatetimeWithTimezone') -> bool: ...
 
-        def __ge__(self, other: 'DatetimeWithTimezone') -> bool:
-            ...
+        def __ge__(self, other: 'DatetimeWithTimezone') -> bool: ...
 
         def isoformat(
             self,
             *,
-            timespec: t.Literal['auto', 'microseconds', 'milliseconds',
-                                'seconds'] = 'auto'
-        ) -> str:
-            ...
+            timespec: t.Literal[
+                'auto', 'microseconds', 'milliseconds', 'seconds'
+            ] = 'auto',
+        ) -> str: ...
 
-        def timestamp(self) -> float:
-            ...
+        def timestamp(self) -> float: ...
 
         @classmethod
-        def fromisoformat(cls, isoformat: str) -> 'DatetimeWithTimezone':
-            ...
+        def fromisoformat(cls, isoformat: str) -> 'DatetimeWithTimezone': ...
 
         @classmethod
         def from_datetime(
             cls, dt: datetime.datetime, default_tz: datetime.timezone
-        ) -> 'DatetimeWithTimezone':
-            ...
+        ) -> 'DatetimeWithTimezone': ...
 
         @classmethod
         def parse_isoformat(
             cls,
             isoformat: str,
             default_tz: datetime.timezone = ...,
-        ) -> 'DatetimeWithTimezone':
-            ...
+        ) -> 'DatetimeWithTimezone': ...
 
         @classmethod
         def combine(
@@ -78,35 +73,27 @@ if t.TYPE_CHECKING:  # pragma: no cover
             date: datetime.date,
             time: datetime.time,
             default_tz: datetime.timezone = ...,
-        ) -> 'DatetimeWithTimezone':
-            ...
+        ) -> 'DatetimeWithTimezone': ...
 
         @staticmethod
-        def as_datetime(dt: 'DatetimeWithTimezone') -> datetime.datetime:
-            ...
+        def as_datetime(dt: 'DatetimeWithTimezone') -> datetime.datetime: ...
 
         @property
-        def year(self) -> int:
-            ...
+        def year(self) -> int: ...
 
         @property
-        def month(self) -> int:
-            ...
+        def month(self) -> int: ...
 
         @property
-        def day(self) -> int:
-            ...
+        def day(self) -> int: ...
 
         @property
-        def hour(self) -> int:
-            ...
+        def hour(self) -> int: ...
 
         @property
-        def minute(self) -> int:
-            ...
+        def minute(self) -> int: ...
 
-        def weekday(self) -> int:
-            ...
+        def weekday(self) -> int: ...
 
         def replace(
             self,
@@ -119,26 +106,18 @@ if t.TYPE_CHECKING:  # pragma: no cover
             second: int = ...,
             microsecond: int = ...,
             fold: int = ...,
-        ) -> 'DatetimeWithTimezone':
-            ...
+        ) -> 'DatetimeWithTimezone': ...
 
-        def strftime(self, format: str) -> str:
-            ...
+        def strftime(self, format: str) -> str: ...
 
-    # pylint: enable=all
 else:
-
     # Warning, this class is not actually used during runtime, and is only
     # present for type checking (to make sure we only use dates with a timezone
     # attached). So do not instantiate it, as this could make it easy to do a
     # `isinstance` check, but feel free to implement real static methods.
 
-    # pylint: disable=invalid-name
     _utc = datetime.timezone.utc
-    _utcfromtimestamp = datetime.datetime.utcfromtimestamp
-
-    # pylint: enable=invalid-name
-
+    _fromtimestamp = datetime.datetime.fromtimestamp
 
     class DatetimeWithTimezone(datetime.datetime):
         @staticmethod
@@ -154,7 +133,7 @@ else:
 
         @staticmethod
         def utcfromtimestamp(timestamp: float) -> 'DatetimeWithTimezone':
-            return _utcfromtimestamp(timestamp).replace(tzinfo=_utc)
+            return _fromtimestamp(timestamp, tz=_utc)
 
         @classmethod
         def parse_isoformat(
@@ -162,7 +141,8 @@ else:
             isoformat: str,
             default_tz: datetime.timezone = _utc,
         ) -> 'DatetimeWithTimezone':
-            import dateutil.parser  # pylint: disable=import-outside-toplevel
+            import dateutil.parser
+
             dt = dateutil.parser.isoparse(isoformat)
             return cls.from_datetime(dt, default_tz=default_tz)
 

codegrade-16.1.91/cg_maybe/__init__.py

@@ -0,0 +1,9 @@
+"""This module implements the ``Maybe`` monad."""
+
+from . import utils as utils
+from ._just import Just as Just
+from ._maybe import Maybe as Maybe
+from ._nothing import Nothing as Nothing
+from ._nothing import _Nothing as _Nothing
+from .utils import from_nullable as from_nullable
+from .utils import of as of

{codegrade-16.1.89 → codegrade-16.1.91}/cg_maybe/_just.py

@@ -1,27 +1,26 @@
-"""This module implements the ``Just`` part of the ``Maybe`` monad.
-"""
+"""This module implements the ``Just`` part of the ``Maybe`` monad."""
+
 import os
 import typing as t
 
 from ._nothing import Nothing, _Nothing
 from ._type_helpers import Final, Literal
-from ._type_helpers import SupportsLessThan as _SupportsLessThan
 from ._type_helpers import SupportsGreaterOrEqual as _SupportsGreaterOrEqual
+from ._type_helpers import SupportsLessThan as _SupportsLessThan
 
 if t.TYPE_CHECKING or os.getenv('CG_GENERATING_DOCS'):  # pragma: no cover
-    # pylint: disable=unused-import,invalid-name
     import cg_maybe
 
 _T = t.TypeVar('_T', covariant=True)
-_TT = t.TypeVar('_TT', covariant=True)  # pylint: disable=invalid-name
+_TT = t.TypeVar('_TT', covariant=True)
 _Y = t.TypeVar('_Y')
 _Z = t.TypeVar('_Z')
 
 
 class Just(t.Generic[_T]):
-    """The just part of the Maybe monad.
-    """
-    __slots__ = ('value', )
+    """The just part of the Maybe monad."""
+
+    __slots__ = ('value',)
 
     is_just: Literal[True] = True
     is_nothing: Literal[False] = False
@@ -47,7 +46,7 @@ class Just(t.Generic[_T]):
     def map_or_default(
         self,
         mapper: t.Callable[[_T], _Y],
-        default: _Z,  # pylint: disable=unused-argument
+        default: _Z,
     ) -> _Y:
         """Transform this just by applying ``mapper`` to its argument and
         return the result.
@@ -105,8 +104,8 @@ class Just(t.Generic[_T]):
         :param chainer: The function that will be called if this method is
             called on ``Just``. It should return a Optional value.
         """
-        # pylint: disable=import-outside-toplevel
         from .utils import from_nullable
+
         return from_nullable(chainer(self.value))
 
     def __repr__(self) -> str:
@@ -117,7 +116,7 @@ class Just(t.Generic[_T]):
 
     def alt(
         self,
-        alternative: 'cg_maybe._maybe.Maybe[_T]',  # pylint: disable=unused-argument
+        alternative: 'cg_maybe._maybe.Maybe[_T]',
     ) -> 'cg_maybe._maybe.Maybe[_T]':
         """Return the given ``alternative`` if called on a ``Nothing``,
         otherwise the method returns the value it is called on.
@@ -135,7 +134,7 @@ class Just(t.Generic[_T]):
 
     def alt_lazy(
         self,
-        maker: t.Callable[[], 'cg_maybe._maybe.Maybe[_Y]'],  # pylint: disable=unused-argument
+        maker: t.Callable[[], 'cg_maybe._maybe.Maybe[_Y]'],
     ) -> 'cg_maybe._maybe.Maybe[t.Union[_Y, _T]]':
         """Return the result of ``maker`` if called on a ``Nothing``, otherwise
         the method returns the value it is called on.
@@ -165,7 +164,7 @@ class Just(t.Generic[_T]):
         """
         return self.value
 
-    def or_default_lazy(self, producer: t.Callable[[], _Y]) -> _T:  # pylint: disable=unused-argument
+    def or_default_lazy(self, producer: t.Callable[[], _Y]) -> _T:
         """Get the value from a ``Just``, or return the given a default as
         produced by the given function.
 
@@ -181,7 +180,7 @@ class Just(t.Generic[_T]):
         """
         return self.value
 
-    def or_default(self, value: _Y) -> _T:  # pylint: disable=unused-argument
+    def or_default(self, value: _Y) -> _T:
         """Get the value from a ``Just``, or return the given default value.
 
         >>> from cg_maybe import Just, Nothing
@@ -210,7 +209,7 @@ class Just(t.Generic[_T]):
         self,
         *,
         just: t.Callable[[_T], _TT],
-        nothing: t.Callable[[], _TT],  # pylint: disable=unused-argument
+        nothing: t.Callable[[], _TT],
     ) -> _TT:
         """A poor mans version of pattern matching.
 
@@ -250,7 +249,7 @@ class Just(t.Generic[_T]):
         callback(self.value)
         return self
 
-    def if_nothing(self, callback: t.Callable[[], object]) -> 'Just[_T]':  # pylint: disable=unused-argument
+    def if_nothing(self, callback: t.Callable[[], object]) -> 'Just[_T]':
         """Call the given callback if this value is a ``Nothing``, otherwise do
         nothing.
 
@@ -267,7 +266,7 @@ class Just(t.Generic[_T]):
 
     def try_extract(
         self,
-        make_exception: t.Union[t.Callable[[], Exception], Exception],  # pylint: disable=unused-argument
+        make_exception: t.Union[t.Callable[[], Exception], Exception],
     ) -> _T:
         """Try to extract the value, raising an exception created by the given
         argument if the value is ``Nothing``.
@@ -292,9 +291,9 @@ class Just(t.Generic[_T]):
         return self.value
 
     def __bool__(self) -> Literal[False]:
-        raise Exception('Do not check Just for boolean value')  # pylint: disable=broad-exception-raised
+        raise Exception('Do not check Just for boolean value')
 
-    def attr(self, attr: str) -> object:
+    def attr(self, attr: str) -> 'Just[object]':
         """Get the given attribute from the value in the just and wrap the
         result in a just.
 
@@ -306,7 +305,7 @@ class Just(t.Generic[_T]):
         return Just(getattr(self.value, attr))
 
     def join(
-        self: 'Just[cg_maybe._maybe.Maybe[_Y]]'
+        self: 'Just[cg_maybe._maybe.Maybe[_Y]]',
     ) -> 'cg_maybe._maybe.Maybe[_Y]':
         """Join a ``Just`` of a ``Maybe``.
 
@@ -349,8 +348,7 @@ class Just(t.Generic[_T]):
             return False
         return NotImplemented
 
-
-    def ne(  # pylint: disable=invalid-name
+    def ne(
         self: 'Just[_Y]',
         val: _Y,
     ) -> bool:
@@ -363,7 +361,7 @@ class Just(t.Generic[_T]):
         """
         return self.value != val
 
-    def lt(  # pylint: disable=invalid-name
+    def lt(
         self: 'Just[_SupportsLessThan[_T]]',
         val: _SupportsLessThan[_T],
     ) -> bool:
@@ -389,7 +387,7 @@ class Just(t.Generic[_T]):
         """
         return self.value <= val
 
-    def gt(  # pylint: disable=invalid-name
+    def gt(
         self: 'Just[_SupportsLessThan[_T]]',
         val: _SupportsLessThan[_T],
     ) -> bool:

{codegrade-16.1.89 → codegrade-16.1.91}/cg_maybe/_maybe.py

@@ -1,13 +1,11 @@
-"""This module combines ``Just`` and ``Nothing`` into ``Maybe``.
+"""This module combines ``Just`` and ``Nothing`` into ``Maybe``."""
 
-
-"""
 import typing as t
 
 from ._just import Just
 from ._nothing import _Nothing
 
-_Nothing._set_doc()  # pylint: disable=protected-access
+_Nothing._set_doc()  # noqa: SLF001
 
 _T = t.TypeVar('_T', covariant=True)
 

{codegrade-16.1.89 → codegrade-16.1.91}/cg_maybe/_nothing.py

@@ -1,27 +1,24 @@
-"""This module implements the ``Nothing`` part of the ``Maybe`` monad.
+"""This module implements the ``Nothing`` part of the ``Maybe`` monad."""
 
-
-"""
 import os
 import typing as t
 
 from ._type_helpers import Literal
-from ._type_helpers import SupportsLessThan as _SupportsLessThan
 from ._type_helpers import SupportsGreaterOrEqual as _SupportsGreaterOrEqual
+from ._type_helpers import SupportsLessThan as _SupportsLessThan
 
 if t.TYPE_CHECKING or os.getenv('CG_GENERATING_DOCS'):  # pragma: no cover
-    # pylint: disable=unused-import,invalid-name
     import cg_maybe
 
 _T = t.TypeVar('_T', covariant=True)
-_TT = t.TypeVar('_TT', covariant=True)  # pylint: disable=invalid-name
+_TT = t.TypeVar('_TT', covariant=True)
 _Y = t.TypeVar('_Y')
 _Z = t.TypeVar('_Z')
 
 
 class _Nothing(t.Generic[_T]):
-    """Singleton class to represent the ``Nothing`` part of a ``Maybe``.
-    """
+    """Singleton class to represent the ``Nothing`` part of a ``Maybe``."""
+
     __slots__ = ()
 
     def __hash__(self) -> int:
@@ -32,17 +29,17 @@ class _Nothing(t.Generic[_T]):
 
     @classmethod
     def _set_doc(cls) -> None:
-        # pylint: disable=import-outside-toplevel
         from ._just import Just
+
         for attr in dir(cls):
             value = getattr(cls, attr)
             if (
-                not attr.startswith('_') and hasattr(Just, attr) and
-                not value.__doc__
+                not attr.startswith('_')
+                and hasattr(Just, attr)
+                and not value.__doc__
             ):
                 value.__doc__ = getattr(Just, attr).__doc__
 
-    # pylint: disable=no-self-use,missing-function-docstring,unused-argument
     def map(self, mapper: t.Callable[[_T], _TT]) -> '_Nothing[_TT]':
         return Nothing
 
@@ -56,7 +53,6 @@ class _Nothing(t.Generic[_T]):
     def chain_nullable(
         self, chainer: t.Callable[[_T], t.Optional['_TT']]
     ) -> '_Nothing[_TT]':
-        # pylint: disable=import-outside-toplevel
         return Nothing
 
     def chain(
@@ -119,7 +115,8 @@ class _Nothing(t.Generic[_T]):
     def __lt__(self, other: object) -> bool:
         if isinstance(other, _Nothing):
             return False
-        from ._just import Just  # pylint: disable=import-outside-toplevel
+        from ._just import Just
+
         if isinstance(other, Just):
             return True
         return NotImplemented
@@ -159,9 +156,9 @@ class _Nothing(t.Generic[_T]):
         return obj is Nothing or isinstance(obj, cls)
 
     def __bool__(self) -> Literal[False]:
-        raise Exception('Do not check Nothing for boolean value')  # pylint: disable=broad-exception-raised
+        raise Exception('Do not check Nothing for boolean value')
 
-    def attr(self, attr: str) -> object:
+    def attr(self, attr: str) -> '_Nothing[object]':
         return Nothing
 
     def join(self: '_Nothing[cg_maybe._maybe.Maybe[_Y]]') -> '_Nothing[_Y]':
@@ -176,9 +173,9 @@ class _Nothing(t.Generic[_T]):
     ) -> Literal[False]:
         return False
 
-    ne = eq  # pylint: disable=invalid-name
+    ne = eq
 
-    def lt(  # pylint: disable=invalid-name
+    def lt(
         self: '_Nothing[_SupportsLessThan[_T]]',
         val: _SupportsLessThan[_T],
     ) -> Literal[False]:
@@ -190,7 +187,7 @@ class _Nothing(t.Generic[_T]):
     ) -> Literal[False]:
         return False
 
-    def gt(  # pylint: disable=invalid-name
+    def gt(
         self: '_Nothing[_SupportsLessThan[_T]]',
         val: _SupportsLessThan[_T],
     ) -> Literal[False]:
@@ -202,7 +199,5 @@ class _Nothing(t.Generic[_T]):
     ) -> Literal[False]:
         return False
 
-    # pylint: enable=no-self-use,missing-function-docstring,unused-argument
-
 
 Nothing: _Nothing[t.Any] = _Nothing()

codegrade-16.1.91/cg_maybe/_type_helpers.py

@@ -0,0 +1,34 @@
+"""Type helpers for ``cg_maybe``."""
+
+import sys
+import typing as t
+
+if sys.version_info >= (3, 8):
+    from typing import Final as Final
+    from typing import Literal as Literal
+    from typing import Protocol as Protocol
+else:  # pragma: no cover
+    from typing_extensions import (
+        Final as Final,
+    )
+    from typing_extensions import (
+        Literal as Literal,
+    )
+    from typing_extensions import (
+        Protocol as Protocol,
+    )
+
+_T = t.TypeVar('_T', covariant=True)
+_TT = t.TypeVar('_TT')
+
+
+class SupportsLessThan(Protocol[_T]):
+    """A type that supports the `<` operator."""
+
+    def __lt__(self: _TT, other: _TT) -> bool: ...
+
+
+class SupportsGreaterOrEqual(Protocol[_T]):
+    """A type that supports the `>=` operator."""
+
+    def __ge__(self: _TT, other: _TT) -> bool: ...

{codegrade-16.1.89 → codegrade-16.1.91}/cg_maybe/cg_maybe_plugin.py

@@ -1,19 +1,17 @@
 """
 Plugin to fix the type of certain methods on ``Just`` and ``Nothing`` objects.
-
-
 """
+
 import typing as t
 
-from mypy.types import Type, Instance, LiteralType
-from mypy.plugin import Plugin, MethodContext
 from mypy.checkmember import analyze_member_access
+from mypy.plugin import MethodContext, Plugin
+from mypy.types import Instance, LiteralType, Type
 
 
-def attr_callback(ctx: MethodContext, typ: str) -> Type:
-    """Callback to determine type for a ``.attr`` call on a ``Maybe``.
-    """
-    (attr, ), = ctx.arg_types
+def attr_callback(ctx: MethodContext) -> Type:
+    """Callback to determine type for a ``.attr`` call on a ``Maybe``."""
+    ((attr,),) = ctx.arg_types
     attr_maybe_value: t.Optional[Type] = attr
     if isinstance(attr, Instance):
         attr_maybe_value = attr.last_known_value
@@ -31,9 +29,11 @@ def attr_callback(ctx: MethodContext, typ: str) -> Type:
         return ctx.default_return_type
 
     assert isinstance(ctx.type, Instance)
-    base, = ctx.type.args
-    assert isinstance(base, Instance)
-    if not base.type.has_readable_member(attr_value):
+    (base,) = ctx.type.args
+    if not (
+        isinstance(base, Instance)
+        and base.type.has_readable_member(attr_value)
+    ):
         ctx.api.fail(
             'The {} has no attribute named {}'.format(base, attr_value),
             ctx.context,
@@ -48,34 +48,33 @@ def attr_callback(ctx: MethodContext, typ: str) -> Type:
         ctx.context,
         is_lvalue=False,
         is_super=False,
-        is_operator=True,
+        is_operator=False,
         msg=checker.msg,
         original_type=base,
         chk=checker.chk,
         in_literal_context=checker.is_literal_context(),
     )
-    return ctx.api.named_generic_type(typ, [member])
+    assert isinstance(ctx.default_return_type, Instance)
+    return ctx.default_return_type.copy_modified(args=[member])
 
 
 class CgMaybePlugin(Plugin):
-    """Mypy plugin definition.
-    """
+    """Mypy plugin definition."""
 
-    def get_method_hook(  # pylint: disable=no-self-use
+    def get_method_hook(
         self,
         fullname: str,
     ) -> t.Optional[t.Callable[[MethodContext], Type]]:
-        """Get the function to be called by mypy.
-        """
-        if fullname == 'cg_maybe._just.Just.attr':
-            return lambda ctx: attr_callback(ctx, 'cg_maybe.Just')
-        elif fullname == 'cg_maybe._nothing._Nothing.attr':
-            return lambda ctx: attr_callback(ctx, 'cg_maybe._Nothing')
+        """Get the function to be called by mypy."""
+        if fullname in (
+            'cg_maybe._just.Just.attr',
+            'cg_maybe._nothing._Nothing.attr',
+        ):
+            return lambda ctx: attr_callback(ctx)
         return None
 
 
 def plugin(_: str) -> t.Type[CgMaybePlugin]:
-    """Get the mypy plugin definition.
-    """
+    """Get the mypy plugin definition."""
     # ignore version argument if the plugin works with all mypy versions.
     return CgMaybePlugin