numpy 2.4.0__cp313-cp313t-musllinux_1_2_aarch64.whl

numpy/f2py/f2py2e.pyi

@@ -0,0 +1,74 @@
+import argparse
+import pprint
+from collections.abc import Hashable, Iterable, Mapping, MutableMapping, Sequence
+from types import ModuleType
+from typing import Any, Final, NotRequired, TypedDict, type_check_only
+from typing_extensions import TypeVar, override
+
+from .__version__ import version
+from .auxfuncs import _Bool, outmess as outmess
+
+###
+
+_KT = TypeVar("_KT", bound=Hashable)
+_VT = TypeVar("_VT")
+
+@type_check_only
+class _F2PyDict(TypedDict):
+    csrc: list[str]
+    h: list[str]
+    fsrc: NotRequired[list[str]]
+    ltx: NotRequired[list[str]]
+
+@type_check_only
+class _PreparseResult(TypedDict):
+    dependencies: list[str]
+    backend: str
+    modulename: str
+
+###
+
+MESON_ONLY_VER: Final[bool]
+f2py_version: Final = version
+numpy_version: Final = version
+__usage__: Final[str]
+
+show = pprint.pprint
+
+class CombineIncludePaths(argparse.Action):
+    @override
+    def __call__(
+        self,
+        /,
+        parser: argparse.ArgumentParser,
+        namespace: argparse.Namespace,
+        values: str | Sequence[str] | None,
+        option_string: str | None = None,
+    ) -> None: ...
+
+#
+def run_main(comline_list: Iterable[str]) -> dict[str, _F2PyDict]: ...
+def run_compile() -> None: ...
+def main() -> None: ...
+
+#
+def scaninputline(inputline: Iterable[str]) -> tuple[list[str], dict[str, _Bool]]: ...
+def callcrackfortran(files: list[str], options: dict[str, bool]) -> list[dict[str, Any]]: ...
+def buildmodules(lst: Iterable[Mapping[str, object]]) -> dict[str, dict[str, Any]]: ...
+def dict_append(d_out: MutableMapping[_KT, _VT], d_in: Mapping[_KT, _VT]) -> None: ...
+def filter_files(
+    prefix: str,
+    suffix: str,
+    files: Iterable[str],
+    remove_prefix: _Bool | None = None,
+) -> tuple[list[str], list[str]]: ...
+def get_prefix(module: ModuleType) -> str: ...
+def get_newer_options(iline: Iterable[str]) -> tuple[list[str], Any, list[str]]: ...
+
+#
+def f2py_parser() -> argparse.ArgumentParser: ...
+def make_f2py_compile_parser() -> argparse.ArgumentParser: ...
+
+#
+def preparse_sysargv() -> _PreparseResult: ...
+def validate_modulename(pyf_files: Sequence[str], modulename: str = "untitled") -> str: ...

numpy/f2py/f90mod_rules.py

@@ -0,0 +1,269 @@
+"""
+Build F90 module support for f2py2e.
+
+Copyright 1999 -- 2011 Pearu Peterson all rights reserved.
+Copyright 2011 -- present NumPy Developers.
+Permission to use, modify, and distribute this software is given under the
+terms of the NumPy License.
+
+NO WARRANTY IS EXPRESSED OR IMPLIED.  USE AT YOUR OWN RISK.
+"""
+__version__ = "$Revision: 1.27 $"[10:-1]
+
+f2py_version = 'See `f2py -v`'
+
+import numpy as np
+
+from . import capi_maps, func2subr
+
+# The environment provided by auxfuncs.py is needed for some calls to eval.
+# As the needed functions cannot be determined by static inspection of the
+# code, it is safest to use import * pending a major refactoring of f2py.
+from .auxfuncs import *
+from .crackfortran import undo_rmbadname, undo_rmbadname1
+
+options = {}
+
+
+def findf90modules(m):
+    if ismodule(m):
+        return [m]
+    if not hasbody(m):
+        return []
+    ret = []
+    for b in m['body']:
+        if ismodule(b):
+            ret.append(b)
+        else:
+            ret = ret + findf90modules(b)
+    return ret
+
+
+fgetdims1 = """\
+      external f2pysetdata
+      logical ns
+      integer r,i
+      integer(%d) s(*)
+      ns = .FALSE.
+      if (allocated(d)) then
+         do i=1,r
+            if ((size(d,i).ne.s(i)).and.(s(i).ge.0)) then
+               ns = .TRUE.
+            end if
+         end do
+         if (ns) then
+            deallocate(d)
+         end if
+      end if
+      if ((.not.allocated(d)).and.(s(1).ge.1)) then""" % np.intp().itemsize
+
+fgetdims2 = """\
+      end if
+      if (allocated(d)) then
+         do i=1,r
+            s(i) = size(d,i)
+         end do
+      end if
+      flag = 1
+      call f2pysetdata(d,allocated(d))"""
+
+fgetdims2_sa = """\
+      end if
+      if (allocated(d)) then
+         do i=1,r
+            s(i) = size(d,i)
+         end do
+         !s(r) must be equal to len(d(1))
+      end if
+      flag = 2
+      call f2pysetdata(d,allocated(d))"""
+
+
+def buildhooks(pymod):
+    from . import rules
+    ret = {'f90modhooks': [], 'initf90modhooks': [], 'body': [],
+           'need': ['F_FUNC', 'arrayobject.h'],
+           'separatorsfor': {'includes0': '\n', 'includes': '\n'},
+           'docs': ['"Fortran 90/95 modules:\\n"'],
+           'latexdoc': []}
+    fhooks = ['']
+
+    def fadd(line, s=fhooks):
+        s[0] = f'{s[0]}\n      {line}'
+    doc = ['']
+
+    def dadd(line, s=doc):
+        s[0] = f'{s[0]}\n{line}'
+
+    usenames = getuseblocks(pymod)
+    for m in findf90modules(pymod):
+        sargs, fargs, efargs, modobjs, notvars, onlyvars = [], [], [], [], [
+            m['name']], []
+        sargsp = []
+        ifargs = []
+        mfargs = []
+        if hasbody(m):
+            for b in m['body']:
+                notvars.append(b['name'])
+        for n in m['vars'].keys():
+            var = m['vars'][n]
+
+            if (n not in notvars and isvariable(var)) and (not l_or(isintent_hide, isprivate)(var)):
+                onlyvars.append(n)
+                mfargs.append(n)
+        outmess(f"\t\tConstructing F90 module support for \"{m['name']}\"...\n")
+        if len(onlyvars) == 0 and len(notvars) == 1 and m['name'] in notvars:
+            outmess(f"\t\t\tSkipping {m['name']} since there are no public vars/func in this module...\n")
+            continue
+
+        # gh-25186
+        if m['name'] in usenames and containscommon(m):
+            outmess(f"\t\t\tSkipping {m['name']} since it is in 'use' and contains a common block...\n")
+            continue
+        # skip modules with derived types
+        if m['name'] in usenames and containsderivedtypes(m):
+            outmess(f"\t\t\tSkipping {m['name']} since it is in 'use' and contains a derived type...\n")
+            continue
+        if onlyvars:
+            outmess(f"\t\t  Variables: {' '.join(onlyvars)}\n")
+        chooks = ['']
+
+        def cadd(line, s=chooks):
+            s[0] = f'{s[0]}\n{line}'
+        ihooks = ['']
+
+        def iadd(line, s=ihooks):
+            s[0] = f'{s[0]}\n{line}'
+
+        vrd = capi_maps.modsign2map(m)
+        cadd('static FortranDataDef f2py_%s_def[] = {' % (m['name']))
+        dadd('\\subsection{Fortran 90/95 module \\texttt{%s}}\n' % (m['name']))
+        if hasnote(m):
+            note = m['note']
+            if isinstance(note, list):
+                note = '\n'.join(note)
+            dadd(note)
+        if onlyvars:
+            dadd('\\begin{description}')
+        for n in onlyvars:
+            var = m['vars'][n]
+            modobjs.append(n)
+            ct = capi_maps.getctype(var)
+            at = capi_maps.c2capi_map[ct]
+            dm = capi_maps.getarrdims(n, var)
+            dms = dm['dims'].replace('*', '-1').strip()
+            dms = dms.replace(':', '-1').strip()
+            if not dms:
+                dms = '-1'
+            use_fgetdims2 = fgetdims2
+            cadd('\t{"%s",%s,{{%s}},%s, %s},' %
+                 (undo_rmbadname1(n), dm['rank'], dms, at,
+                  capi_maps.get_elsize(var)))
+            dadd('\\item[]{{}\\verb@%s@{}}' %
+                 (capi_maps.getarrdocsign(n, var)))
+            if hasnote(var):
+                note = var['note']
+                if isinstance(note, list):
+                    note = '\n'.join(note)
+                dadd(f'--- {note}')
+            if isallocatable(var):
+                fargs.append(f"f2py_{m['name']}_getdims_{n}")
+                efargs.append(fargs[-1])
+                sargs.append(
+                    f'void (*{n})(int*,npy_intp*,void(*)(char*,npy_intp*),int*)')
+                sargsp.append('void (*)(int*,npy_intp*,void(*)(char*,npy_intp*),int*)')
+                iadd(f"\tf2py_{m['name']}_def[i_f2py++].func = {n};")
+                fadd(f'subroutine {fargs[-1]}(r,s,f2pysetdata,flag)')
+                fadd(f"use {m['name']}, only: d => {undo_rmbadname1(n)}\n")
+                fadd('integer flag\n')
+                fhooks[0] = fhooks[0] + fgetdims1
+                dms = range(1, int(dm['rank']) + 1)
+                fadd(' allocate(d(%s))\n' %
+                     (','.join(['s(%s)' % i for i in dms])))
+                fhooks[0] = fhooks[0] + use_fgetdims2
+                fadd(f'end subroutine {fargs[-1]}')
+            else:
+                fargs.append(n)
+                sargs.append(f'char *{n}')
+                sargsp.append('char*')
+                iadd(f"\tf2py_{m['name']}_def[i_f2py++].data = {n};")
+        if onlyvars:
+            dadd('\\end{description}')
+        if hasbody(m):
+            for b in m['body']:
+                if not isroutine(b):
+                    outmess("f90mod_rules.buildhooks:"
+                            f" skipping {b['block']} {b['name']}\n")
+                    continue
+                modobjs.append(f"{b['name']}()")
+                b['modulename'] = m['name']
+                api, wrap = rules.buildapi(b)
+                if isfunction(b):
+                    fhooks[0] = fhooks[0] + wrap
+                    fargs.append(f"f2pywrap_{m['name']}_{b['name']}")
+                    ifargs.append(func2subr.createfuncwrapper(b, signature=1))
+                elif wrap:
+                    fhooks[0] = fhooks[0] + wrap
+                    fargs.append(f"f2pywrap_{m['name']}_{b['name']}")
+                    ifargs.append(
+                        func2subr.createsubrwrapper(b, signature=1))
+                else:
+                    fargs.append(b['name'])
+                    mfargs.append(fargs[-1])
+                api['externroutines'] = []
+                ar = applyrules(api, vrd)
+                ar['docs'] = []
+                ar['docshort'] = []
+                ret = dictappend(ret, ar)
+                cadd(('\t{"%s",-1,{{-1}},0,0,NULL,(void *)'
+                      'f2py_rout_#modulename#_%s_%s,'
+                      'doc_f2py_rout_#modulename#_%s_%s},')
+                     % (b['name'], m['name'], b['name'], m['name'], b['name']))
+                sargs.append(f"char *{b['name']}")
+                sargsp.append('char *')
+                iadd(f"\tf2py_{m['name']}_def[i_f2py++].data = {b['name']};")
+        cadd('\t{NULL}\n};\n')
+        iadd('}')
+        ihooks[0] = 'static void f2py_setup_%s(%s) {\n\tint i_f2py=0;%s' % (
+            m['name'], ','.join(sargs), ihooks[0])
+        if '_' in m['name']:
+            F_FUNC = 'F_FUNC_US'
+        else:
+            F_FUNC = 'F_FUNC'
+        iadd('extern void %s(f2pyinit%s,F2PYINIT%s)(void (*)(%s));'
+             % (F_FUNC, m['name'], m['name'].upper(), ','.join(sargsp)))
+        iadd('static void f2py_init_%s(void) {' % (m['name']))
+        iadd('\t%s(f2pyinit%s,F2PYINIT%s)(f2py_setup_%s);'
+             % (F_FUNC, m['name'], m['name'].upper(), m['name']))
+        iadd('}\n')
+        ret['f90modhooks'] = ret['f90modhooks'] + chooks + ihooks
+        ret['initf90modhooks'] = ['\tPyDict_SetItemString(d, "%s", PyFortranObject_New(f2py_%s_def,f2py_init_%s));' % (
+            m['name'], m['name'], m['name'])] + ret['initf90modhooks']
+        fadd('')
+        fadd(f"subroutine f2pyinit{m['name']}(f2pysetupfunc)")
+        if mfargs:
+            for a in undo_rmbadname(mfargs):
+                fadd(f"use {m['name']}, only : {a}")
+        if ifargs:
+            fadd(' '.join(['interface'] + ifargs))
+            fadd('end interface')
+        fadd('external f2pysetupfunc')
+        if efargs:
+            for a in undo_rmbadname(efargs):
+                fadd(f'external {a}')
+        fadd(f"call f2pysetupfunc({','.join(undo_rmbadname(fargs))})")
+        fadd(f"end subroutine f2pyinit{m['name']}\n")
+
+        dadd('\n'.join(ret['latexdoc']).replace(
+            r'\subsection{', r'\subsubsection{'))
+
+        ret['latexdoc'] = []
+        ret['docs'].append(f"\"\t{m['name']} --- {','.join(undo_rmbadname(modobjs))}\"")
+
+    ret['routine_defs'] = ''
+    ret['doc'] = []
+    ret['docshort'] = []
+    ret['latexdoc'] = doc[0]
+    if len(ret['docs']) <= 1:
+        ret['docs'] = ''
+    return ret, fhooks[0]

numpy/f2py/f90mod_rules.pyi

@@ -0,0 +1,16 @@
+from collections.abc import Mapping
+from typing import Any, Final
+
+from .auxfuncs import isintent_dict as isintent_dict
+
+__version__: Final[str] = ...
+f2py_version: Final = "See `f2py -v`"
+
+options: Final[dict[str, bool]]
+
+fgetdims1: Final[str] = ...
+fgetdims2: Final[str] = ...
+fgetdims2_sa: Final[str] = ...
+
+def findf90modules(m: Mapping[str, object]) -> list[dict[str, Any]]: ...
+def buildhooks(pymod: Mapping[str, object]) -> dict[str, Any]: ...

numpy/f2py/func2subr.py

@@ -0,0 +1,329 @@
+"""
+
+Rules for building C/API module with f2py2e.
+
+Copyright 1999 -- 2011 Pearu Peterson all rights reserved.
+Copyright 2011 -- present NumPy Developers.
+Permission to use, modify, and distribute this software is given under the
+terms of the NumPy License.
+
+NO WARRANTY IS EXPRESSED OR IMPLIED.  USE AT YOUR OWN RISK.
+"""
+import copy
+
+from ._isocbind import isoc_kindmap
+from .auxfuncs import (
+    getfortranname,
+    isexternal,
+    isfunction,
+    isfunction_wrap,
+    isintent_in,
+    isintent_out,
+    islogicalfunction,
+    ismoduleroutine,
+    isscalar,
+    issubroutine,
+    issubroutine_wrap,
+    outmess,
+    show,
+)
+
+
+def var2fixfortran(vars, a, fa=None, f90mode=None):
+    if fa is None:
+        fa = a
+    if a not in vars:
+        show(vars)
+        outmess(f'var2fixfortran: No definition for argument "{a}".\n')
+        return ''
+    if 'typespec' not in vars[a]:
+        show(vars[a])
+        outmess(f'var2fixfortran: No typespec for argument "{a}".\n')
+        return ''
+    vardef = vars[a]['typespec']
+    if vardef == 'type' and 'typename' in vars[a]:
+        vardef = f"{vardef}({vars[a]['typename']})"
+    selector = {}
+    lk = ''
+    if 'kindselector' in vars[a]:
+        selector = vars[a]['kindselector']
+        lk = 'kind'
+    elif 'charselector' in vars[a]:
+        selector = vars[a]['charselector']
+        lk = 'len'
+    if '*' in selector:
+        if f90mode:
+            if selector['*'] in ['*', ':', '(*)']:
+                vardef = f'{vardef}(len=*)'
+            else:
+                vardef = f"{vardef}({lk}={selector['*']})"
+        elif selector['*'] in ['*', ':']:
+            vardef = f"{vardef}*({selector['*']})"
+        else:
+            vardef = f"{vardef}*{selector['*']}"
+    elif 'len' in selector:
+        vardef = f"{vardef}(len={selector['len']}"
+        if 'kind' in selector:
+            vardef = f"{vardef},kind={selector['kind']})"
+        else:
+            vardef = f'{vardef})'
+    elif 'kind' in selector:
+        vardef = f"{vardef}(kind={selector['kind']})"
+
+    vardef = f'{vardef} {fa}'
+    if 'dimension' in vars[a]:
+        vardef = f"{vardef}({','.join(vars[a]['dimension'])})"
+    return vardef
+
+def useiso_c_binding(rout):
+    useisoc = False
+    for value in rout['vars'].values():
+        kind_value = value.get('kindselector', {}).get('kind')
+        if kind_value in isoc_kindmap:
+            return True
+    return useisoc
+
+def createfuncwrapper(rout, signature=0):
+    assert isfunction(rout)
+
+    extra_args = []
+    vars = rout['vars']
+    for a in rout['args']:
+        v = rout['vars'][a]
+        for i, d in enumerate(v.get('dimension', [])):
+            if d == ':':
+                dn = f'f2py_{a}_d{i}'
+                dv = {'typespec': 'integer', 'intent': ['hide']}
+                dv['='] = f'shape({a}, {i})'
+                extra_args.append(dn)
+                vars[dn] = dv
+                v['dimension'][i] = dn
+    rout['args'].extend(extra_args)
+    need_interface = bool(extra_args)
+
+    ret = ['']
+
+    def add(line, ret=ret):
+        ret[0] = f'{ret[0]}\n      {line}'
+    name = rout['name']
+    fortranname = getfortranname(rout)
+    f90mode = ismoduleroutine(rout)
+    newname = f'{name}f2pywrap'
+
+    if newname not in vars:
+        vars[newname] = vars[name]
+        args = [newname] + rout['args'][1:]
+    else:
+        args = [newname] + rout['args']
+
+    l_tmpl = var2fixfortran(vars, name, '@@@NAME@@@', f90mode)
+    if l_tmpl[:13] == 'character*(*)':
+        if f90mode:
+            l_tmpl = 'character(len=10)' + l_tmpl[13:]
+        else:
+            l_tmpl = 'character*10' + l_tmpl[13:]
+        charselect = vars[name]['charselector']
+        if charselect.get('*', '') == '(*)':
+            charselect['*'] = '10'
+
+    l1 = l_tmpl.replace('@@@NAME@@@', newname)
+    rl = None
+
+    useisoc = useiso_c_binding(rout)
+    sargs = ', '.join(args)
+    if f90mode:
+        # gh-23598 fix warning
+        # Essentially, this gets called again with modules where the name of the
+        # function is added to the arguments, which is not required, and removed
+        sargs = sargs.replace(f"{name}, ", '')
+        args = [arg for arg in args if arg != name]
+        rout['args'] = args
+        add(f"subroutine f2pywrap_{rout['modulename']}_{name} ({sargs})")
+        if not signature:
+            add(f"use {rout['modulename']}, only : {fortranname}")
+        if useisoc:
+            add('use iso_c_binding')
+    else:
+        add(f'subroutine f2pywrap{name} ({sargs})')
+        if useisoc:
+            add('use iso_c_binding')
+        if not need_interface:
+            add(f'external {fortranname}')
+            rl = l_tmpl.replace('@@@NAME@@@', '') + ' ' + fortranname
+
+    if need_interface:
+        for line in rout['saved_interface'].split('\n'):
+            if line.lstrip().startswith('use ') and '__user__' not in line:
+                add(line)
+
+    args = args[1:]
+    dumped_args = []
+    for a in args:
+        if isexternal(vars[a]):
+            add(f'external {a}')
+            dumped_args.append(a)
+    for a in args:
+        if a in dumped_args:
+            continue
+        if isscalar(vars[a]):
+            add(var2fixfortran(vars, a, f90mode=f90mode))
+            dumped_args.append(a)
+    for a in args:
+        if a in dumped_args:
+            continue
+        if isintent_in(vars[a]):
+            add(var2fixfortran(vars, a, f90mode=f90mode))
+            dumped_args.append(a)
+    for a in args:
+        if a in dumped_args:
+            continue
+        add(var2fixfortran(vars, a, f90mode=f90mode))
+
+    add(l1)
+    if rl is not None:
+        add(rl)
+
+    if need_interface:
+        if f90mode:
+            # f90 module already defines needed interface
+            pass
+        else:
+            add('interface')
+            add(rout['saved_interface'].lstrip())
+            add('end interface')
+
+    sargs = ', '.join([a for a in args if a not in extra_args])
+
+    if not signature:
+        if islogicalfunction(rout):
+            add(f'{newname} = .not.(.not.{fortranname}({sargs}))')
+        else:
+            add(f'{newname} = {fortranname}({sargs})')
+    if f90mode:
+        add(f"end subroutine f2pywrap_{rout['modulename']}_{name}")
+    else:
+        add('end')
+    return ret[0]
+
+
+def createsubrwrapper(rout, signature=0):
+    assert issubroutine(rout)
+
+    extra_args = []
+    vars = rout['vars']
+    for a in rout['args']:
+        v = rout['vars'][a]
+        for i, d in enumerate(v.get('dimension', [])):
+            if d == ':':
+                dn = f'f2py_{a}_d{i}'
+                dv = {'typespec': 'integer', 'intent': ['hide']}
+                dv['='] = f'shape({a}, {i})'
+                extra_args.append(dn)
+                vars[dn] = dv
+                v['dimension'][i] = dn
+    rout['args'].extend(extra_args)
+    need_interface = bool(extra_args)
+
+    ret = ['']
+
+    def add(line, ret=ret):
+        ret[0] = f'{ret[0]}\n      {line}'
+    name = rout['name']
+    fortranname = getfortranname(rout)
+    f90mode = ismoduleroutine(rout)
+
+    args = rout['args']
+
+    useisoc = useiso_c_binding(rout)
+    sargs = ', '.join(args)
+    if f90mode:
+        add(f"subroutine f2pywrap_{rout['modulename']}_{name} ({sargs})")
+        if useisoc:
+            add('use iso_c_binding')
+        if not signature:
+            add(f"use {rout['modulename']}, only : {fortranname}")
+    else:
+        add(f'subroutine f2pywrap{name} ({sargs})')
+        if useisoc:
+            add('use iso_c_binding')
+        if not need_interface:
+            add(f'external {fortranname}')
+
+    if need_interface:
+        for line in rout['saved_interface'].split('\n'):
+            if line.lstrip().startswith('use ') and '__user__' not in line:
+                add(line)
+
+    dumped_args = []
+    for a in args:
+        if isexternal(vars[a]):
+            add(f'external {a}')
+            dumped_args.append(a)
+    for a in args:
+        if a in dumped_args:
+            continue
+        if isscalar(vars[a]):
+            add(var2fixfortran(vars, a, f90mode=f90mode))
+            dumped_args.append(a)
+    for a in args:
+        if a in dumped_args:
+            continue
+        add(var2fixfortran(vars, a, f90mode=f90mode))
+
+    if need_interface:
+        if f90mode:
+            # f90 module already defines needed interface
+            pass
+        else:
+            add('interface')
+            for line in rout['saved_interface'].split('\n'):
+                if line.lstrip().startswith('use ') and '__user__' in line:
+                    continue
+                add(line)
+            add('end interface')
+
+    sargs = ', '.join([a for a in args if a not in extra_args])
+
+    if not signature:
+        add(f'call {fortranname}({sargs})')
+    if f90mode:
+        add(f"end subroutine f2pywrap_{rout['modulename']}_{name}")
+    else:
+        add('end')
+    return ret[0]
+
+
+def assubr(rout):
+    if isfunction_wrap(rout):
+        fortranname = getfortranname(rout)
+        name = rout['name']
+        outmess('\t\tCreating wrapper for Fortran function "%s"("%s")...\n' % (
+            name, fortranname))
+        rout = copy.copy(rout)
+        fname = name
+        rname = fname
+        if 'result' in rout:
+            rname = rout['result']
+            rout['vars'][fname] = rout['vars'][rname]
+        fvar = rout['vars'][fname]
+        if not isintent_out(fvar):
+            if 'intent' not in fvar:
+                fvar['intent'] = []
+            fvar['intent'].append('out')
+            flag = 1
+            for i in fvar['intent']:
+                if i.startswith('out='):
+                    flag = 0
+                    break
+            if flag:
+                fvar['intent'].append(f'out={rname}')
+        rout['args'][:] = [fname] + rout['args']
+        return rout, createfuncwrapper(rout)
+    if issubroutine_wrap(rout):
+        fortranname = getfortranname(rout)
+        name = rout['name']
+        outmess('\t\tCreating wrapper for Fortran subroutine "%s"("%s")...\n'
+                % (name, fortranname))
+        rout = copy.copy(rout)
+        return rout, createsubrwrapper(rout)
+    return rout, ''

numpy/f2py/func2subr.pyi

@@ -0,0 +1,7 @@
+from .auxfuncs import _Bool, _ROut, _Var
+
+def var2fixfortran(vars: _Var, a: str, fa: str | None = None, f90mode: _Bool | None = None) -> str: ...
+def useiso_c_binding(rout: _ROut) -> bool: ...
+def createfuncwrapper(rout: _ROut, signature: int = 0) -> str: ...
+def createsubrwrapper(rout: _ROut, signature: int = 0) -> str: ...
+def assubr(rout: _ROut) -> tuple[dict[str, str], str]: ...