Merge openpyxl stubs from microsoft/python-type-stubs

stubs/openpyxl/METADATA.toml

@@ -1 +1,5 @@
 version = "3.0.*"
+requires = ["lxml-stubs", "types-pillow", "numpy"]
+
+[tool.stubtest]
+ignore_missing_stub = false

stubs/openpyxl/openpyxl/__init__.pyi

@@ -1,3 +1,5 @@
+from typing import Protocol
+
 from openpyxl.compat.numbers import NUMPY as NUMPY
 from openpyxl.reader.excel import load_workbook as load_workbook
 from openpyxl.workbook import Workbook as Workbook
@@ -13,3 +15,7 @@ from ._constants import (
 )
 
 open = load_workbook
+
+# Utility type reused elsewhere
+class _Decodable(Protocol):  # noqa: Y046  # Utility type reused elsewhere
+    def decode(self, __encoding: str) -> str: ...

stubs/openpyxl/openpyxl/cell/cell.pyi

@@ -1,78 +1,90 @@
-from _typeshed import Incomplete
+import datetime
+from re import Pattern
+from typing_extensions import Final, Literal, TypeAlias
 
+from openpyxl.comments.comments import Comment
+from openpyxl.compat.numbers import NUMERIC_TYPES as NUMERIC_TYPES, _NumericTypes
+from openpyxl.styles.cell_style import StyleArray
 from openpyxl.styles.styleable import StyleableObject
+from openpyxl.workbook.child import _WorkbookChild
+from openpyxl.worksheet.hyperlink import Hyperlink
 
 __docformat__: str
-TIME_TYPES: Incomplete
-TIME_FORMATS: Incomplete
-STRING_TYPES: Incomplete
-KNOWN_TYPES: Incomplete
-ILLEGAL_CHARACTERS_RE: Incomplete
-ERROR_CODES: Incomplete
-TYPE_STRING: str
-TYPE_FORMULA: str
-TYPE_NUMERIC: str
-TYPE_BOOL: str
-TYPE_NULL: str
-TYPE_INLINE: str
-TYPE_ERROR: str
-TYPE_FORMULA_CACHE_STRING: str
-VALID_TYPES: Incomplete
+TIME_TYPES: tuple[type[datetime.datetime], type[datetime.date], type[datetime.time], type[datetime.timedelta]]
+_TimeTypes: TypeAlias = datetime.datetime | datetime.date | datetime.time | datetime.timedelta
+TIME_FORMATS: dict[_TimeTypes, str]
+STRING_TYPES: tuple[type[str], type[bytes]]
+_StringTypes: TypeAlias = str | bytes
+# mypy will simplify the type. Pyright fully expands it.
+KNOWN_TYPES = NUMERIC_TYPES + TIME_TYPES + STRING_TYPES + (bool, type(None))  # noqa: F821,Y026
+_KnownTypes: TypeAlias = _NumericTypes | _TimeTypes | _StringTypes | bool | None
+ILLEGAL_CHARACTERS_RE: Pattern[str]
+ERROR_CODES: Final = ("#NULL!", "#DIV/0!", "#VALUE!", "#REF!", "#NAME?", "#NUM!", "#N/A")
+TYPE_STRING: Final = "s"
+TYPE_FORMULA: Final = "f"
+TYPE_NUMERIC: Final = "n"
+TYPE_BOOL: Final = "b"
+TYPE_NULL: Final = "n"
+TYPE_INLINE: Final = "inlineStr"
+TYPE_ERROR: Final = "e"
+TYPE_FORMULA_CACHE_STRING: Final = "str"
 
-def get_type(t, value): ...
-def get_time_format(t): ...
+VALID_TYPES = (TYPE_STRING, TYPE_FORMULA, TYPE_NUMERIC, TYPE_BOOL, TYPE_NULL, TYPE_INLINE, TYPE_ERROR, TYPE_FORMULA_CACHE_STRING)
+
+def get_type(t, value) -> Literal["n", "s", "d", None]: ...
+def get_time_format(t) -> str: ...
 
 class Cell(StyleableObject):
-    row: Incomplete
-    column: Incomplete
+    row: int | None
+    column: int | None
     data_type: str
     def __init__(
         self,
-        worksheet,
-        row: Incomplete | None = ...,
-        column: Incomplete | None = ...,
-        value: Incomplete | None = ...,
-        style_array: Incomplete | None = ...,
+        worksheet: _WorkbookChild,
+        row: int | None = ...,
+        column: int | None = ...,
+        value: _KnownTypes = ...,
+        style_array: StyleArray | None = ...,
     ) -> None: ...
     @property
-    def coordinate(self): ...
+    def coordinate(self) -> str: ...
     @property
-    def col_idx(self): ...
+    def col_idx(self) -> int: ...
     @property
-    def column_letter(self): ...
+    def column_letter(self) -> str: ...
     @property
-    def encoding(self): ...
+    def encoding(self) -> str: ...
     @property
     def base_date(self): ...
-    def check_string(self, value): ...
+    def check_string(self, value: str | bytes): ...
     def check_error(self, value): ...
     @property
-    def value(self): ...
+    def value(self) -> _KnownTypes: ...
     @value.setter
-    def value(self, value) -> None: ...
+    def value(self, value: _KnownTypes) -> None: ...
     @property
-    def internal_value(self): ...
+    def internal_value(self) -> _KnownTypes: ...
     @property
-    def hyperlink(self): ...
+    def hyperlink(self) -> Hyperlink | None: ...
     @hyperlink.setter
-    def hyperlink(self, val) -> None: ...
+    def hyperlink(self, val: Hyperlink | str | None) -> None: ...
     @property
-    def is_date(self): ...
+    def is_date(self) -> bool: ...
     def offset(self, row: int = ..., column: int = ...): ...
     @property
-    def comment(self): ...
+    def comment(self) -> Comment | None: ...
     @comment.setter
-    def comment(self, value) -> None: ...
+    def comment(self, value: Comment | None) -> None: ...
 
 class MergedCell(StyleableObject):
     data_type: str
-    comment: Incomplete
-    hyperlink: Incomplete
-    row: Incomplete
-    column: Incomplete
-    def __init__(self, worksheet, row: Incomplete | None = ..., column: Incomplete | None = ...) -> None: ...
+    comment: Comment | None
+    hyperlink: Hyperlink | None
+    row: int | None
+    column: int | None
+    def __init__(self, worksheet: _WorkbookChild, row: int | None = ..., column: int | None = ...) -> None: ...
     @property
-    def coordinate(self): ...
-    value: Incomplete
+    def coordinate(self) -> str: ...
+    value: _KnownTypes
 
-def WriteOnlyCell(ws: Incomplete | None = ..., value: Incomplete | None = ...): ...
+def WriteOnlyCell(ws: _WorkbookChild | None = ..., value: _KnownTypes = ...) -> Cell: ...

stubs/openpyxl/openpyxl/cell/text.pyi

@@ -1,82 +1,91 @@
-from _typeshed import Incomplete
+from typing_extensions import Literal, TypeAlias
 
+from openpyxl.descriptors.base import _IntegerSetter
+from openpyxl.descriptors.sequence import _Sequence
 from openpyxl.descriptors.serialisable import Serialisable
+from openpyxl.styles.colors import Color
 from openpyxl.styles.fonts import Font
 
 class PhoneticProperties(Serialisable):
     tagname: str
-    fontId: Incomplete
-    type: Incomplete
-    alignment: Incomplete
+    @property
+    def fontId(self) -> int: ...
+    @fontId.setter
+    def fontId(self, __value: _IntegerSetter | None) -> None: ...
+    type: Literal["halfwidthKatakana", "fullwidthKatakana", "Hiragana", "noConversion", None]
+    alignment: Literal["noControl", "left", "center", "distributed", None]
     def __init__(
-        self, fontId: Incomplete | None = ..., type: Incomplete | None = ..., alignment: Incomplete | None = ...
+        self,
+        fontId: _IntegerSetter,
+        type: Literal["halfwidthKatakana", "fullwidthKatakana", "Hiragana", "noConversion", None] = ...,
+        alignment: Literal["noControl", "left", "center", "distributed", None] = ...,
     ) -> None: ...
 
 class PhoneticText(Serialisable):
     tagname: str
-    sb: Incomplete
-    eb: Incomplete
-    t: Incomplete
-    text: Incomplete
-    def __init__(self, sb: Incomplete | None = ..., eb: Incomplete | None = ..., t: Incomplete | None = ...) -> None: ...
+    @property
+    def sb(self) -> int: ...
+    @sb.setter
+    def sb(self, __value: _IntegerSetter) -> None: ...
+    @property
+    def eb(self) -> int: ...
+    @eb.setter
+    def eb(self, __value: _IntegerSetter) -> None: ...
+    t: str
+    text = t  # noqa: F821
+    def __init__(self, sb: _IntegerSetter, eb: _IntegerSetter, t: str) -> None: ...
 
 class InlineFont(Font):
     tagname: str
-    rFont: Incomplete
-    charset: Incomplete
-    family: Incomplete
-    b: Incomplete
-    i: Incomplete
-    strike: Incomplete
-    outline: Incomplete
-    shadow: Incomplete
-    condense: Incomplete
-    extend: Incomplete
-    color: Incomplete
-    sz: Incomplete
-    u: Incomplete
-    vertAlign: Incomplete
-    scheme: Incomplete
-    __elements__: Incomplete
+    rFont: str | None
+    __elements__: tuple[str, ...]
     def __init__(
         self,
-        rFont: Incomplete | None = ...,
-        charset: Incomplete | None = ...,
-        family: Incomplete | None = ...,
-        b: Incomplete | None = ...,
-        i: Incomplete | None = ...,
-        strike: Incomplete | None = ...,
-        outline: Incomplete | None = ...,
-        shadow: Incomplete | None = ...,
-        condense: Incomplete | None = ...,
-        extend: Incomplete | None = ...,
-        color: Incomplete | None = ...,
-        sz: Incomplete | None = ...,
-        u: Incomplete | None = ...,
-        vertAlign: Incomplete | None = ...,
-        scheme: Incomplete | None = ...,
+        rFont: str | None = ...,
+        charset: int | None = ...,
+        family: float | None = ...,
+        b: bool | None = ...,
+        i: bool | None = ...,
+        strike: bool | None = ...,
+        outline: bool | None = ...,
+        shadow: bool | None = ...,
+        condense: bool | None = ...,
+        extend: bool | None = ...,
+        color: Color | None = ...,
+        sz: float | None = ...,
+        u: Literal["single", "double", "singleAccounting", "doubleAccounting", None] = ...,
+        vertAlign: Literal["superscript", "subscript", "baseline", None] = ...,
+        scheme: Literal["major", "minor", None] = ...,
     ) -> None: ...
 
 class RichText(Serialisable):
     tagname: str
-    rPr: Incomplete
-    font: Incomplete
-    t: Incomplete
-    text: Incomplete
-    __elements__: Incomplete
-    def __init__(self, rPr: Incomplete | None = ..., t: Incomplete | None = ...) -> None: ...
+    rPr: InlineFont | None
+    font = rPr  # noqa: F821
+    t: str | None
+    text = t  # noqa: F821
+    __elements__: tuple[str, ...]
+    def __init__(self, rPr: InlineFont | None = ..., t: str | None = ...) -> None: ...
+
+_PhoneticProperties: TypeAlias = PhoneticProperties
 
 class Text(Serialisable):
     tagname: str
-    t: Incomplete
-    plain: Incomplete
-    r: Incomplete
-    formatted: Incomplete
-    rPh: Incomplete
-    phonetic: Incomplete
-    phoneticPr: Incomplete
-    PhoneticProperties: Incomplete
-    __elements__: Incomplete
-    def __init__(self, t: Incomplete | None = ..., r=..., rPh=..., phoneticPr: Incomplete | None = ...) -> None: ...
+    t: str | None
+    plain = t  # noqa: F821
+    r: _Sequence[RichText] | None
+    formatted = r  # noqa: F821
+    rPh: _Sequence[PhoneticText] | None
+    phonetic = rPh  # noqa: F821
+    phoneticPr: _PhoneticProperties | None
+    PhoneticProperties = phoneticPr  # noqa: F821
+    __elements__: tuple[str, ...]
+    def __init__(
+        self,
+        t: str | None = ...,
+        r: _Sequence[RichText] | None = ...,
+        rPh: _Sequence[RichText] | None = ...,
+        phoneticPr: _PhoneticProperties | None = ...,
+    ) -> None: ...
     @property
-    def content(self): ...
+    def content(self) -> str: ...