Drop support for python 3.7 (#98)

Drop support for python 3.7. Bumps version to `0.2.0-dev` since this is a potentially breaking change.

Author: jdidion

.github/workflows/pythonpackage.yml

@@ -9,7 +9,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        PYTHON_VERSION: ["3.7", "3.8", "3.9", "3.10"]
+        PYTHON_VERSION: ["3.8", "3.9", "3.10"]
     steps:
     - uses: actions/checkout@v2
 

.readthedocs.yml

@@ -2,7 +2,7 @@ version: 2
 build:
   os: ubuntu-22.04
   tools:
-    python: "3.7"
+    python: "3.8"
 sphinx:
   configuration: docs/conf.py
 python:

README.md

@@ -37,7 +37,7 @@
 
 `pip install fgpyo`
 
-**Requires python 3.7+**
+**Requires python 3.8+**
 
 See documentation on [fgpyo.readthedocs.org][rtd-link].
 
@@ -48,7 +48,7 @@ See documentation on [fgpyo.readthedocs.org][rtd-link].
 A simple way to create an environment with the desired version of python and poetry is to use [conda][conda-link].  E.g.:
 
 ```bash
-conda create -n fgpyo -c conda-forge "python>=3.6" poetry
+conda create -n fgpyo -c conda-forge "python>=3.8" poetry
 conda activate fgpyo
 poetry install
 ```

fgpyo/util/inspect.py

@@ -1,28 +1,25 @@
+import functools
 import sys
+import typing
+from enum import Enum
+from functools import partial
+from pathlib import PurePath
 from typing import Any
+from typing import Callable
 from typing import Dict
 from typing import Iterable
 from typing import List
+from typing import Literal
+from typing import Optional
 from typing import Tuple
 from typing import Type
 from typing import Union
 
-if sys.version_info >= (3, 8):
-    from typing import Literal
-else:
-    from typing_extensions import Literal
 if sys.version_info >= (3, 12):
     from typing import TypeAlias
 else:
     from typing_extensions import TypeAlias
 
-import functools
-from enum import Enum
-from functools import partial
-from pathlib import PurePath
-from typing import Callable
-from typing import Optional
-
 import attr
 
 import fgpyo.util.types as types
@@ -112,8 +109,8 @@ def get_parser() -> partial:
                 raise ValueError("Unable to parse set (try typing.Set[type])")
             elif type_ == dict:
                 raise ValueError("Unable to parse dict (try typing.Mapping[type])")
-            elif types.get_origin_type(type_) == list:
-                subtypes = types.get_arg_types(type_)
+            elif typing.get_origin(type_) == list:
+                subtypes = typing.get_args(type_)
 
                 assert (
                     len(subtypes) == 1
@@ -133,8 +130,8 @@ def get_parser() -> partial:
                         ]
                     )
                 )
-            elif types.get_origin_type(type_) == set:
-                subtypes = types.get_arg_types(type_)
+            elif typing.get_origin(type_) == set:
+                subtypes = typing.get_args(type_)
                 assert (
                     len(subtypes) == 1
                 ), "Sets are allowed only one subtype per PEP specification!"
@@ -153,14 +150,14 @@ def get_parser() -> partial:
                         ]
                     )
                 )
-            elif types.get_origin_type(type_) == tuple:
+            elif typing.get_origin(type_) == tuple:
                 subtype_parsers = [
                     _get_parser(
                         cls,
                         subtype,
                         parsers,
                     )
-                    for subtype in types.get_arg_types(type_)
+                    for subtype in typing.get_args(type_)
                 ]
 
                 def tuple_parse(tuple_string: str) -> Tuple[Any, ...]:
@@ -183,8 +180,8 @@ def tuple_parse(tuple_string: str) -> Tuple[Any, ...]:
 
                 return functools.partial(tuple_parse)
 
-            elif types.get_origin_type(type_) == dict:
-                subtypes = types.get_arg_types(type_)
+            elif typing.get_origin(type_) == dict:
+                subtypes = typing.get_args(type_)
                 assert (
                     len(subtypes) == 2
                 ), "Dict object must have exactly 2 subtypes per PEP specification!"
@@ -231,15 +228,15 @@ def dict_parse(dict_string: str) -> Dict[Any, Any]:
                 return functools.partial(type_)
             elif type_ == NoneType:
                 return functools.partial(types.none_parser)
-            elif types.get_origin_type(type_) is Union:
+            elif typing.get_origin(type_) is Union:
                 return types.make_union_parser(
                     union=type_,
-                    parsers=[_get_parser(cls, arg, parsers) for arg in types.get_arg_types(type_)],
+                    parsers=[_get_parser(cls, arg, parsers) for arg in typing.get_args(type_)],
                 )
-            elif types.get_origin_type(type_) is Literal:  # Py>=3.7.
+            elif typing.get_origin(type_) is Literal:
                 return types.make_literal_parser(
                     type_,
-                    [_get_parser(cls, type(arg), parsers) for arg in types.get_arg_types(type_)],
+                    [_get_parser(cls, type(arg), parsers) for arg in typing.get_args(type_)],
                 )
             else:
                 raise ParserNotFoundException(
@@ -319,8 +316,8 @@ def attr_from(
 
 def attribute_is_optional(attribute: attr.Attribute) -> bool:
     """Returns True if the attribute is optional, False otherwise"""
-    return types.get_origin_type(attribute.type) is Union and isinstance(
-        None, types.get_arg_types(attribute.type)
+    return typing.get_origin(attribute.type) is Union and isinstance(
+        None, typing.get_args(attribute.type)
     )
 
 

fgpyo/util/logging.py

@@ -34,19 +34,13 @@
 """
 
 import logging
-import sys
-
-if sys.version_info >= (3, 8):
-    from typing import Literal
-else:
-    from typing_extensions import Literal
-
 import socket
 from contextlib import AbstractContextManager
 from logging import Logger
 from threading import RLock
 from typing import Any
 from typing import Callable
+from typing import Literal
 from typing import Optional
 from typing import Union
 

fgpyo/util/tests/test_types.py

@@ -0,0 +1,11 @@
+from typing import Iterable
+from typing import List
+from typing import Sequence
+
+from fgpyo.util import types
+
+
+def test_is_listlike() -> None:
+    assert types.is_list_like(List[str])
+    assert types.is_list_like(Iterable[str])
+    assert types.is_list_like(Sequence[str])

fgpyo/util/types.py

@@ -1,50 +1,15 @@
 import collections
 import inspect
-import sys
 import typing
 from enum import Enum
 from functools import partial
 from typing import Callable
 from typing import Iterable
+from typing import Literal
 from typing import Type
 from typing import TypeVar
 from typing import Union
 
-# `get_origin_type` is a method that gets the outer type (ex list in a List[str])
-# `get_arg_types` is a method that gets the inner type (ex str in a List[str])
-if sys.version_info >= (3, 8):
-    from typing import Literal
-
-    get_origin_type = typing.get_origin
-    get_arg_types = typing.get_args
-else:
-    import typing_inspect
-    from typing_extensions import Literal
-
-    def get_origin_type(tp: Type) -> Type:
-        """Returns the outer type of a Typing object (ex list in a List[T])"""
-
-        if type(tp) is type(Literal):  # Py<=3.6.
-            return Literal
-        origin = typing_inspect.get_origin(tp)
-        return {
-            typing.List: list,
-            typing.Iterable: collections.abc.Iterable,
-            typing.Sequence: collections.abc.Sequence,
-            typing.Tuple: tuple,
-            typing.Set: set,
-            typing.Mapping: dict,
-            typing.Dict: dict,
-        }.get(origin, origin)
-
-    def get_arg_types(tp: Type) -> Type:
-        """Gets the inner types of a Typing object (ex T in a List[T])"""
-
-        if type(tp) is type(Literal):  # Py<=3.6.
-            return tp.__values__
-        return typing_inspect.get_args(tp, evaluate=True)  # evaluate=True default on Py>=3.7.
-
-
 UnionType = TypeVar("UnionType", bound="Union")
 EnumType = TypeVar("EnumType", bound="Enum")
 # conceptually bound to "Literal" but that's not valid in the spec
@@ -109,7 +74,7 @@ def is_constructible_from_str(type_: type) -> bool:
 
 def _is_optional(type_: type) -> bool:
     """Returns true if type_ is optional"""
-    return get_origin_type(type_) is Union and type(None) in get_arg_types(type_)
+    return typing.get_origin(type_) is Union and type(None) in typing.get_args(type_)
 
 
 def _make_union_parser_worker(
@@ -150,15 +115,15 @@ def _make_literal_parser_worker(
     """Worker function behind literal parsing. Iterates through possible literals and
     returns the value produced by the first literal that matches expectation.
     Otherwise raises an error if none work"""
-    for arg, p in zip(get_arg_types(literal), parsers):
+    for arg, p in zip(typing.get_args(literal), parsers):
         try:
             if p(value) == arg:
                 return arg
         except ValueError:
             pass
     raise InspectException(
         "invalid choice: {!r} (choose from {})".format(
-            value, ", ".join(map(repr, map(str, get_arg_types(literal))))
+            value, ", ".join(map(repr, map(str, typing.get_args(literal))))
         )
     )
 
@@ -174,7 +139,7 @@ def make_literal_parser(
 
 def is_list_like(type_: type) -> bool:
     """Returns true if the value is a list or list like object"""
-    return get_origin_type(type_) in [list, collections.abc.Iterable, collections.abc.Sequence]
+    return typing.get_origin(type_) in [list, collections.abc.Iterable, collections.abc.Sequence]
 
 
 def none_parser(value: str) -> Literal[None]: