You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
259 lines
10 KiB
Python
259 lines
10 KiB
Python
import re
|
|
from collections.abc import Callable, Iterable, Mapping
|
|
from typing import IO, Any, Concatenate, Final, Never, ParamSpec, TypeAlias, overload
|
|
from typing import Literal as L
|
|
|
|
from _typeshed import StrOrBytesPath, StrPath
|
|
|
|
from .__version__ import version
|
|
from .auxfuncs import isintent_dict as isintent_dict
|
|
|
|
###
|
|
|
|
_Tss = ParamSpec("_Tss")
|
|
|
|
_VisitResult: TypeAlias = list[Any] | dict[str, Any] | None
|
|
_VisitItem: TypeAlias = tuple[str | None, _VisitResult]
|
|
_VisitFunc: TypeAlias = Callable[Concatenate[_VisitItem, list[_VisitItem], _VisitResult, _Tss], _VisitItem | None]
|
|
|
|
###
|
|
|
|
COMMON_FREE_EXTENSIONS: Final[list[str]] = ...
|
|
COMMON_FIXED_EXTENSIONS: Final[list[str]] = ...
|
|
|
|
f2py_version: Final = version
|
|
tabchar: Final[str] = " "
|
|
|
|
f77modulename: str
|
|
pyffilename: str
|
|
sourcecodeform: L["fix", "gree"]
|
|
strictf77: L[0, 1]
|
|
quiet: L[0, 1]
|
|
verbose: L[0, 1, 2]
|
|
skipemptyends: L[0, 1]
|
|
ignorecontains: L[1]
|
|
dolowercase: L[1]
|
|
|
|
beginpattern: str | re.Pattern[str]
|
|
currentfilename: str
|
|
filepositiontext: str
|
|
expectbegin: L[0, 1]
|
|
gotnextfile: L[0, 1]
|
|
neededmodule: int
|
|
skipblocksuntil: int
|
|
groupcounter: int
|
|
groupname: dict[int, str] | str
|
|
groupcache: dict[int, dict[str, Any]] | None
|
|
grouplist: dict[int, list[dict[str, Any]]] | None
|
|
previous_context: tuple[str, str, int] | None
|
|
|
|
f90modulevars: dict[str, dict[str, Any]] = {}
|
|
debug: list[Never] = []
|
|
include_paths: list[str] = []
|
|
onlyfuncs: list[str] = []
|
|
skipfuncs: list[str] = []
|
|
skipfunctions: Final[list[str]] = []
|
|
usermodules: Final[list[dict[str, Any]]] = []
|
|
|
|
defaultimplicitrules: Final[dict[str, dict[str, str]]] = {}
|
|
badnames: Final[dict[str, str]] = {}
|
|
invbadnames: Final[dict[str, str]] = {}
|
|
|
|
beforethisafter: Final[str] = ...
|
|
fortrantypes: Final[str] = ...
|
|
groupbegins77: Final[str] = ...
|
|
groupbegins90: Final[str] = ...
|
|
groupends: Final[str] = ...
|
|
endifs: Final[str] = ...
|
|
moduleprocedures: Final[str] = ...
|
|
|
|
beginpattern77: Final[tuple[re.Pattern[str], L["begin"]]] = ...
|
|
beginpattern90: Final[tuple[re.Pattern[str], L["begin"]]] = ...
|
|
callpattern: Final[tuple[re.Pattern[str], L["call"]]] = ...
|
|
callfunpattern: Final[tuple[re.Pattern[str], L["callfun"]]] = ...
|
|
commonpattern: Final[tuple[re.Pattern[str], L["common"]]] = ...
|
|
containspattern: Final[tuple[re.Pattern[str], L["contains"]]] = ...
|
|
datapattern: Final[tuple[re.Pattern[str], L["data"]]] = ...
|
|
dimensionpattern: Final[tuple[re.Pattern[str], L["dimension"]]] = ...
|
|
endifpattern: Final[tuple[re.Pattern[str], L["endif"]]] = ...
|
|
endpattern: Final[tuple[re.Pattern[str], L["end"]]] = ...
|
|
entrypattern: Final[tuple[re.Pattern[str], L["entry"]]] = ...
|
|
externalpattern: Final[tuple[re.Pattern[str], L["external"]]] = ...
|
|
f2pyenhancementspattern: Final[tuple[re.Pattern[str], L["f2pyenhancements"]]] = ...
|
|
formatpattern: Final[tuple[re.Pattern[str], L["format"]]] = ...
|
|
functionpattern: Final[tuple[re.Pattern[str], L["begin"]]] = ...
|
|
implicitpattern: Final[tuple[re.Pattern[str], L["implicit"]]] = ...
|
|
intentpattern: Final[tuple[re.Pattern[str], L["intent"]]] = ...
|
|
intrinsicpattern: Final[tuple[re.Pattern[str], L["intrinsic"]]] = ...
|
|
optionalpattern: Final[tuple[re.Pattern[str], L["optional"]]] = ...
|
|
moduleprocedurepattern: Final[tuple[re.Pattern[str], L["moduleprocedure"]]] = ...
|
|
multilinepattern: Final[tuple[re.Pattern[str], L["multiline"]]] = ...
|
|
parameterpattern: Final[tuple[re.Pattern[str], L["parameter"]]] = ...
|
|
privatepattern: Final[tuple[re.Pattern[str], L["private"]]] = ...
|
|
publicpattern: Final[tuple[re.Pattern[str], L["public"]]] = ...
|
|
requiredpattern: Final[tuple[re.Pattern[str], L["required"]]] = ...
|
|
subroutinepattern: Final[tuple[re.Pattern[str], L["begin"]]] = ...
|
|
typespattern: Final[tuple[re.Pattern[str], L["type"]]] = ...
|
|
usepattern: Final[tuple[re.Pattern[str], L["use"]]] = ...
|
|
|
|
analyzeargs_re_1: Final[re.Pattern[str]] = ...
|
|
callnameargspattern: Final[re.Pattern[str]] = ...
|
|
charselector: Final[re.Pattern[str]] = ...
|
|
crackline_bind_1: Final[re.Pattern[str]] = ...
|
|
crackline_bindlang: Final[re.Pattern[str]] = ...
|
|
crackline_re_1: Final[re.Pattern[str]] = ...
|
|
determineexprtype_re_1: Final[re.Pattern[str]] = ...
|
|
determineexprtype_re_2: Final[re.Pattern[str]] = ...
|
|
determineexprtype_re_3: Final[re.Pattern[str]] = ...
|
|
determineexprtype_re_4: Final[re.Pattern[str]] = ...
|
|
determineexprtype_re_5: Final[re.Pattern[str]] = ...
|
|
getlincoef_re_1: Final[re.Pattern[str]] = ...
|
|
kindselector: Final[re.Pattern[str]] = ...
|
|
lenarraypattern: Final[re.Pattern[str]] = ...
|
|
lenkindpattern: Final[re.Pattern[str]] = ...
|
|
namepattern: Final[re.Pattern[str]] = ...
|
|
nameargspattern: Final[re.Pattern[str]] = ...
|
|
operatorpattern: Final[re.Pattern[str]] = ...
|
|
real16pattern: Final[re.Pattern[str]] = ...
|
|
real8pattern: Final[re.Pattern[str]] = ...
|
|
selectpattern: Final[re.Pattern[str]] = ...
|
|
typedefpattern: Final[re.Pattern[str]] = ...
|
|
typespattern4implicit: Final[re.Pattern[str]] = ...
|
|
word_pattern: Final[re.Pattern[str]] = ...
|
|
|
|
post_processing_hooks: Final[list[_VisitFunc[...]]] = []
|
|
|
|
#
|
|
def outmess(line: str, flag: int = 1) -> None: ...
|
|
def reset_global_f2py_vars() -> None: ...
|
|
|
|
#
|
|
def rmbadname1(name: str) -> str: ...
|
|
def undo_rmbadname1(name: str) -> str: ...
|
|
def rmbadname(names: Iterable[str]) -> list[str]: ...
|
|
def undo_rmbadname(names: Iterable[str]) -> list[str]: ...
|
|
|
|
#
|
|
def openhook(filename: StrPath, mode: str) -> IO[Any]: ...
|
|
def is_free_format(fname: StrPath) -> bool: ...
|
|
def readfortrancode(
|
|
ffile: StrOrBytesPath | Iterable[StrOrBytesPath],
|
|
dowithline: Callable[[str, int], object] = ...,
|
|
istop: int = 1,
|
|
) -> None: ...
|
|
|
|
#
|
|
def split_by_unquoted(line: str, characters: str) -> tuple[str, str]: ...
|
|
|
|
#
|
|
def crackline(line: str, reset: int = 0) -> None: ...
|
|
def markouterparen(line: str) -> str: ...
|
|
def markoutercomma(line: str, comma: str = ",") -> str: ...
|
|
def unmarkouterparen(line: str) -> str: ...
|
|
def appenddecl(decl: Mapping[str, object] | None, decl2: Mapping[str, object] | None, force: int = 1) -> dict[str, Any]: ...
|
|
|
|
#
|
|
def parse_name_for_bind(line: str) -> tuple[str, str | None]: ...
|
|
def analyzeline(m: re.Match[str], case: str, line: str) -> None: ...
|
|
def appendmultiline(group: dict[str, Any], context_name: str, ml: str) -> None: ...
|
|
def cracktypespec0(typespec: str, ll: str | None) -> tuple[str, str | None, str | None, str | None]: ...
|
|
|
|
#
|
|
def removespaces(expr: str) -> str: ...
|
|
def markinnerspaces(line: str) -> str: ...
|
|
def updatevars(typespec: str, selector: str | None, attrspec: str, entitydecl: str) -> str: ...
|
|
def cracktypespec(typespec: str, selector: str | None) -> tuple[dict[str, str] | None, dict[str, str] | None, str | None]: ...
|
|
|
|
#
|
|
def setattrspec(decl: dict[str, list[str]], attr: str | None, force: int = 0) -> dict[str, list[str]]: ...
|
|
def setkindselector(decl: dict[str, dict[str, str]], sel: dict[str, str], force: int = 0) -> dict[str, dict[str, str]]: ...
|
|
def setcharselector(decl: dict[str, dict[str, str]], sel: dict[str, str], force: int = 0) -> dict[str, dict[str, str]]: ...
|
|
def getblockname(block: Mapping[str, object], unknown: str = "unknown") -> str: ...
|
|
def setmesstext(block: Mapping[str, object]) -> None: ...
|
|
def get_usedict(block: Mapping[str, object]) -> dict[str, str]: ...
|
|
def get_useparameters(block: Mapping[str, object], param_map: Mapping[str, str] | None = None) -> dict[str, str]: ...
|
|
|
|
#
|
|
@overload
|
|
def postcrack2(
|
|
block: dict[str, Any],
|
|
tab: str = "",
|
|
param_map: Mapping[str, str] | None = None,
|
|
) -> dict[str, str | Any]: ...
|
|
@overload
|
|
def postcrack2(
|
|
block: list[dict[str, Any]],
|
|
tab: str = "",
|
|
param_map: Mapping[str, str] | None = None,
|
|
) -> list[dict[str, str | Any]]: ...
|
|
|
|
#
|
|
@overload
|
|
def postcrack(block: dict[str, Any], args: Mapping[str, str] | None = None, tab: str = "") -> dict[str, Any]: ...
|
|
@overload
|
|
def postcrack(block: list[dict[str, str]], args: Mapping[str, str] | None = None, tab: str = "") -> list[dict[str, Any]]: ...
|
|
|
|
#
|
|
def sortvarnames(vars: Mapping[str, object]) -> list[str]: ...
|
|
def analyzecommon(block: Mapping[str, object]) -> dict[str, Any]: ...
|
|
def analyzebody(block: Mapping[str, object], args: Mapping[str, str], tab: str = "") -> list[dict[str, Any]]: ...
|
|
def buildimplicitrules(block: Mapping[str, object]) -> tuple[dict[str, dict[str, str]], dict[str, str]]: ...
|
|
def myeval(e: str, g: object | None = None, l: object | None = None) -> float: ...
|
|
|
|
#
|
|
def getlincoef(e: str, xset: set[str]) -> tuple[float | None, float | None, str | None]: ...
|
|
|
|
#
|
|
def get_sorted_names(vars: Mapping[str, Mapping[str, str]]) -> list[str]: ...
|
|
def get_parameters(vars: Mapping[str, Mapping[str, str]], global_params: dict[str, str] = {}) -> dict[str, str]: ...
|
|
|
|
#
|
|
def analyzevars(block: Mapping[str, Any]) -> dict[str, dict[str, str]]: ...
|
|
|
|
#
|
|
def param_eval(v: str, g_params: dict[str, Any], params: Mapping[str, object], dimspec: str | None = None) -> dict[str, Any]: ...
|
|
def param_parse(d: str, params: Mapping[str, str]) -> str: ...
|
|
def expr2name(a: str, block: Mapping[str, object], args: list[str] = []) -> str: ...
|
|
def analyzeargs(block: Mapping[str, object]) -> dict[str, Any]: ...
|
|
|
|
#
|
|
def determineexprtype(expr: str, vars: Mapping[str, object], rules: dict[str, Any] = {}) -> dict[str, Any]: ...
|
|
def crack2fortrangen(block: Mapping[str, object], tab: str = "\n", as_interface: bool = False) -> str: ...
|
|
def common2fortran(common: Mapping[str, object], tab: str = "") -> str: ...
|
|
def use2fortran(use: Mapping[str, object], tab: str = "") -> str: ...
|
|
def true_intent_list(var: dict[str, list[str]]) -> list[str]: ...
|
|
def vars2fortran(
|
|
block: Mapping[str, Mapping[str, object]],
|
|
vars: Mapping[str, object],
|
|
args: Mapping[str, str],
|
|
tab: str = "",
|
|
as_interface: bool = False,
|
|
) -> str: ...
|
|
|
|
#
|
|
def crackfortran(files: StrOrBytesPath | Iterable[StrOrBytesPath]) -> list[dict[str, Any]]: ...
|
|
def crack2fortran(block: Mapping[str, Any]) -> str: ...
|
|
|
|
#
|
|
def traverse(
|
|
obj: tuple[str | None, _VisitResult],
|
|
visit: _VisitFunc[_Tss],
|
|
parents: list[tuple[str | None, _VisitResult]] = [],
|
|
result: list[Any] | dict[str, Any] | None = None,
|
|
*args: _Tss.args,
|
|
**kwargs: _Tss.kwargs,
|
|
) -> _VisitItem | _VisitResult: ...
|
|
|
|
#
|
|
def character_backward_compatibility_hook(
|
|
item: _VisitItem,
|
|
parents: list[_VisitItem],
|
|
result: object, # ignored
|
|
*args: object, # ignored
|
|
**kwargs: object, # ignored
|
|
) -> _VisitItem | None: ...
|
|
|
|
# namespace pollution
|
|
c: str
|
|
n: str
|