inline type hints

Author: RonnyPfannschmidt

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
 -   repo: https://github.com/asottile/pyupgrade
-    rev: v3.2.0
+    rev: v3.3.1
     hooks:
     -   id: pyupgrade
         args: [--py37-plus]
@@ -14,3 +14,9 @@ repos:
   hooks:
       - id: black
         language_version: python3
+-   repo: https://github.com/pre-commit/mirrors-mypy
+    rev: 'v0.991' 
+    hooks:
+    -   id: mypy
+        additional_dependencies:
+          - "pytest==7.2.0"

MANIFEST.in

@@ -2,4 +2,3 @@ include LICENSE
 include example.ini
 include tox.ini
 include src/iniconfig/py.typed
-recursive-include src *.pyi

pyproject.toml

@@ -3,4 +3,7 @@ requires = ["setuptools>=41.2.0", "wheel", "setuptools_scm>3"]
 
 build-backend = "setuptools.build_meta"
 
-[tool.setuptools_scm]
+[tool.setuptools_scm]
+
+[tool.mypy]
+strict = true

setup.py

@@ -4,7 +4,7 @@
 import setuptools_scm  # noqa
 
 
-def local_scheme(version):
+def local_scheme(version: object) -> str:
     """Skip the local version (eg. +xyz of 0.6.1.dev4+gdf99fe2)
     to be able to upload to Test PyPI"""
     return ""

src/iniconfig/__init__.py

@@ -1,63 +1,111 @@
 """ brain-dead simple parser for ini-style files.
 (C) Ronny Pfannschmidt, Holger Krekel -- MIT licensed
 """
+from __future__ import annotations
+from typing import (
+    Callable,
+    Iterator,
+    Mapping,
+    Optional,
+    Tuple,
+    TypeVar,
+    Union,
+    TYPE_CHECKING,
+    NoReturn,
+    NamedTuple,
+    overload,
+    cast,
+)
+
+
+if TYPE_CHECKING:
+    from typing_extensions import Final
+
 __all__ = ["IniConfig", "ParseError"]
 
 COMMENTCHARS = "#;"
 
+_D = TypeVar("_D")
+_T = TypeVar("_T")
+
+
+_str_default = cast(Callable[[str], str], str)
+
+
+class _ParsedLine(NamedTuple):
+    lineno: int
+    section: str | None
+    name: str | None
+    value: str | None
+
 
 class ParseError(Exception):
-    def __init__(self, path, lineno, msg):
+    path: Final[str]
+    lineno: Final[int]
+    msg: Final[str]
+
+    def __init__(self, path: str, lineno: int, msg: str):
         Exception.__init__(self, path, lineno, msg)
         self.path = path
         self.lineno = lineno
         self.msg = msg
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f"{self.path}:{self.lineno + 1}: {self.msg}"
 
 
 class SectionWrapper:
-    def __init__(self, config, name):
+    config: Final[IniConfig]
+    name: Final[str]
+
+    def __init__(self, config: IniConfig, name: str):
         self.config = config
         self.name = name
 
-    def lineof(self, name):
+    def lineof(self, name: str) -> int | None:
         return self.config.lineof(self.name, name)
 
-    def get(self, key, default=None, convert=str):
+    def get(
+        self,
+        key: str,
+        default: _D | None = None,
+        convert: Callable[[str], _T] | None = None,
+    ) -> _D | _T | str | None:
         return self.config.get(self.name, key, convert=convert, default=default)
 
-    def __getitem__(self, key):
+    def __getitem__(self, key: str) -> str:
         return self.config.sections[self.name][key]
 
-    def __iter__(self):
-        section = self.config.sections.get(self.name, [])
+    def __iter__(self) -> Iterator[str]:
+        section: Mapping[str, str] = self.config.sections.get(self.name, {})
 
-        def lineof(key):
-            return self.config.lineof(self.name, key)
+        def lineof(key: str) -> int:
+            return self.config.lineof(self.name, key)  # type: ignore
 
         yield from sorted(section, key=lineof)
 
-    def items(self):
+    def items(self) -> Iterator[tuple[str, str]]:
         for name in self:
             yield name, self[name]
 
 
 class IniConfig:
-    def __init__(self, path, data=None):
+    path: Final[str]
+    sections: Final[Mapping[str, Mapping[str, str]]]
+
+    def __init__(
+        self, path: str, data: str | None = None, encoding: str = "utf-8"
+    ) -> None:
         self.path = str(path)  # convenience
         if data is None:
-            f = open(self.path)
-            try:
-                tokens = self._parse(iter(f))
-            finally:
-                f.close()
-        else:
-            tokens = self._parse(data.splitlines(True))
+            with open(self.path, encoding=encoding) as fp:
+                data = fp.read()
+
+        tokens = self._parse(data.splitlines(True))
 
         self._sources = {}
-        self.sections = {}
+        sections_data: dict[str, dict[str, str]]
+        self.sections = sections_data = {}
 
         for lineno, section, name, value in tokens:
             if section is None:
@@ -66,44 +114,46 @@ def __init__(self, path, data=None):
             if name is None:
                 if section in self.sections:
                     self._raise(lineno, f"duplicate section {section!r}")
-                self.sections[section] = {}
+                sections_data[section] = {}
             else:
                 if name in self.sections[section]:
                     self._raise(lineno, f"duplicate name {name!r}")
-                self.sections[section][name] = value
+                assert value is not None
+                sections_data[section][name] = value
 
-    def _raise(self, lineno, msg):
+    def _raise(self, lineno: int, msg: str) -> NoReturn:
         raise ParseError(self.path, lineno, msg)
 
-    def _parse(self, line_iter):
-        result = []
+    def _parse(self, line_iter: list[str]) -> list[_ParsedLine]:
+        result: list[_ParsedLine] = []
         section = None
         for lineno, line in enumerate(line_iter):
             name, data = self._parseline(line, lineno)
             # new value
             if name is not None and data is not None:
-                result.append((lineno, section, name, data))
+                result.append(_ParsedLine(lineno, section, name, data))
             # new section
             elif name is not None and data is None:
                 if not name:
                     self._raise(lineno, "empty section name")
                 section = name
-                result.append((lineno, section, None, None))
+                result.append(_ParsedLine(lineno, section, None, None))
             # continuation
             elif name is None and data is not None:
                 if not result:
                     self._raise(lineno, "unexpected value continuation")
                 last = result.pop()
-                last_name, last_data = last[-2:]
-                if last_name is None:
+                if last.name is None:
                     self._raise(lineno, "unexpected value continuation")
 
-                if last_data:
-                    data = f"{last_data}\n{data}"
-                result.append(last[:-1] + (data,))
+                if last.value:
+                    last = last._replace(value=f"{last.value}\n{data}")
+                else:
+                    last = last._replace(value=data)
+                result.append(last)
         return result
 
-    def _parseline(self, line, lineno):
+    def _parseline(self, line: str, lineno: int) -> tuple[str | None, str | None]:
         # blank lines
         if iscommentline(line):
             line = ""
@@ -135,30 +185,83 @@ def _parseline(self, line, lineno):
         else:
             return None, line.strip()
 
-    def lineof(self, section, name=None):
+    def lineof(self, section: str, name: str | None = None) -> int | None:
         lineno = self._sources.get((section, name))
-        if lineno is not None:
-            return lineno + 1
+        return None if lineno is None else lineno + 1
+
+    @overload
+    def get(
+        self,
+        section: str,
+        name: str,
+    ) -> str | None:
+        ...
+
+    @overload
+    def get(
+        self,
+        section: str,
+        name: str,
+        convert: Callable[[str], _T],
+    ) -> _T | None:
+        ...
 
-    def get(self, section, name, default=None, convert=str):
+    @overload
+    def get(
+        self,
+        section: str,
+        name: str,
+        default: None,
+        convert: Callable[[str], _T],
+    ) -> _T | None:
+        ...
+
+    @overload
+    def get(
+        self, section: str, name: str, default: _D, convert: None = None
+    ) -> str | _D:
+        ...
+
+    @overload
+    def get(
+        self,
+        section: str,
+        name: str,
+        default: _D,
+        convert: Callable[[str], _T],
+    ) -> _T | _D:
+        ...
+
+    def get(  # type: ignore
+        self,
+        section: str,
+        name: str,
+        default: _D | None = None,
+        convert: Callable[[str], _T] | None = None,
+    ) -> _D | _T | str | None:
         try:
-            return convert(self.sections[section][name])
+            value: str = self.sections[section][name]
         except KeyError:
             return default
+        else:
+            if convert is not None:
+                return convert(value)
+            else:
+                return value
 
-    def __getitem__(self, name):
+    def __getitem__(self, name: str) -> SectionWrapper:
         if name not in self.sections:
             raise KeyError(name)
         return SectionWrapper(self, name)
 
-    def __iter__(self):
-        for name in sorted(self.sections, key=self.lineof):
+    def __iter__(self) -> Iterator[SectionWrapper]:
+        for name in sorted(self.sections, key=self.lineof):  # type: ignore
             yield SectionWrapper(self, name)
 
-    def __contains__(self, arg):
+    def __contains__(self, arg: str) -> bool:
         return arg in self.sections
 
 
-def iscommentline(line):
+def iscommentline(line: str) -> bool:
     c = line.lstrip()[:1]
     return c in COMMENTCHARS