diff options
| -rw-r--r-- | numpy/__init__.pyi | 4 | ||||
| -rw-r--r-- | numpy/char.pyi | 59 | ||||
| -rw-r--r-- | numpy/core/defchararray.pyi | 422 | ||||
| -rw-r--r-- | numpy/core/src/multiarray/nditer_impl.h | 2 | ||||
| -rw-r--r-- | numpy/core/src/umath/ufunc_object.c | 4 | ||||
| -rw-r--r-- | numpy/core/tests/test_ufunc.py | 8 | ||||
| -rw-r--r-- | numpy/linalg/lapack_lite/README.rst | 7 | ||||
| -rw-r--r-- | numpy/linalg/lapack_lite/clapack_scrub.py | 21 | ||||
| -rw-r--r-- | numpy/linalg/lapack_lite/fortran.py | 5 | ||||
| -rwxr-xr-x | numpy/linalg/lapack_lite/make_lite.py | 35 | ||||
| -rw-r--r-- | numpy/typing/tests/data/fail/char.py | 66 | ||||
| -rw-r--r-- | numpy/typing/tests/data/reveal/char.py | 147 | ||||
| -rw-r--r-- | numpy/typing/tests/test_isfile.py | 1 |
13 files changed, 692 insertions, 89 deletions
diff --git a/numpy/__init__.pyi b/numpy/__init__.pyi index 5adf69988..0313530dc 100644 --- a/numpy/__init__.pyi +++ b/numpy/__init__.pyi @@ -197,7 +197,6 @@ from typing import ( # Ensures that the stubs are picked up from numpy import ( - char as char, ctypeslib as ctypeslib, fft as fft, lib as lib, @@ -211,6 +210,9 @@ from numpy import ( version as version, ) +from numpy.core import defchararray +char = defchararray + from numpy.core.function_base import ( linspace as linspace, logspace as logspace, diff --git a/numpy/char.pyi b/numpy/char.pyi deleted file mode 100644 index 4904aa27a..000000000 --- a/numpy/char.pyi +++ /dev/null @@ -1,59 +0,0 @@ -from typing import Any, List - -from numpy import ( - chararray as chararray, -) - -__all__: List[str] - -def equal(x1, x2): ... -def not_equal(x1, x2): ... -def greater_equal(x1, x2): ... -def less_equal(x1, x2): ... -def greater(x1, x2): ... -def less(x1, x2): ... -def str_len(a): ... -def add(x1, x2): ... -def multiply(a, i): ... -def mod(a, values): ... -def capitalize(a): ... -def center(a, width, fillchar=...): ... -def count(a, sub, start=..., end=...): ... -def decode(a, encoding=..., errors=...): ... -def encode(a, encoding=..., errors=...): ... -def endswith(a, suffix, start=..., end=...): ... -def expandtabs(a, tabsize=...): ... -def find(a, sub, start=..., end=...): ... -def index(a, sub, start=..., end=...): ... -def isalnum(a): ... -def isalpha(a): ... -def isdigit(a): ... -def islower(a): ... -def isspace(a): ... -def istitle(a): ... -def isupper(a): ... -def join(sep, seq): ... -def ljust(a, width, fillchar=...): ... -def lower(a): ... -def lstrip(a, chars=...): ... -def partition(a, sep): ... -def replace(a, old, new, count=...): ... -def rfind(a, sub, start=..., end=...): ... -def rindex(a, sub, start=..., end=...): ... -def rjust(a, width, fillchar=...): ... -def rpartition(a, sep): ... -def rsplit(a, sep=..., maxsplit=...): ... -def rstrip(a, chars=...): ... -def split(a, sep=..., maxsplit=...): ... -def splitlines(a, keepends=...): ... -def startswith(a, prefix, start=..., end=...): ... -def strip(a, chars=...): ... -def swapcase(a): ... -def title(a): ... -def translate(a, table, deletechars=...): ... -def upper(a): ... -def zfill(a, width): ... -def isnumeric(a): ... -def isdecimal(a): ... -def array(obj, itemsize=..., copy=..., unicode=..., order=...): ... -def asarray(obj, itemsize=..., unicode=..., order=...): ... diff --git a/numpy/core/defchararray.pyi b/numpy/core/defchararray.pyi new file mode 100644 index 000000000..28d247b05 --- /dev/null +++ b/numpy/core/defchararray.pyi @@ -0,0 +1,422 @@ +from typing import ( + Literal as L, + overload, + TypeVar, + Any, + List, +) + +from numpy import ( + chararray as chararray, + dtype, + str_, + bytes_, + int_, + bool_, + object_, + _OrderKACF, +) + +from numpy.typing import ( + NDArray, + _ArrayLikeStr_co as U_co, + _ArrayLikeBytes_co as S_co, + _ArrayLikeInt_co as i_co, + _ArrayLikeBool_co as b_co, +) + +from numpy.core.multiarray import compare_chararrays as compare_chararrays + +_SCT = TypeVar("_SCT", str_, bytes_) +_CharArray = chararray[Any, dtype[_SCT]] + +__all__: List[str] + +# Comparison +@overload +def equal(x1: U_co, x2: U_co) -> NDArray[bool_]: ... +@overload +def equal(x1: S_co, x2: S_co) -> NDArray[bool_]: ... + +@overload +def not_equal(x1: U_co, x2: U_co) -> NDArray[bool_]: ... +@overload +def not_equal(x1: S_co, x2: S_co) -> NDArray[bool_]: ... + +@overload +def greater_equal(x1: U_co, x2: U_co) -> NDArray[bool_]: ... +@overload +def greater_equal(x1: S_co, x2: S_co) -> NDArray[bool_]: ... + +@overload +def less_equal(x1: U_co, x2: U_co) -> NDArray[bool_]: ... +@overload +def less_equal(x1: S_co, x2: S_co) -> NDArray[bool_]: ... + +@overload +def greater(x1: U_co, x2: U_co) -> NDArray[bool_]: ... +@overload +def greater(x1: S_co, x2: S_co) -> NDArray[bool_]: ... + +@overload +def less(x1: U_co, x2: U_co) -> NDArray[bool_]: ... +@overload +def less(x1: S_co, x2: S_co) -> NDArray[bool_]: ... + +# String operations +@overload +def add(x1: U_co, x2: U_co) -> NDArray[str_]: ... +@overload +def add(x1: S_co, x2: S_co) -> NDArray[bytes_]: ... + +@overload +def multiply(a: U_co, i: i_co) -> NDArray[str_]: ... +@overload +def multiply(a: S_co, i: i_co) -> NDArray[bytes_]: ... + +@overload +def mod(a: U_co, value: Any) -> NDArray[str_]: ... +@overload +def mod(a: S_co, value: Any) -> NDArray[bytes_]: ... + +@overload +def capitalize(a: U_co) -> NDArray[str_]: ... +@overload +def capitalize(a: S_co) -> NDArray[bytes_]: ... + +@overload +def center(a: U_co, width: i_co, fillchar: U_co = ...) -> NDArray[str_]: ... +@overload +def center(a: S_co, width: i_co, fillchar: S_co = ...) -> NDArray[bytes_]: ... + +def decode( + a: S_co, + encoding: None | str = ..., + errors: None | str = ..., +) -> NDArray[str_]: ... + +def encode( + a: U_co, + encoding: None | str = ..., + errors: None | str = ..., +) -> NDArray[bytes_]: ... + +@overload +def expandtabs(a: U_co, tabsize: i_co = ...) -> NDArray[str_]: ... +@overload +def expandtabs(a: S_co, tabsize: i_co = ...) -> NDArray[bytes_]: ... + +@overload +def join(sep: U_co, seq: U_co) -> NDArray[str_]: ... +@overload +def join(sep: S_co, seq: S_co) -> NDArray[bytes_]: ... + +@overload +def ljust(a: U_co, width: i_co, fillchar: U_co = ...) -> NDArray[str_]: ... +@overload +def ljust(a: S_co, width: i_co, fillchar: S_co = ...) -> NDArray[bytes_]: ... + +@overload +def lower(a: U_co) -> NDArray[str_]: ... +@overload +def lower(a: S_co) -> NDArray[bytes_]: ... + +@overload +def lstrip(a: U_co, chars: None | U_co = ...) -> NDArray[str_]: ... +@overload +def lstrip(a: S_co, chars: None | S_co = ...) -> NDArray[bytes_]: ... + +@overload +def partition(a: U_co, sep: U_co) -> NDArray[str_]: ... +@overload +def partition(a: S_co, sep: S_co) -> NDArray[bytes_]: ... + +@overload +def replace( + a: U_co, + old: U_co, + new: U_co, + count: None | i_co = ..., +) -> NDArray[str_]: ... +@overload +def replace( + a: S_co, + old: S_co, + new: S_co, + count: None | i_co = ..., +) -> NDArray[bytes_]: ... + +@overload +def rjust( + a: U_co, + width: i_co, + fillchar: U_co = ..., +) -> NDArray[str_]: ... +@overload +def rjust( + a: S_co, + width: i_co, + fillchar: S_co = ..., +) -> NDArray[bytes_]: ... + +@overload +def rpartition(a: U_co, sep: U_co) -> NDArray[str_]: ... +@overload +def rpartition(a: S_co, sep: S_co) -> NDArray[bytes_]: ... + +@overload +def rsplit( + a: U_co, + sep: None | U_co = ..., + maxsplit: None | i_co = ..., +) -> NDArray[object_]: ... +@overload +def rsplit( + a: S_co, + sep: None | S_co = ..., + maxsplit: None | i_co = ..., +) -> NDArray[object_]: ... + +@overload +def rstrip(a: U_co, chars: None | U_co = ...) -> NDArray[str_]: ... +@overload +def rstrip(a: S_co, chars: None | S_co = ...) -> NDArray[bytes_]: ... + +@overload +def split( + a: U_co, + sep: None | U_co = ..., + maxsplit: None | i_co = ..., +) -> NDArray[object_]: ... +@overload +def split( + a: S_co, + sep: None | S_co = ..., + maxsplit: None | i_co = ..., +) -> NDArray[object_]: ... + +@overload +def splitlines(a: U_co, keepends: None | b_co = ...) -> NDArray[object_]: ... +@overload +def splitlines(a: S_co, keepends: None | b_co = ...) -> NDArray[object_]: ... + +@overload +def strip(a: U_co, chars: None | U_co = ...) -> NDArray[str_]: ... +@overload +def strip(a: S_co, chars: None | S_co = ...) -> NDArray[bytes_]: ... + +@overload +def swapcase(a: U_co) -> NDArray[str_]: ... +@overload +def swapcase(a: S_co) -> NDArray[bytes_]: ... + +@overload +def title(a: U_co) -> NDArray[str_]: ... +@overload +def title(a: S_co) -> NDArray[bytes_]: ... + +@overload +def translate( + a: U_co, + table: U_co, + deletechars: None | U_co = ..., +) -> NDArray[str_]: ... +@overload +def translate( + a: S_co, + table: S_co, + deletechars: None | S_co = ..., +) -> NDArray[bytes_]: ... + +@overload +def upper(a: U_co) -> NDArray[str_]: ... +@overload +def upper(a: S_co) -> NDArray[bytes_]: ... + +@overload +def zfill(a: U_co, width: i_co) -> NDArray[str_]: ... +@overload +def zfill(a: S_co, width: i_co) -> NDArray[bytes_]: ... + +# String information +@overload +def count( + a: U_co, + sub: U_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[int_]: ... +@overload +def count( + a: S_co, + sub: S_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[int_]: ... + +@overload +def endswith( + a: U_co, + suffix: U_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[bool_]: ... +@overload +def endswith( + a: S_co, + suffix: S_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[bool_]: ... + +@overload +def find( + a: U_co, + sub: U_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[int_]: ... +@overload +def find( + a: S_co, + sub: S_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[int_]: ... + +@overload +def index( + a: U_co, + sub: U_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[int_]: ... +@overload +def index( + a: S_co, + sub: S_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[int_]: ... + +def isalpha(a: U_co | S_co) -> NDArray[bool_]: ... +def isalnum(a: U_co | S_co) -> NDArray[bool_]: ... +def isdecimal(a: U_co | S_co) -> NDArray[bool_]: ... +def isdigit(a: U_co | S_co) -> NDArray[bool_]: ... +def islower(a: U_co | S_co) -> NDArray[bool_]: ... +def isnumeric(a: U_co | S_co) -> NDArray[bool_]: ... +def isspace(a: U_co | S_co) -> NDArray[bool_]: ... +def istitle(a: U_co | S_co) -> NDArray[bool_]: ... +def isupper(a: U_co | S_co) -> NDArray[bool_]: ... + +@overload +def rfind( + a: U_co, + sub: U_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[int_]: ... +@overload +def rfind( + a: S_co, + sub: S_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[int_]: ... + +@overload +def rindex( + a: U_co, + sub: U_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[int_]: ... +@overload +def rindex( + a: S_co, + sub: S_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[int_]: ... + +@overload +def startswith( + a: U_co, + prefix: U_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[bool_]: ... +@overload +def startswith( + a: S_co, + prefix: S_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[bool_]: ... + +def str_len(A: U_co | S_co) -> NDArray[int_]: ... + +# Overload 1 and 2: str- or bytes-based array-likes +# overload 3: arbitrary object with unicode=False (-> bytes_) +# overload 4: arbitrary object with unicode=True (-> str_) +@overload +def array( + obj: U_co, + itemsize: None | int = ..., + copy: bool = ..., + unicode: L[False] = ..., + order: _OrderKACF = ..., +) -> _CharArray[str_]: ... +@overload +def array( + obj: S_co, + itemsize: None | int = ..., + copy: bool = ..., + unicode: L[False] = ..., + order: _OrderKACF = ..., +) -> _CharArray[bytes_]: ... +@overload +def array( + obj: object, + itemsize: None | int = ..., + copy: bool = ..., + unicode: L[False] = ..., + order: _OrderKACF = ..., +) -> _CharArray[bytes_]: ... +@overload +def array( + obj: object, + itemsize: None | int = ..., + copy: bool = ..., + unicode: L[True] = ..., + order: _OrderKACF = ..., +) -> _CharArray[str_]: ... + +@overload +def asarray( + obj: U_co, + itemsize: None | int = ..., + unicode: L[False] = ..., + order: _OrderKACF = ..., +) -> _CharArray[str_]: ... +@overload +def asarray( + obj: S_co, + itemsize: None | int = ..., + unicode: L[False] = ..., + order: _OrderKACF = ..., +) -> _CharArray[bytes_]: ... +@overload +def asarray( + obj: object, + itemsize: None | int = ..., + unicode: L[False] = ..., + order: _OrderKACF = ..., +) -> _CharArray[bytes_]: ... +@overload +def asarray( + obj: object, + itemsize: None | int = ..., + unicode: L[True] = ..., + order: _OrderKACF = ..., +) -> _CharArray[str_]: ... diff --git a/numpy/core/src/multiarray/nditer_impl.h b/numpy/core/src/multiarray/nditer_impl.h index b36ab8543..2a82b7e54 100644 --- a/numpy/core/src/multiarray/nditer_impl.h +++ b/numpy/core/src/multiarray/nditer_impl.h @@ -289,7 +289,7 @@ struct NpyIter_AxisData_tag { 1 + \ /* intp stride[nop+1] AND char* ptr[nop+1] */ \ 2*((nop)+1) \ - )*NPY_SIZEOF_INTP ) + )*(size_t)NPY_SIZEOF_INTP) /* * Macro to advance an AXISDATA pointer by a specified count. diff --git a/numpy/core/src/umath/ufunc_object.c b/numpy/core/src/umath/ufunc_object.c index 7abcb9513..9c943566b 100644 --- a/numpy/core/src/umath/ufunc_object.c +++ b/numpy/core/src/umath/ufunc_object.c @@ -1062,8 +1062,8 @@ check_for_trivial_loop(PyArrayMethodObject *ufuncimpl, if (dtypes[i] != PyArray_DESCR(op[i])) { NPY_CASTING safety = PyArray_GetCastSafety( PyArray_DESCR(op[i]), dtypes[i], NULL); - if (safety < 0) { - /* A proper error during a cast check should be rare */ + if (safety < 0 && PyErr_Occurred()) { + /* A proper error during a cast check, should be rare */ return -1; } if (!(safety & _NPY_CAST_IS_VIEW)) { diff --git a/numpy/core/tests/test_ufunc.py b/numpy/core/tests/test_ufunc.py index c3ea10d93..30929ce91 100644 --- a/numpy/core/tests/test_ufunc.py +++ b/numpy/core/tests/test_ufunc.py @@ -2308,6 +2308,14 @@ def test_ufunc_casterrors(): assert out[-1] == 1 +def test_trivial_loop_invalid_cast(): + # This tests the fast-path "invalid cast", see gh-19904. + with pytest.raises(TypeError, + match="cast ufunc 'add' input 0"): + # the void dtype definitely cannot cast to double: + np.add(np.array(1, "i,i"), 3, signature="dd->d") + + @pytest.mark.skipif(not HAS_REFCOUNT, reason="Python lacks refcounts") @pytest.mark.parametrize("offset", [0, np.BUFSIZE//2, int(1.5*np.BUFSIZE)]) diff --git a/numpy/linalg/lapack_lite/README.rst b/numpy/linalg/lapack_lite/README.rst index ed738ab86..8baa1d8ff 100644 --- a/numpy/linalg/lapack_lite/README.rst +++ b/numpy/linalg/lapack_lite/README.rst @@ -12,15 +12,18 @@ automatically from a directory of LAPACK source files. You'll need `plex 2.0.0dev`_, available from PyPI, installed to do the appropriate scrubbing. As of writing, **this is only available for python 2.7**, and is unlikely to ever be ported to python 3. +As a result, all the Python scripts in this directory must remain compatible +with Python 2.7, even though NumPy itself no longer supports this version, +until these scripts are rewritten to use something other than ``plex``. .. _plex 2.0.0dev: https://pypi.python.org/pypi/plex/ The routines that ``lapack_litemodule.c`` wraps are listed in ``wrapped_routines``, along with a few exceptions that aren't picked up properly. Assuming that you have an unpacked LAPACK source tree in -``~/LAPACK``, you generate the new routines in this directory with:: +``/tmp/lapack-3.x.x``, you generate the new routines in this directory with:: -$ python ./make_lite.py wrapped_routines ~/LAPACK +$ ./make_lite.py wrapped_routines /tmp/lapack-3.x.x This will grab the right routines, with dependencies, put them into the appropriate ``f2c_*.f`` files, run ``f2c`` over them, then do some scrubbing diff --git a/numpy/linalg/lapack_lite/clapack_scrub.py b/numpy/linalg/lapack_lite/clapack_scrub.py index 44c0d92d9..e6f2d09f4 100644 --- a/numpy/linalg/lapack_lite/clapack_scrub.py +++ b/numpy/linalg/lapack_lite/clapack_scrub.py @@ -1,12 +1,17 @@ -#!/usr/bin/env python3 +#!/usr/bin/env python2.7 +# WARNING! This a Python 2 script. Read README.rst for rationale. import os import re import sys -from io import StringIO from plex import Scanner, Str, Lexicon, Opt, Bol, State, AnyChar, TEXT, IGNORE from plex.traditional import re as Re +try: + from io import BytesIO as UStringIO # Python 2 +except ImportError: + from io import StringIO as UStringIO # Python 3 + class MyScanner(Scanner): def __init__(self, info, name='<default>'): @@ -22,8 +27,8 @@ def sep_seq(sequence, sep): return pat def runScanner(data, scanner_class, lexicon=None): - info = StringIO(data) - outfo = StringIO() + info = UStringIO(data) + outfo = UStringIO() if lexicon is not None: scanner = scanner_class(lexicon, info) else: @@ -190,7 +195,7 @@ def cleanComments(source): return SourceLines state = SourceLines - for line in StringIO(source): + for line in UStringIO(source): state = state(line) comments.flushTo(lines) return lines.getValue() @@ -218,7 +223,7 @@ def removeHeader(source): return OutOfHeader state = LookingForHeader - for line in StringIO(source): + for line in UStringIO(source): state = state(line) return lines.getValue() @@ -227,7 +232,7 @@ def removeSubroutinePrototypes(source): r'/\* Subroutine \*/^\s*(?:(?:inline|static)\s+){0,2}(?!else|typedef|return)\w+\s+\*?\s*(\w+)\s*\([^0]+\)\s*;?' ) lines = LineQueue() - for line in StringIO(source): + for line in UStringIO(source): if not expression.match(line): lines.add(line) @@ -249,7 +254,7 @@ def removeBuiltinFunctions(source): return InBuiltInFunctions state = LookingForBuiltinFunctions - for line in StringIO(source): + for line in UStringIO(source): state = state(line) return lines.getValue() diff --git a/numpy/linalg/lapack_lite/fortran.py b/numpy/linalg/lapack_lite/fortran.py index fc09f0808..2a5c9c05e 100644 --- a/numpy/linalg/lapack_lite/fortran.py +++ b/numpy/linalg/lapack_lite/fortran.py @@ -1,3 +1,4 @@ +# WARNING! This a Python 2 script. Read README.rst for rationale. import re import itertools @@ -44,6 +45,8 @@ class LineIterator: line = line.rstrip() return line + next = __next__ + class PushbackIterator: """PushbackIterator(iterable) @@ -69,6 +72,8 @@ class PushbackIterator: def pushback(self, item): self.buffer.append(item) + next = __next__ + def fortranSourceLines(fo): """Return an iterator over statement lines of a Fortran source file. diff --git a/numpy/linalg/lapack_lite/make_lite.py b/numpy/linalg/lapack_lite/make_lite.py index 09ffaf840..398c27e94 100755 --- a/numpy/linalg/lapack_lite/make_lite.py +++ b/numpy/linalg/lapack_lite/make_lite.py @@ -1,4 +1,5 @@ -#!/usr/bin/env python3 +#!/usr/bin/env python2.7 +# WARNING! This a Python 2 script. Read README.rst for rationale. """ Usage: make_lite.py <wrapped_routines_file> <lapack_dir> @@ -20,7 +21,10 @@ import shutil import fortran import clapack_scrub -from shutil import which +try: + from distutils.spawn import find_executable as which # Python 2 +except ImportError: + from shutil import which # Python 3 # Arguments to pass to f2c. You'll always want -A for ANSI C prototypes # Others of interest: -a to not make variables static by default @@ -81,7 +85,8 @@ class FortranRoutine: return self._dependencies def __repr__(self): - return f'FortranRoutine({self.name!r}, filename={self.filename!r})' + return "FortranRoutine({!r}, filename={!r})".format(self.name, + self.filename) class UnknownFortranRoutine(FortranRoutine): """Wrapper for a Fortran routine for which the corresponding file @@ -193,7 +198,7 @@ class LapackLibrary(FortranLibrary): def printRoutineNames(desc, routines): print(desc) for r in routines: - print(f'\t{r.name}') + print('\t%s' % r.name) def getLapackRoutines(wrapped_routines, ignores, lapack_dir): blas_src_dir = os.path.join(lapack_dir, 'BLAS', 'SRC') @@ -243,7 +248,7 @@ def dumpRoutineNames(library, output_dir): with open(filename, 'w') as fo: for r in routines: deps = r.dependencies() - fo.write(f"{r.name}: {' '.join(deps)}\n") + fo.write('%s: %s\n' % (r.name, ' '.join(deps))) def concatenateRoutines(routines, output_file): with open(output_file, 'w') as output_fo: @@ -261,8 +266,8 @@ def runF2C(fortran_filename, output_dir): subprocess.check_call( ["f2c"] + F2C_ARGS + ['-d', output_dir, fortran_filename] ) - except subprocess.CalledProcessError as e: - raise F2CError from e + except subprocess.CalledProcessError: + raise F2CError def scrubF2CSource(c_file): with open(c_file) as fo: @@ -275,8 +280,8 @@ def scrubF2CSource(c_file): def ensure_executable(name): try: which(name) - except Exception as ex: - raise SystemExit(name + ' not found') from ex + except Exception: + raise SystemExit(name + ' not found') def create_name_header(output_dir): routine_re = re.compile(r'^ (subroutine|.* function)\s+(\w+)\(.*$', @@ -316,13 +321,13 @@ def create_name_header(output_dir): # Rename BLAS/LAPACK symbols for name in sorted(symbols): - f.write(f'#define {name}_ BLAS_FUNC({name})\n') + f.write("#define %s_ BLAS_FUNC(%s)\n" % (name, name)) # Rename also symbols that f2c exports itself f.write("\n" "/* Symbols exported by f2c.c */\n") for name in sorted(f2c_symbols): - f.write(f'#define {name} numpy_lapack_lite_{name}\n') + f.write("#define %s numpy_lapack_lite_%s\n" % (name, name)) def main(): if len(sys.argv) != 3: @@ -348,9 +353,9 @@ def main(): dumpRoutineNames(library, output_dir) for typename in types: - fortran_file = os.path.join(output_dir, f'f2c_{typename}.f') + fortran_file = os.path.join(output_dir, 'f2c_%s.f' % typename) c_file = fortran_file[:-2] + '.c' - print(f'creating {c_file} ...') + print('creating %s ...' % c_file) routines = library.allRoutinesByType(typename) concatenateRoutines(routines, fortran_file) @@ -358,11 +363,11 @@ def main(): patch_file = os.path.basename(fortran_file) + '.patch' if os.path.exists(patch_file): subprocess.check_call(['patch', '-u', fortran_file, patch_file]) - print(f'Patched {fortran_file}') + print("Patched {}".format(fortran_file)) try: runF2C(fortran_file, output_dir) except F2CError: - print(f'f2c failed on {fortran_file}') + print('f2c failed on %s' % fortran_file) break scrubF2CSource(c_file) diff --git a/numpy/typing/tests/data/fail/char.py b/numpy/typing/tests/data/fail/char.py new file mode 100644 index 000000000..320f05df5 --- /dev/null +++ b/numpy/typing/tests/data/fail/char.py @@ -0,0 +1,66 @@ +import numpy as np +import numpy.typing as npt + +AR_U: npt.NDArray[np.str_] +AR_S: npt.NDArray[np.bytes_] + +np.char.equal(AR_U, AR_S) # E: incompatible type + +np.char.not_equal(AR_U, AR_S) # E: incompatible type + +np.char.greater_equal(AR_U, AR_S) # E: incompatible type + +np.char.less_equal(AR_U, AR_S) # E: incompatible type + +np.char.greater(AR_U, AR_S) # E: incompatible type + +np.char.less(AR_U, AR_S) # E: incompatible type + +np.char.encode(AR_S) # E: incompatible type +np.char.decode(AR_U) # E: incompatible type + +np.char.join(AR_U, b"_") # E: incompatible type +np.char.join(AR_S, "_") # E: incompatible type + +np.char.ljust(AR_U, 5, fillchar=b"a") # E: incompatible type +np.char.ljust(AR_S, 5, fillchar="a") # E: incompatible type +np.char.rjust(AR_U, 5, fillchar=b"a") # E: incompatible type +np.char.rjust(AR_S, 5, fillchar="a") # E: incompatible type + +np.char.lstrip(AR_U, chars=b"a") # E: incompatible type +np.char.lstrip(AR_S, chars="a") # E: incompatible type +np.char.strip(AR_U, chars=b"a") # E: incompatible type +np.char.strip(AR_S, chars="a") # E: incompatible type +np.char.rstrip(AR_U, chars=b"a") # E: incompatible type +np.char.rstrip(AR_S, chars="a") # E: incompatible type + +np.char.partition(AR_U, b"a") # E: incompatible type +np.char.partition(AR_S, "a") # E: incompatible type +np.char.rpartition(AR_U, b"a") # E: incompatible type +np.char.rpartition(AR_S, "a") # E: incompatible type + +np.char.replace(AR_U, b"_", b"-") # E: incompatible type +np.char.replace(AR_S, "_", "-") # E: incompatible type + +np.char.split(AR_U, b"_") # E: incompatible type +np.char.split(AR_S, "_") # E: incompatible type +np.char.rsplit(AR_U, b"_") # E: incompatible type +np.char.rsplit(AR_S, "_") # E: incompatible type + +np.char.count(AR_U, b"a", start=[1, 2, 3]) # E: incompatible type +np.char.count(AR_S, "a", end=9) # E: incompatible type + +np.char.endswith(AR_U, b"a", start=[1, 2, 3]) # E: incompatible type +np.char.endswith(AR_S, "a", end=9) # E: incompatible type +np.char.startswith(AR_U, b"a", start=[1, 2, 3]) # E: incompatible type +np.char.startswith(AR_S, "a", end=9) # E: incompatible type + +np.char.find(AR_U, b"a", start=[1, 2, 3]) # E: incompatible type +np.char.find(AR_S, "a", end=9) # E: incompatible type +np.char.rfind(AR_U, b"a", start=[1, 2, 3]) # E: incompatible type +np.char.rfind(AR_S, "a", end=9) # E: incompatible type + +np.char.index(AR_U, b"a", start=[1, 2, 3]) # E: incompatible type +np.char.index(AR_S, "a", end=9) # E: incompatible type +np.char.rindex(AR_U, b"a", start=[1, 2, 3]) # E: incompatible type +np.char.rindex(AR_S, "a", end=9) # E: incompatible type diff --git a/numpy/typing/tests/data/reveal/char.py b/numpy/typing/tests/data/reveal/char.py new file mode 100644 index 000000000..dd2e76a2d --- /dev/null +++ b/numpy/typing/tests/data/reveal/char.py @@ -0,0 +1,147 @@ +import numpy as np +import numpy.typing as npt +from typing import Sequence + +AR_U: npt.NDArray[np.str_] +AR_S: npt.NDArray[np.bytes_] + +reveal_type(np.char.equal(AR_U, AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] +reveal_type(np.char.equal(AR_S, AR_S)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] + +reveal_type(np.char.not_equal(AR_U, AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] +reveal_type(np.char.not_equal(AR_S, AR_S)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] + +reveal_type(np.char.greater_equal(AR_U, AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] +reveal_type(np.char.greater_equal(AR_S, AR_S)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] + +reveal_type(np.char.less_equal(AR_U, AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] +reveal_type(np.char.less_equal(AR_S, AR_S)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] + +reveal_type(np.char.greater(AR_U, AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] +reveal_type(np.char.greater(AR_S, AR_S)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] + +reveal_type(np.char.less(AR_U, AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] +reveal_type(np.char.less(AR_S, AR_S)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] + +reveal_type(np.char.multiply(AR_U, 5)) # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]] +reveal_type(np.char.multiply(AR_S, [5, 4, 3])) # E: numpy.ndarray[Any, numpy.dtype[numpy.bytes_]] + +reveal_type(np.char.mod(AR_U, "test")) # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]] +reveal_type(np.char.mod(AR_S, "test")) # E: numpy.ndarray[Any, numpy.dtype[numpy.bytes_]] + +reveal_type(np.char.capitalize(AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]] +reveal_type(np.char.capitalize(AR_S)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bytes_]] + +reveal_type(np.char.center(AR_U, 5)) # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]] +reveal_type(np.char.center(AR_S, [2, 3, 4], b"a")) # E: numpy.ndarray[Any, numpy.dtype[numpy.bytes_]] + +reveal_type(np.char.encode(AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bytes_]] +reveal_type(np.char.decode(AR_S)) # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]] + +reveal_type(np.char.expandtabs(AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]] +reveal_type(np.char.expandtabs(AR_S, tabsize=4)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bytes_]] + +reveal_type(np.char.join(AR_U, "_")) # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]] +reveal_type(np.char.join(AR_S, [b"_", b""])) # E: numpy.ndarray[Any, numpy.dtype[numpy.bytes_]] + +reveal_type(np.char.ljust(AR_U, 5)) # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]] +reveal_type(np.char.ljust(AR_S, [4, 3, 1], fillchar=[b"a", b"b", b"c"])) # E: numpy.ndarray[Any, numpy.dtype[numpy.bytes_]] +reveal_type(np.char.rjust(AR_U, 5)) # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]] +reveal_type(np.char.rjust(AR_S, [4, 3, 1], fillchar=[b"a", b"b", b"c"])) # E: numpy.ndarray[Any, numpy.dtype[numpy.bytes_]] + +reveal_type(np.char.lstrip(AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]] +reveal_type(np.char.lstrip(AR_S, chars=b"_")) # E: numpy.ndarray[Any, numpy.dtype[numpy.bytes_]] +reveal_type(np.char.rstrip(AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]] +reveal_type(np.char.rstrip(AR_S, chars=b"_")) # E: numpy.ndarray[Any, numpy.dtype[numpy.bytes_]] +reveal_type(np.char.strip(AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]] +reveal_type(np.char.strip(AR_S, chars=b"_")) # E: numpy.ndarray[Any, numpy.dtype[numpy.bytes_]] + +reveal_type(np.char.partition(AR_U, "\n")) # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]] +reveal_type(np.char.partition(AR_S, [b"a", b"b", b"c"])) # E: numpy.ndarray[Any, numpy.dtype[numpy.bytes_]] +reveal_type(np.char.rpartition(AR_U, "\n")) # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]] +reveal_type(np.char.rpartition(AR_S, [b"a", b"b", b"c"])) # E: numpy.ndarray[Any, numpy.dtype[numpy.bytes_]] + +reveal_type(np.char.replace(AR_U, "_", "-")) # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]] +reveal_type(np.char.replace(AR_S, [b"_", b""], [b"a", b"b"])) # E: numpy.ndarray[Any, numpy.dtype[numpy.bytes_]] + +reveal_type(np.char.split(AR_U, "_")) # E: numpy.ndarray[Any, numpy.dtype[numpy.object_]] +reveal_type(np.char.split(AR_S, maxsplit=[1, 2, 3])) # E: numpy.ndarray[Any, numpy.dtype[numpy.object_]] +reveal_type(np.char.rsplit(AR_U, "_")) # E: numpy.ndarray[Any, numpy.dtype[numpy.object_]] +reveal_type(np.char.rsplit(AR_S, maxsplit=[1, 2, 3])) # E: numpy.ndarray[Any, numpy.dtype[numpy.object_]] + +reveal_type(np.char.splitlines(AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.object_]] +reveal_type(np.char.splitlines(AR_S, keepends=[True, True, False])) # E: numpy.ndarray[Any, numpy.dtype[numpy.object_]] + +reveal_type(np.char.swapcase(AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]] +reveal_type(np.char.swapcase(AR_S)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bytes_]] + +reveal_type(np.char.title(AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]] +reveal_type(np.char.title(AR_S)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bytes_]] + +reveal_type(np.char.upper(AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]] +reveal_type(np.char.upper(AR_S)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bytes_]] + +reveal_type(np.char.zfill(AR_U, 5)) # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]] +reveal_type(np.char.zfill(AR_S, [2, 3, 4])) # E: numpy.ndarray[Any, numpy.dtype[numpy.bytes_]] + +reveal_type(np.char.count(AR_U, "a", start=[1, 2, 3])) # E: numpy.ndarray[Any, numpy.dtype[{int_}]] +reveal_type(np.char.count(AR_S, [b"a", b"b", b"c"], end=9)) # E: numpy.ndarray[Any, numpy.dtype[{int_}]] + +reveal_type(np.char.endswith(AR_U, "a", start=[1, 2, 3])) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] +reveal_type(np.char.endswith(AR_S, [b"a", b"b", b"c"], end=9)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] +reveal_type(np.char.startswith(AR_U, "a", start=[1, 2, 3])) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] +reveal_type(np.char.startswith(AR_S, [b"a", b"b", b"c"], end=9)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] + +reveal_type(np.char.find(AR_U, "a", start=[1, 2, 3])) # E: numpy.ndarray[Any, numpy.dtype[{int_}]] +reveal_type(np.char.find(AR_S, [b"a", b"b", b"c"], end=9)) # E: numpy.ndarray[Any, numpy.dtype[{int_}]] +reveal_type(np.char.rfind(AR_U, "a", start=[1, 2, 3])) # E: numpy.ndarray[Any, numpy.dtype[{int_}]] +reveal_type(np.char.rfind(AR_S, [b"a", b"b", b"c"], end=9)) # E: numpy.ndarray[Any, numpy.dtype[{int_}]] + +reveal_type(np.char.index(AR_U, "a", start=[1, 2, 3])) # E: numpy.ndarray[Any, numpy.dtype[{int_}]] +reveal_type(np.char.index(AR_S, [b"a", b"b", b"c"], end=9)) # E: numpy.ndarray[Any, numpy.dtype[{int_}]] +reveal_type(np.char.rindex(AR_U, "a", start=[1, 2, 3])) # E: numpy.ndarray[Any, numpy.dtype[{int_}]] +reveal_type(np.char.rindex(AR_S, [b"a", b"b", b"c"], end=9)) # E: numpy.ndarray[Any, numpy.dtype[{int_}]] + +reveal_type(np.char.isalpha(AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] +reveal_type(np.char.isalpha(AR_S)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] + +reveal_type(np.char.isalnum(AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] +reveal_type(np.char.isalnum(AR_S)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] + +reveal_type(np.char.isdecimal(AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] +reveal_type(np.char.isdecimal(AR_S)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] + +reveal_type(np.char.isdigit(AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] +reveal_type(np.char.isdigit(AR_S)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] + +reveal_type(np.char.islower(AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] +reveal_type(np.char.islower(AR_S)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] + +reveal_type(np.char.isnumeric(AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] +reveal_type(np.char.isnumeric(AR_S)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] + +reveal_type(np.char.isspace(AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] +reveal_type(np.char.isspace(AR_S)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] + +reveal_type(np.char.istitle(AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] +reveal_type(np.char.istitle(AR_S)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] + +reveal_type(np.char.isupper(AR_U)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] +reveal_type(np.char.isupper(AR_S)) # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]] + +reveal_type(np.char.str_len(AR_U)) # E: numpy.ndarray[Any, numpy.dtype[{int_}]] +reveal_type(np.char.str_len(AR_S)) # E: numpy.ndarray[Any, numpy.dtype[{int_}]] + +reveal_type(np.char.array(AR_U)) # E: numpy.chararray[Any, numpy.dtype[numpy.str_]] +reveal_type(np.char.array(AR_S, order="K")) # E: numpy.chararray[Any, numpy.dtype[numpy.bytes_]] +reveal_type(np.char.array("bob", copy=True)) # E: numpy.chararray[Any, numpy.dtype[numpy.str_]] +reveal_type(np.char.array(b"bob", itemsize=5)) # E: numpy.chararray[Any, numpy.dtype[numpy.bytes_]] +reveal_type(np.char.array(1, unicode=False)) # E: numpy.chararray[Any, numpy.dtype[numpy.bytes_]] +reveal_type(np.char.array(1, unicode=True)) # E: numpy.chararray[Any, numpy.dtype[numpy.str_]] + +reveal_type(np.char.asarray(AR_U)) # E: numpy.chararray[Any, numpy.dtype[numpy.str_]] +reveal_type(np.char.asarray(AR_S, order="K")) # E: numpy.chararray[Any, numpy.dtype[numpy.bytes_]] +reveal_type(np.char.asarray("bob")) # E: numpy.chararray[Any, numpy.dtype[numpy.str_]] +reveal_type(np.char.asarray(b"bob", itemsize=5)) # E: numpy.chararray[Any, numpy.dtype[numpy.bytes_]] +reveal_type(np.char.asarray(1, unicode=False)) # E: numpy.chararray[Any, numpy.dtype[numpy.bytes_]] +reveal_type(np.char.asarray(1, unicode=True)) # E: numpy.chararray[Any, numpy.dtype[numpy.str_]] diff --git a/numpy/typing/tests/test_isfile.py b/numpy/typing/tests/test_isfile.py index b617b3873..ac99cb6c1 100644 --- a/numpy/typing/tests/test_isfile.py +++ b/numpy/typing/tests/test_isfile.py @@ -8,7 +8,6 @@ ROOT = Path(np.__file__).parents[0] FILES = [ ROOT / "py.typed", ROOT / "__init__.pyi", - ROOT / "char.pyi", ROOT / "ctypeslib.pyi", ROOT / "rec.pyi", ROOT / "core" / "__init__.pyi", |