From 1a625e0b541afdf6d3134287ec52dee26d486ce7 Mon Sep 17 00:00:00 2001 From: said Date: Wed, 20 May 2026 23:10:37 +0100 Subject: [PATCH 1/4] codex: add pyi readiness context --- README.md | 11 + docs/pyi_format.md | 44 +++ fortran_parser/cli.py | 3 + fortran_parser/parser.py | 102 ++++- fortran_parser/pyi_context.py | 162 ++++++++ tests/parser/test_pyi_readiness_context.py | 428 +++++++++++++++++++++ x2py/cli.py | 26 +- 7 files changed, 766 insertions(+), 10 deletions(-) create mode 100644 fortran_parser/pyi_context.py create mode 100644 tests/parser/test_pyi_readiness_context.py diff --git a/README.md b/README.md index 059018dc3..63b9f0811 100644 --- a/README.md +++ b/README.md @@ -435,6 +435,17 @@ Expected result: unresolved imported derived-type/kind dependencies, and final `wrappable` boolean. +If readiness is blocked only because the parsed file imports facts from another +source, an edited `.pyi` file can provide the missing wrapper-facing context: + +```bash +python -m x2py solver.f90 --parse --wrap-readiness --readiness-pyi state_mod.pyi +``` + +The `.pyi` context can declare imported derived types with `class` stubs, +literal compile-time constants with `Final[...] = value`, and callback +signatures with `Callable[...]`. + ## Running tests From repository root: diff --git a/docs/pyi_format.md b/docs/pyi_format.md index 1ea220f38..ff8f5e885 100644 --- a/docs/pyi_format.md +++ b/docs/pyi_format.md @@ -389,3 +389,47 @@ example, `def f(a: Int32) -> None: ...` and renaming is applied inside shape expressions such as `Shape('1:n')`. Names outside function and method argument lists, including module variables and class fields, remain significant. + +## Wrap-Readiness Context + +An edited `.pyi` file can also be used as parser-side wrap-readiness context +before semantic IR conversion. This is useful when the parsed Fortran source +imports symbols from files that are not part of the current parse, but the user +knows enough about those symbols to make wrapping safe. + +Use the CLI with one or more context files: + +```bash +python -m x2py solver.f90 --parse --wrap-readiness --readiness-pyi state_mod.pyi +``` + +The readiness context currently consumes three kinds of facts: + +- `class name:` declares an external derived type name. +- `name: Final[Int32] = 8` declares a literal compile-time constant or kind + value. +- `Callable[...]` on a procedure argument declares the callback signature for a + Fortran procedure dummy argument. + +Example: + +```python +from typing import Callable, Final + +rk: Final[Int32] = 8 + +class sim_state: + n: Int32 + values: Float64[Shape('n'), ORDER_F] + +def step( + state: sim_state, + t: Float64, + objective: Callable[[sim_state, Float64], Float64], +) -> tuple[Returns["state", sim_state], Returns["score", Float64]]: ... +``` + +This can clear readiness blockers for a Fortran routine that imports +`sim_state`, uses `real(kind=rk)`, and accepts `objective` as a callback. A +`Final[...]` declaration without a literal value is intentionally not enough +for kind or compile-time value resolution. diff --git a/fortran_parser/cli.py b/fortran_parser/cli.py index 115714b16..c7cd59c74 100644 --- a/fortran_parser/cli.py +++ b/fortran_parser/cli.py @@ -129,6 +129,9 @@ def _format_blocker_item(code: str, item) -> str: if code == "unresolved_kind_fields": providers = ", ".join(item.get("import_modules") or []) or "" return f"{item['type_owner']}:{item['field']} uses kind {item['kind']} from {providers}" + if code == "callback_arguments_requiring_pyi": + iface = f" via {item['interface']}" if item.get("interface") else "" + return f"{item['procedure']}:{item['argument']} needs Callable[...] callback metadata{iface}" return str(item) diff --git a/fortran_parser/parser.py b/fortran_parser/parser.py index b7a869668..13366dc04 100644 --- a/fortran_parser/parser.py +++ b/fortran_parser/parser.py @@ -8,6 +8,7 @@ from .lexer import preprocess_lines from .models import FortranArgument, FortranBlockData, FortranDerivedType, FortranFile, FortranInterface, FortranModule, FortranParseError, FortranProcedureSignature, FortranProgram, FortranProject, FortranSubmodule, FortranUseMapping, FortranVariable +from .pyi_context import PyiReadinessContext, load_pyi_readiness_context from .type_resolver import extract_kind_from_type_spec from .utils import split_csv @@ -482,9 +483,17 @@ def visit_project( self._insert_unique_scope_symbol(project.interfaces, iface.name.lower(), iface, label="project interface scope") return project - def visit_wrap_readiness(self, code: str, filename: str | None = None) -> dict: + def visit_wrap_readiness( + self, + code: str, + filename: str | None = None, + *, + pyi_files: list[str | Path] | tuple[str | Path, ...] | None = None, + pyi_context: PyiReadinessContext | None = None, + ) -> dict: lines = self._preprocessed_lines(code, filename) parsed_file = self.visit_file(code, filename=filename) + readiness_context = pyi_context or load_pyi_readiness_context(pyi_files) modules = parsed_file.modules submodules = parsed_file.submodules programs = parsed_file.programs @@ -525,12 +534,19 @@ def visit_wrap_readiness(self, code: str, filename: str | None = None) -> dict: wrap_target_signatures, types, modules, + pyi_context=readiness_context, ) unresolved_kind_args, unresolved_kind_fields = self._collect_unresolved_kind_diagnostics( wrap_target_signatures, types, modules, module_params, + pyi_context=readiness_context, + ) + callback_args_requiring_pyi = self._collect_callback_argument_diagnostics( + wrap_target_signatures, + interfaces, + pyi_context=readiness_context, ) blockers = self._build_wrap_blockers( signatures=signatures, @@ -540,6 +556,7 @@ def visit_wrap_readiness(self, code: str, filename: str | None = None) -> dict: unresolved_derived_fields=unresolved_derived_fields, unresolved_kind_args=unresolved_kind_args, unresolved_kind_fields=unresolved_kind_fields, + callback_args_requiring_pyi=callback_args_requiring_pyi, ) unit_blockers = self._build_unit_blockers( filename=filename, @@ -551,6 +568,7 @@ def visit_wrap_readiness(self, code: str, filename: str | None = None) -> dict: unresolved_derived_fields=unresolved_derived_fields, unresolved_kind_args=unresolved_kind_args, unresolved_kind_fields=unresolved_kind_fields, + callback_args_requiring_pyi=callback_args_requiring_pyi, ) return { @@ -566,6 +584,8 @@ def visit_wrap_readiness(self, code: str, filename: str | None = None) -> dict: "unresolved_derived_type_fields": unresolved_derived_fields, "unresolved_kind_arguments": unresolved_kind_args, "unresolved_kind_fields": unresolved_kind_fields, + "callback_arguments_requiring_pyi": callback_args_requiring_pyi, + "pyi_context": readiness_context.to_dict(), "wrappability_blockers": blockers, "unit_blockers": unit_blockers, "why_not_wrappable": [b["message"] for b in blockers], @@ -3717,11 +3737,14 @@ def _kind_symbol_is_known( uses: dict[str, list[FortranUseMapping]], local_symbols: set[str], module_params: dict[str, dict[str, str]], + pyi_context: PyiReadinessContext | None = None, ) -> bool: """Check whether a symbolic kind is declared locally or in parsed imports.""" lowered = symbol.lower() if lowered in local_symbols: return True + if pyi_context is not None and pyi_context.has_constant(symbol): + return True if owning_module and lowered in module_params.get(owning_module.lower(), {}): return True if FortranParser._kind_symbol_visible_from_module_params(symbol, uses, module_params): @@ -3735,6 +3758,8 @@ def _collect_unresolved_derived_type_diagnostics( signatures: list[FortranProcedureSignature], types: list[FortranDerivedType], modules: list[FortranModule], + *, + pyi_context: PyiReadinessContext | None = None, ) -> tuple[list[dict], list[dict]]: """Find derived-type references that are not defined in the parsed source.""" defined_types = {dtype.name.lower() for dtype in types} @@ -3744,7 +3769,9 @@ def _collect_unresolved_derived_type_diagnostics( def _missing_type(kind: str | None) -> bool: base_name = FortranParser._derived_type_base_name(kind) - return bool(base_name) and base_name.lower() not in defined_types + return bool(base_name) and base_name.lower() not in defined_types and not ( + pyi_context is not None and pyi_context.has_type(base_name) + ) for sig in signatures: for arg in sig.arguments: @@ -3785,6 +3812,8 @@ def _collect_unresolved_kind_diagnostics( types: list[FortranDerivedType], modules: list[FortranModule], module_params: dict[str, dict[str, str]], + *, + pyi_context: PyiReadinessContext | None = None, ) -> tuple[list[dict], list[dict]]: """Find symbolic intrinsic kind references not declared in parsed source/imports.""" module_uses = {mod.name.lower(): mod.uses for mod in modules} @@ -3802,6 +3831,7 @@ def _append_unresolved_arg(arg: FortranArgument) -> None: uses=sig.uses, local_symbols=local_symbols, module_params=module_params, + pyi_context=pyi_context, ): continue item = { @@ -3816,16 +3846,16 @@ def _append_unresolved_arg(arg: FortranArgument) -> None: unresolved_args.append(item) for arg in sig.arguments: - if arg.base_type != "derived": + if arg.base_type not in {"derived", "procedure"}: _append_unresolved_arg(arg) - if sig.result and sig.result.base_type != "derived": + if sig.result and sig.result.base_type not in {"derived", "procedure"}: _append_unresolved_arg(sig.result) for dtype in types: uses = module_uses.get(dtype.module.lower(), {}) if dtype.module else {} local_symbols: set[str] = set() for field in dtype.fields: - if field.base_type == "derived": + if field.base_type in {"derived", "procedure"}: continue for symbol in sorted(FortranParser._kind_expression_symbols(field.kind)): if FortranParser._kind_symbol_is_known( @@ -3834,6 +3864,7 @@ def _append_unresolved_arg(arg: FortranArgument) -> None: uses=uses, local_symbols=local_symbols, module_params=module_params, + pyi_context=pyi_context, ): continue item = { @@ -3849,6 +3880,43 @@ def _append_unresolved_arg(arg: FortranArgument) -> None: return unresolved_args, unresolved_fields + @staticmethod + def _collect_callback_argument_diagnostics( + signatures: list[FortranProcedureSignature], + interfaces: list[FortranInterface], + *, + pyi_context: PyiReadinessContext | None = None, + ) -> list[dict]: + """Find procedure dummy arguments whose callback signature is not known.""" + parsed_interfaces = { + iface.name.lower() + for iface in interfaces + if iface.name + } + missing_callbacks: list[dict] = [] + + for sig in signatures: + for arg in sig.arguments: + if arg.base_type != "procedure": + continue + if pyi_context is not None and pyi_context.has_callback_argument(sig.name, arg.name): + continue + if arg.kind and arg.kind.lower() in parsed_interfaces: + continue + missing_callbacks.append({ + "procedure": sig.name, + "module": sig.module, + "argument": arg.name, + "interface": arg.kind or None, + "needs": [ + "callable_signature", + "argument_order", + "return_type", + ], + }) + + return missing_callbacks + @staticmethod def _build_wrap_blockers( *, @@ -3859,6 +3927,7 @@ def _build_wrap_blockers( unresolved_derived_fields: list[dict], unresolved_kind_args: list[dict], unresolved_kind_fields: list[dict], + callback_args_requiring_pyi: list[dict], ) -> list[dict]: """Create explicit, user-facing reasons why a source is not wrap-ready.""" blockers: list[dict] = [] @@ -3904,6 +3973,12 @@ def _build_wrap_blockers( "message": "Some derived-type fields use kind symbols missing from the parsed source/imports.", "items": unresolved_kind_fields, }) + if callback_args_requiring_pyi: + blockers.append({ + "code": "callback_arguments_requiring_pyi", + "message": "Some procedure dummy arguments need callback signatures from a .pyi file.", + "items": callback_args_requiring_pyi, + }) return blockers @staticmethod @@ -3918,6 +3993,7 @@ def _build_unit_blockers( unresolved_derived_fields: list[dict], unresolved_kind_args: list[dict], unresolved_kind_fields: list[dict], + callback_args_requiring_pyi: list[dict], ) -> list[dict]: """Build unit-scoped blocker records without per-unit readiness flags. @@ -3971,6 +4047,7 @@ def derived_type_unit_key(module: str | None, type_owner: str | None) -> tuple[s ] derived_items = [item for item in unresolved_derived_args if same_unit(item, sig)] kind_items = [item for item in unresolved_kind_args if same_unit(item, sig)] + callback_items = [item for item in callback_args_requiring_pyi if same_unit(item, sig)] if missing_items: blockers.append({ "code": "unknown_argument_types", @@ -3989,6 +4066,12 @@ def derived_type_unit_key(module: str | None, type_owner: str | None) -> tuple[s "message": "Some procedure arguments use kind symbols missing from the parsed source/imports.", "items": kind_items, }) + if callback_items: + blockers.append({ + "code": "callback_arguments_requiring_pyi", + "message": "Some procedure dummy arguments need callback signatures from a .pyi file.", + "items": callback_items, + }) if not blockers: continue qualified_name = f"{sig.module}.{sig.name}" if sig.module else sig.name @@ -4418,5 +4501,10 @@ def parse_fortran_project(files, *, encoding: str = "utf-8") -> FortranProject: return _DEFAULT_PARSER.visit_project(files, encoding=encoding) -def assess_wrap_readiness(code: str, filename: str | None = None) -> dict: - return _DEFAULT_PARSER.visit_wrap_readiness(code, filename=filename) +def assess_wrap_readiness( + code: str, + filename: str | None = None, + *, + pyi_files: list[str | Path] | tuple[str | Path, ...] | None = None, +) -> dict: + return _DEFAULT_PARSER.visit_wrap_readiness(code, filename=filename, pyi_files=pyi_files) diff --git a/fortran_parser/pyi_context.py b/fortran_parser/pyi_context.py new file mode 100644 index 000000000..14137c0a9 --- /dev/null +++ b/fortran_parser/pyi_context.py @@ -0,0 +1,162 @@ +# -*- coding: utf-8 -*- +"""Read wrapper-facing facts from user-provided `.pyi` files. + +This module is intentionally narrower than the semantic `.pyi` parser. It is +used by wrap-readiness to answer one question: did the user provide enough +interface facts to clear parser-side blockers for imported types, constants, +and callback arguments? +""" + +from __future__ import annotations + +import ast +from dataclasses import dataclass, field +from pathlib import Path + + +@dataclass(frozen=True) +class PyiReadinessFunction: + name: str + arguments: dict[str, str] = field(default_factory=dict) + return_annotation: str | None = None + filename: str | None = None + + +@dataclass +class PyiReadinessContext: + files: list[str] = field(default_factory=list) + types: set[str] = field(default_factory=set) + constants: dict[str, str] = field(default_factory=dict) + functions: dict[str, PyiReadinessFunction] = field(default_factory=dict) + callback_arguments: set[tuple[str, str]] = field(default_factory=set) + + def has_type(self, name: str | None) -> bool: + if not name: + return False + return _canonical_type_name(name) in {item.lower() for item in self.types} + + def has_constant(self, name: str | None) -> bool: + return bool(name) and name.lower() in self.constants + + def has_callback_argument(self, procedure: str | None, argument: str | None) -> bool: + return bool(procedure and argument) and (procedure.lower(), argument.lower()) in self.callback_arguments + + def to_dict(self) -> dict: + return { + "files": list(self.files), + "provided_types": sorted(self.types, key=str.lower), + "provided_constants": dict(sorted(self.constants.items())), + "provided_callbacks": [ + {"procedure": procedure, "argument": argument} + for procedure, argument in sorted(self.callback_arguments) + ], + } + + +def load_pyi_readiness_context(paths: list[str | Path] | tuple[str | Path, ...] | None) -> PyiReadinessContext: + context = PyiReadinessContext() + for raw_path in paths or []: + path = Path(raw_path) + _merge_context(context, parse_pyi_readiness_text(path.read_text(encoding="utf-8"), filename=str(path))) + return context + + +def parse_pyi_readiness_text(source: str, *, filename: str = "") -> PyiReadinessContext: + tree = ast.parse(source, filename=filename) + visitor = _PyiReadinessVisitor(filename) + visitor.visit(tree) + return visitor.context + + +def _merge_context(target: PyiReadinessContext, source: PyiReadinessContext) -> None: + target.files.extend(source.files) + target.types.update(source.types) + target.constants.update(source.constants) + target.functions.update(source.functions) + target.callback_arguments.update(source.callback_arguments) + + +def _canonical_type_name(name: str) -> str: + text = name.strip() + if "(" in text: + text = text.split("(", 1)[0].strip() + return text.lower() + + +def _annotation_text(node: ast.AST | None) -> str | None: + if node is None: + return None + return ast.unparse(node) + + +def _qualified_tail(node: ast.AST) -> str | None: + if isinstance(node, ast.Name): + return node.id + if isinstance(node, ast.Attribute): + return node.attr + return None + + +def _is_subscript_of(node: ast.AST | None, name: str) -> bool: + return ( + isinstance(node, ast.Subscript) + and (_qualified_tail(node.value) or "").lower() == name.lower() + ) + + +def _is_callable_annotation(node: ast.AST | None) -> bool: + return _is_subscript_of(node, "Callable") + + +def _is_final_annotation(node: ast.AST | None) -> bool: + return _is_subscript_of(node, "Final") + + +def _literal_value(node: ast.AST | None) -> str | None: + if node is None: + return None + try: + value = ast.literal_eval(node) + except (ValueError, TypeError): + return None + if isinstance(value, bool): + return ".true." if value else ".false." + if isinstance(value, (int, float, str)): + return str(value) + return None + + +class _PyiReadinessVisitor(ast.NodeVisitor): + def __init__(self, filename: str): + self.filename = filename + self.context = PyiReadinessContext(files=[filename]) + + def visit_ClassDef(self, node: ast.ClassDef) -> None: + self.context.types.add(node.name) + + def visit_AnnAssign(self, node: ast.AnnAssign) -> None: + if not isinstance(node.target, ast.Name): + return + if not _is_final_annotation(node.annotation): + return + value = _literal_value(node.value) + if value is None: + return + self.context.constants[node.target.id.lower()] = value + + def visit_FunctionDef(self, node: ast.FunctionDef) -> None: + arguments: dict[str, str] = {} + for arg in node.args.args: + annotation = _annotation_text(arg.annotation) + if annotation is None: + continue + arguments[arg.arg] = annotation + if _is_callable_annotation(arg.annotation): + self.context.callback_arguments.add((node.name.lower(), arg.arg.lower())) + self.context.functions[node.name.lower()] = PyiReadinessFunction( + name=node.name, + arguments=arguments, + return_annotation=_annotation_text(node.returns), + filename=self.filename, + ) + diff --git a/tests/parser/test_pyi_readiness_context.py b/tests/parser/test_pyi_readiness_context.py new file mode 100644 index 000000000..7e1d59d4c --- /dev/null +++ b/tests/parser/test_pyi_readiness_context.py @@ -0,0 +1,428 @@ +# -*- coding: utf-8 -*- +"""User-provided .pyi facts can clear wrap-readiness blockers.""" + +import json +import subprocess +import sys +from pathlib import Path + +from x2py import assess_wrap_readiness + + +def _write(path: Path, text: str) -> Path: + path.write_text(text.strip() + "\n", encoding="utf-8") + return path + + +def test_pyi_context_resolves_imported_derived_type_argument(tmp_path: Path): + source = """ +module solver_mod + use state_mod, only: sim_state +contains + subroutine step(state) + type(sim_state), intent(inout) :: state + end subroutine step +end module solver_mod +""" + context = _write( + tmp_path / "state_mod.pyi", + """ +class sim_state: + n: Int32 + values: Float64[Shape('n'), ORDER_F] +""", + ) + + before = assess_wrap_readiness(source, filename="solver.f90") + after = assess_wrap_readiness(source, filename="solver.f90", pyi_files=[context]) + + assert before["wrappable"] is False + assert before["wrappability_blockers"][0]["code"] == "unresolved_derived_type_arguments" + assert after["wrappable"] is True + assert after["unresolved_derived_type_arguments"] == [] + assert after["pyi_context"]["provided_types"] == ["sim_state"] + + +def test_pyi_context_resolves_imported_derived_type_result(tmp_path: Path): + source = """ +function current_state() result(state) + use state_mod, only: sim_state + type(sim_state) :: state +end function current_state +""" + context = _write( + tmp_path / "state_mod.pyi", + """ +class sim_state: + id: Int32 +""", + ) + + before = assess_wrap_readiness(source, filename="current_state.f90") + after = assess_wrap_readiness(source, filename="current_state.f90", pyi_files=[context]) + + assert before["unresolved_derived_type_arguments"][0]["argument"] == "state" + assert after["wrappable"] is True + assert after["unresolved_derived_type_arguments"] == [] + + +def test_pyi_context_resolves_missing_derived_type_field(tmp_path: Path): + source = """ +module mesh_mod + use point_mod, only: point + + type :: mesh + type(point) :: origin + end type mesh +contains + subroutine move(m) + type(mesh), intent(inout) :: m + end subroutine move +end module mesh_mod +""" + context = _write( + tmp_path / "point_mod.pyi", + """ +class point: + x: Float64 + y: Float64 +""", + ) + + before = assess_wrap_readiness(source, filename="mesh.f90") + after = assess_wrap_readiness(source, filename="mesh.f90", pyi_files=[context]) + + assert before["wrappability_blockers"][0]["code"] == "unresolved_derived_type_fields" + assert after["wrappable"] is True + assert after["unresolved_derived_type_fields"] == [] + + +def test_pyi_context_final_constant_resolves_imported_kind_argument(tmp_path: Path): + source = """ +subroutine scale(x) + use kinds_mod, only: rk + real(kind=rk), intent(inout) :: x +end subroutine scale +""" + context = _write( + tmp_path / "kinds_mod.pyi", + """ +from typing import Final + +rk: Final[Int32] = 8 +""", + ) + + before = assess_wrap_readiness(source, filename="scale.f90") + after = assess_wrap_readiness(source, filename="scale.f90", pyi_files=[context]) + + assert before["unresolved_kind_arguments"][0]["kind"] == "rk" + assert after["wrappable"] is True + assert after["unresolved_kind_arguments"] == [] + assert after["pyi_context"]["provided_constants"] == {"rk": "8"} + + +def test_pyi_context_final_constant_resolves_imported_kind_field(tmp_path: Path): + source = """ +module state_mod + use kinds_mod, only: rk + + type :: sim_state + real(kind=rk) :: energy + end type sim_state +contains + subroutine update(state) + type(sim_state), intent(inout) :: state + end subroutine update +end module state_mod +""" + context = _write( + tmp_path / "kinds_mod.pyi", + """ +from typing import Final + +rk: Final[Int32] = 8 +""", + ) + + before = assess_wrap_readiness(source, filename="state.f90") + after = assess_wrap_readiness(source, filename="state.f90", pyi_files=[context]) + + assert before["wrappability_blockers"][0]["code"] == "unresolved_kind_fields" + assert after["wrappable"] is True + assert after["unresolved_kind_fields"] == [] + + +def test_pyi_context_requires_literal_final_value_for_kind_resolution(tmp_path: Path): + source = """ +subroutine scale(x) + use kinds_mod, only: rk + real(kind=rk), intent(inout) :: x +end subroutine scale +""" + context = _write( + tmp_path / "kinds_mod.pyi", + """ +from typing import Final + +rk: Final[Int32] +""", + ) + + report = assess_wrap_readiness(source, filename="scale.f90", pyi_files=[context]) + + assert report["wrappable"] is False + assert report["unresolved_kind_arguments"][0]["kind"] == "rk" + assert report["pyi_context"]["provided_constants"] == {} + + +def test_pyi_context_callable_signature_resolves_callback_and_imported_type(tmp_path: Path): + source = """ +module solver_mod + use state_mod, only: sim_state + use callback_mod, only: objective_fn +contains + subroutine step(state, t, objective, score) + type(sim_state), intent(inout) :: state + real(8), intent(in) :: t + procedure(objective_fn) :: objective + real(8), intent(out) :: score + end subroutine step +end module solver_mod +""" + context = _write( + tmp_path / "solver_context.pyi", + """ +from typing import Callable + +class sim_state: + n: Int32 + values: Float64[Shape('n'), ORDER_F] + +def step( + state: sim_state, + t: Float64, + objective: Callable[[sim_state, Float64], Float64], +) -> tuple[Returns["state", sim_state], Returns["score", Float64]]: ... +""", + ) + + before = assess_wrap_readiness(source, filename="solver.f90") + after = assess_wrap_readiness(source, filename="solver.f90", pyi_files=[context]) + + assert before["wrappable"] is False + assert {blocker["code"] for blocker in before["wrappability_blockers"]} == { + "unresolved_derived_type_arguments", + "callback_arguments_requiring_pyi", + } + assert after["wrappable"] is True + assert after["callback_arguments_requiring_pyi"] == [] + assert after["pyi_context"]["provided_callbacks"] == [ + {"procedure": "step", "argument": "objective"} + ] + + +def test_pyi_context_does_not_clear_callback_without_callable_annotation(tmp_path: Path): + source = """ +subroutine apply(f, x, y) + procedure(callback_fn) :: f + real(8), intent(in) :: x + real(8), intent(out) :: y +end subroutine apply +""" + context = _write( + tmp_path / "apply_context.pyi", + """ +def apply(f: Procedure, x: Float64) -> Returns["y", Float64]: ... +""", + ) + + report = assess_wrap_readiness(source, filename="apply.f90", pyi_files=[context]) + + assert report["wrappable"] is False + assert report["callback_arguments_requiring_pyi"][0]["argument"] == "f" + + +def test_pyi_context_combines_multiple_files(tmp_path: Path): + source = """ +module solver_mod + use state_mod, only: sim_state + use kinds_mod, only: rk + use callback_mod, only: objective_fn +contains + subroutine step(state, objective, score) + type(sim_state), intent(inout) :: state + procedure(objective_fn) :: objective + real(kind=rk), intent(out) :: score + end subroutine step +end module solver_mod +""" + types = _write( + tmp_path / "state_mod.pyi", + """ +class sim_state: + value: Float64 +""", + ) + constants = _write( + tmp_path / "kinds_mod.pyi", + """ +from typing import Final + +rk: Final[Int32] = 8 +""", + ) + callbacks = _write( + tmp_path / "callback_mod.pyi", + """ +from typing import Callable + +def step( + state: sim_state, + objective: Callable[[sim_state], Float64], +) -> tuple[Returns["state", sim_state], Returns["score", Float64]]: ... +""", + ) + + report = assess_wrap_readiness(source, filename="solver.f90", pyi_files=[types, constants, callbacks]) + + assert report["wrappable"] is True + assert set(report["pyi_context"]["files"]) == {str(types), str(constants), str(callbacks)} + assert report["pyi_context"]["provided_constants"] == {"rk": "8"} + + +def test_cli_wrap_readiness_uses_pyi_context(tmp_path: Path): + source = _write( + tmp_path / "solver.f90", + """ +module solver_mod + use state_mod, only: sim_state +contains + subroutine step(state) + type(sim_state), intent(inout) :: state + end subroutine step +end module solver_mod +""", + ) + context = _write( + tmp_path / "state_mod.pyi", + """ +class sim_state: + n: Int32 +""", + ) + cmd = [ + sys.executable, + "-m", + "x2py", + str(source), + "--parse", + "--wrap-readiness", + "--readiness-pyi", + str(context), + ] + + res = subprocess.run(cmd, capture_output=True, text=True, check=True) + + assert "Wrappable: yes" in res.stdout + assert "No wrap-readiness blockers detected." in res.stdout + + +def test_cli_parse_json_includes_pyi_context_and_cleared_readiness(tmp_path: Path): + source = _write( + tmp_path / "scale.f90", + """ +subroutine scale(x) + use kinds_mod, only: rk + real(kind=rk), intent(inout) :: x +end subroutine scale +""", + ) + context = _write( + tmp_path / "kinds_mod.pyi", + """ +from typing import Final + +rk: Final[Int32] = 8 +""", + ) + cmd = [ + sys.executable, + "-m", + "x2py", + str(source), + "--parse", + "--json", + "--readiness-pyi", + str(context), + ] + + res = subprocess.run(cmd, capture_output=True, text=True, check=True) + payload = json.loads(res.stdout) + readiness = payload[str(source)]["wrap_readiness"] + + assert readiness["wrappable"] is True + assert readiness["pyi_context"]["provided_constants"] == {"rk": "8"} + + +def test_cli_repeated_readiness_pyi_files_are_combined(tmp_path: Path): + source = _write( + tmp_path / "solver.f90", + """ +module solver_mod + use state_mod, only: sim_state + use callback_mod, only: objective_fn +contains + subroutine step(state, objective) + type(sim_state), intent(inout) :: state + procedure(objective_fn) :: objective + end subroutine step +end module solver_mod +""", + ) + types = _write( + tmp_path / "state_mod.pyi", + """ +class sim_state: + value: Float64 +""", + ) + callbacks = _write( + tmp_path / "callback_mod.pyi", + """ +from typing import Callable + +def step( + state: sim_state, + objective: Callable[[sim_state], None], +) -> Returns["state", sim_state]: ... +""", + ) + cmd = [ + sys.executable, + "-m", + "x2py", + str(source), + "--parse", + "--wrap-readiness", + "--readiness-pyi", + str(types), + "--readiness-pyi", + str(callbacks), + ] + + res = subprocess.run(cmd, capture_output=True, text=True, check=True) + + assert "Wrappable: yes" in res.stdout + + +def test_cli_readiness_pyi_requires_parse_stage(tmp_path: Path): + context = _write(tmp_path / "state_mod.pyi", "class sim_state:\n value: Float64") + source = _write(tmp_path / "solver.f90", "module solver_mod\nend module solver_mod") + cmd = [sys.executable, "-m", "x2py", str(source), "--pyi", "--readiness-pyi", str(context)] + + res = subprocess.run(cmd, capture_output=True, text=True) + + assert res.returncode != 0 + assert "--readiness-pyi requires --parse" in res.stderr + diff --git a/x2py/cli.py b/x2py/cli.py index d3117f967..8b9880909 100644 --- a/x2py/cli.py +++ b/x2py/cli.py @@ -56,7 +56,7 @@ def _expand_paths(paths: list[str]) -> list[Path]: return sorted(set(expanded)) -def _parse_report(paths: list[str]) -> dict[str, dict]: +def _parse_report(paths: list[str], *, readiness_pyi_files: list[str] | None = None) -> dict[str, dict]: out: dict[str, dict] = {} parser = FortranParser() for p in _expand_paths(paths): @@ -69,7 +69,11 @@ def _parse_report(paths: list[str]) -> dict[str, dict]: "submodules": [_to_dict_no_parent(m) for m in parsed.submodules], "programs": [_to_dict_no_parent(m) for m in parsed.programs], "block_data": [_to_dict_no_parent(m) for m in parsed.block_data_units], - "wrap_readiness": parser.visit_wrap_readiness(code, filename=str(p)), + "wrap_readiness": parser.visit_wrap_readiness( + code, + filename=str(p), + pyi_files=readiness_pyi_files, + ), } return out @@ -151,6 +155,8 @@ def main() -> int: " python -m x2py path/to/src_dir --parse --out\n" " Show wrap-readiness only:\n" " python -m x2py path/to/file.f90 --parse --wrap-readiness\n" + " Show wrap-readiness using user-provided .pyi facts:\n" + " python -m x2py path/to/file.f90 --parse --wrap-readiness --readiness-pyi path/to/context.pyi\n" " Print semantic IR JSON:\n" " python -m x2py path/to/file.f90 --semantics\n" " Print generated Python stub text:\n" @@ -190,6 +196,17 @@ def main() -> int: parser.add_argument("--pyi", action="store_true", help="Generate Python .pyi content") parser.add_argument("--json", action="store_true", help="Print JSON to stdout") parser.add_argument("--out", nargs="?", const="", type=str, help="Write stage output to file (optional explicit output filename)") + parser.add_argument( + "--readiness-pyi", + action="append", + default=[], + metavar="PATH", + help=( + "Use an edited .pyi file as wrap-readiness context for imported " + "derived types, literal Final[...] constants, and Callable[...] callbacks. " + "May be repeated." + ), + ) parser.add_argument("--no-color", action="store_true", help="Disable ANSI color in parse diagnostics") parser.add_argument("--debug-traceback", action="store_true", help="Re-raise parser errors for debug") args = parser.parse_args() @@ -200,6 +217,9 @@ def main() -> int: if args.wrap_readiness and not args.parse: parser.error("--wrap-readiness requires --parse") + if args.readiness_pyi and not args.parse: + parser.error("--readiness-pyi requires --parse") + if (args.show_vars or args.print_limit is not None or args.vars_limit is not None) and not args.parse: parser.error("--show-vars/--print-limit require --parse") @@ -220,7 +240,7 @@ def main() -> int: parser.error("JSON output currently supports only the parsing stage. Use --parse with --json/--out.") try: - parse_payload = _parse_report(args.paths) if args.parse else None + parse_payload = _parse_report(args.paths, readiness_pyi_files=args.readiness_pyi) if args.parse else None semantic_payload = _semantic_report(args.paths) if (args.semantics or args.pyi) else None except FortranParseError as exc: if args.debug_traceback or _env_flag("FORTRAN_PARSER_DEBUG"): From 170ab34cebbadaefdd43e8216905ab90c29b6271 Mon Sep 17 00:00:00 2001 From: said Date: Thu, 21 May 2026 01:21:39 +0100 Subject: [PATCH 2/4] codex: move pyi readiness to semantic ir --- README.md | 60 +- docs/pyi_format.md | 39 +- fortran_parser/cli.py | 3 - fortran_parser/parser.py | 102 +--- fortran_parser/pyi_context.py | 162 ------ semantics/__init__.py | 3 + semantics/pyi_parser.py | 36 ++ semantics/pyi_printer.py | 12 + semantics/readiness.py | 539 ++++++++++++++++++ tests/parser/test_cli.py | 46 +- tests/parser/test_pyi_readiness_context.py | 428 -------------- tests/pyi/test_pyi_to_ir.py | 25 + .../semantics/test_semantic_wrap_readiness.py | 172 ++++++ x2py/__init__.py | 3 + x2py/cli.py | 187 ++++-- 15 files changed, 1037 insertions(+), 780 deletions(-) delete mode 100644 fortran_parser/pyi_context.py create mode 100644 semantics/readiness.py delete mode 100644 tests/parser/test_pyi_readiness_context.py create mode 100644 tests/semantics/test_semantic_wrap_readiness.py diff --git a/README.md b/README.md index 63b9f0811..2986738ba 100644 --- a/README.md +++ b/README.md @@ -42,7 +42,7 @@ front-end). Current handled coverage: - **Readiness diagnostics** - Unsupported-pattern detection - Unknown argument declaration reporting - - Final wrappability summary + - Parser-side blocker discovery for early feedback ## Public APIs @@ -50,7 +50,9 @@ Public API: - `parse_fortran_file(source_or_path, filename=None, macro_defines=None, encoding="utf-8") -> FortranFile` - `parse_fortran_project(files, encoding="utf-8") -> FortranProject` -- `assess_wrap_readiness(code, filename=None) -> dict` +- `fortran_file_to_semantic_modules(parsed_file, standalone_module_name=None) -> list[SemanticModule]` +- `assess_semantic_wrap_readiness(semantic_ir, source=None) -> dict` +- `assess_pyi_wrap_readiness(path_or_paths, encoding="utf-8") -> dict` ## Repository layout @@ -61,11 +63,12 @@ The editable wrapper `.pyi` format is documented in ## Terminal usage -`x2py` exposes three stage flags: +`x2py` exposes four stage flags: - `--parse` for parser output and parse-stage diagnostics - `--semantics` for semantic IR JSON - `--pyi` for generated Python stub text +- `--wrap-readiness` for semantic wrap-readiness from either Fortran or `.pyi` For parse output, `--show-vars` expands scope-level variables that are normally summarized as `vars=N`. Use `--print-limit N` to keep large repeated sections @@ -223,17 +226,27 @@ Expected JSON structure (top-level keyed by input path): - `.submodules`: parsed submodules - `.programs`: parsed programs - `.block_data`: parsed block data units -- `.wrap_readiness`: readiness diagnostics ### Example 3: wrap-readiness summary ```bash -python -m x2py tests/data/fortran/general/basic_subroutine.f90 --parse --wrap-readiness +python -m x2py tests/data/fortran/general/basic_subroutine.f90 --wrap-readiness ``` -This prints the wrappability status and blocker list for each input file. -The JSON readiness payload keeps `wrappable` at file level and includes -`unit_blockers` only for procedure/type/file units that own a blocker. +This converts each input to semantic IR, then prints the wrappability status +and blocker list. The same flag accepts edited `.pyi` files: + +```bash +python -m x2py solver.pyi --wrap-readiness +``` + +Use `--json` for the stable readiness payload. It keeps `wrappable` at file +level and includes `unit_blockers` only for units that own a blocker. + +`--wrap-readiness` can also be combined with other stages. For example, +`--semantics --wrap-readiness` emits semantic IR with a `wrap_readiness` payload +attached, and `--parse --wrap-readiness` prints the parse tree followed by the +semantic readiness summary. ### Example 4: semantic IR JSON output @@ -415,36 +428,41 @@ Expected result: ```python from pathlib import Path -from x2py import parse_fortran_file, assess_wrap_readiness +from x2py import ( + assess_semantic_wrap_readiness, + fortran_file_to_semantic_modules, + parse_fortran_file, +) path = Path("tests/data/fortran/general/basic_subroutine.f90") code = path.read_text() parsed = parse_fortran_file(code, filename=str(path)) -report = assess_wrap_readiness(code, filename=str(path)) +modules = fortran_file_to_semantic_modules(parsed, standalone_module_name=path.stem) +report = assess_semantic_wrap_readiness(modules, source=str(path)) print("procedures:", len(parsed.procedures)) print("wrappable:", report["wrappable"]) -print("unknown args:", report["unknown_argument_types"]) +print("blockers:", report["why_not_wrappable"]) ``` Expected result: - `parsed` is a `FortranFile` aggregate with procedures/modules/types/interfaces/program units. -- `report` includes counts, unsupported construct hits, unknown argument info, - unresolved imported derived-type/kind dependencies, and final `wrappable` - boolean. +- `report` is produced from semantic IR and includes public API counts, + semantic blockers, unit-level blockers, and final `wrappable` boolean. -If readiness is blocked only because the parsed file imports facts from another -source, an edited `.pyi` file can provide the missing wrapper-facing context: +If the parsed Fortran file cannot describe the wrapper interface completely, +generate a draft `.pyi`, edit it, then assess readiness from the edited stub: ```bash -python -m x2py solver.f90 --parse --wrap-readiness --readiness-pyi state_mod.pyi +python -m x2py solver.f90 --pyi --out solver.pyi +python -m x2py solver.pyi --wrap-readiness ``` -The `.pyi` context can declare imported derived types with `class` stubs, -literal compile-time constants with `Final[...] = value`, and callback -signatures with `Callable[...]`. +The edited `.pyi` is the source of truth for readiness. It can declare derived +types with `class` stubs, literal compile-time constants with +`Final[...] = value`, and callback signatures with `Callable[[...], ...]`. ## Running tests @@ -496,7 +514,7 @@ The parser exposes stable file/project entrypoints: - `parse_fortran_file(...)` for one source (string or path) returning `FortranFile`. - `parse_fortran_project(...)` for many sources returning `FortranProject`. -- `assess_wrap_readiness(...)` for wrappability diagnostics. +- `assess_semantic_wrap_readiness(...)` for wrappability diagnostics over semantic IR. Internally, `FortranParser.visit_file` uses a recursive grammar-style source-unit parser. The file is first sliced into direct diff --git a/docs/pyi_format.md b/docs/pyi_format.md index ff8f5e885..2dddf710d 100644 --- a/docs/pyi_format.md +++ b/docs/pyi_format.md @@ -390,26 +390,33 @@ renaming is applied inside shape expressions such as `Shape('1:n')`. Names outside function and method argument lists, including module variables and class fields, remain significant. -## Wrap-Readiness Context +## Semantic Wrap-Readiness -An edited `.pyi` file can also be used as parser-side wrap-readiness context -before semantic IR conversion. This is useful when the parsed Fortran source -imports symbols from files that are not part of the current parse, but the user -knows enough about those symbols to make wrapping safe. - -Use the CLI with one or more context files: +Readiness is assessed from semantic IR, not from parser internals. The same CLI +flag works for either source path: ```bash -python -m x2py solver.f90 --parse --wrap-readiness --readiness-pyi state_mod.pyi +python -m x2py solver.f90 --wrap-readiness +python -m x2py solver.pyi --wrap-readiness ``` -The readiness context currently consumes three kinds of facts: +For Fortran input, x2py parses the source, converts it to semantic IR, then +checks that semantic interface. For `.pyi` input, x2py parses the edited stub +directly to semantic IR and checks that interface. The edited `.pyi` is the +source of truth when the user needs to provide information the source parser +cannot infer. + +The flag can be requested alone for a concise readiness report or combined with +other stages. For example, `--semantics --wrap-readiness` emits semantic IR with +the readiness payload attached. + +The readiness check currently consumes these `.pyi` facts: -- `class name:` declares an external derived type name. -- `name: Final[Int32] = 8` declares a literal compile-time constant or kind - value. -- `Callable[...]` on a procedure argument declares the callback signature for a - Fortran procedure dummy argument. +- `class name:` declares a wrapper-visible derived type or handle. +- `name: Final[Int32] = 8` declares a literal compile-time constant value that + can satisfy shape and size metadata. +- `Callable[[ArgType, ...], ReturnType]` declares the full callback signature + for a procedure/function-pointer argument. Example: @@ -432,4 +439,6 @@ def step( This can clear readiness blockers for a Fortran routine that imports `sim_state`, uses `real(kind=rk)`, and accepts `objective` as a callback. A `Final[...]` declaration without a literal value is intentionally not enough -for kind or compile-time value resolution. +for compile-time shape or size resolution, and `Callable[..., ReturnType]` is +not enough for callbacks because the wrapper still needs argument order and +argument types. diff --git a/fortran_parser/cli.py b/fortran_parser/cli.py index c7cd59c74..115714b16 100644 --- a/fortran_parser/cli.py +++ b/fortran_parser/cli.py @@ -129,9 +129,6 @@ def _format_blocker_item(code: str, item) -> str: if code == "unresolved_kind_fields": providers = ", ".join(item.get("import_modules") or []) or "" return f"{item['type_owner']}:{item['field']} uses kind {item['kind']} from {providers}" - if code == "callback_arguments_requiring_pyi": - iface = f" via {item['interface']}" if item.get("interface") else "" - return f"{item['procedure']}:{item['argument']} needs Callable[...] callback metadata{iface}" return str(item) diff --git a/fortran_parser/parser.py b/fortran_parser/parser.py index 13366dc04..b7a869668 100644 --- a/fortran_parser/parser.py +++ b/fortran_parser/parser.py @@ -8,7 +8,6 @@ from .lexer import preprocess_lines from .models import FortranArgument, FortranBlockData, FortranDerivedType, FortranFile, FortranInterface, FortranModule, FortranParseError, FortranProcedureSignature, FortranProgram, FortranProject, FortranSubmodule, FortranUseMapping, FortranVariable -from .pyi_context import PyiReadinessContext, load_pyi_readiness_context from .type_resolver import extract_kind_from_type_spec from .utils import split_csv @@ -483,17 +482,9 @@ def visit_project( self._insert_unique_scope_symbol(project.interfaces, iface.name.lower(), iface, label="project interface scope") return project - def visit_wrap_readiness( - self, - code: str, - filename: str | None = None, - *, - pyi_files: list[str | Path] | tuple[str | Path, ...] | None = None, - pyi_context: PyiReadinessContext | None = None, - ) -> dict: + def visit_wrap_readiness(self, code: str, filename: str | None = None) -> dict: lines = self._preprocessed_lines(code, filename) parsed_file = self.visit_file(code, filename=filename) - readiness_context = pyi_context or load_pyi_readiness_context(pyi_files) modules = parsed_file.modules submodules = parsed_file.submodules programs = parsed_file.programs @@ -534,19 +525,12 @@ def visit_wrap_readiness( wrap_target_signatures, types, modules, - pyi_context=readiness_context, ) unresolved_kind_args, unresolved_kind_fields = self._collect_unresolved_kind_diagnostics( wrap_target_signatures, types, modules, module_params, - pyi_context=readiness_context, - ) - callback_args_requiring_pyi = self._collect_callback_argument_diagnostics( - wrap_target_signatures, - interfaces, - pyi_context=readiness_context, ) blockers = self._build_wrap_blockers( signatures=signatures, @@ -556,7 +540,6 @@ def visit_wrap_readiness( unresolved_derived_fields=unresolved_derived_fields, unresolved_kind_args=unresolved_kind_args, unresolved_kind_fields=unresolved_kind_fields, - callback_args_requiring_pyi=callback_args_requiring_pyi, ) unit_blockers = self._build_unit_blockers( filename=filename, @@ -568,7 +551,6 @@ def visit_wrap_readiness( unresolved_derived_fields=unresolved_derived_fields, unresolved_kind_args=unresolved_kind_args, unresolved_kind_fields=unresolved_kind_fields, - callback_args_requiring_pyi=callback_args_requiring_pyi, ) return { @@ -584,8 +566,6 @@ def visit_wrap_readiness( "unresolved_derived_type_fields": unresolved_derived_fields, "unresolved_kind_arguments": unresolved_kind_args, "unresolved_kind_fields": unresolved_kind_fields, - "callback_arguments_requiring_pyi": callback_args_requiring_pyi, - "pyi_context": readiness_context.to_dict(), "wrappability_blockers": blockers, "unit_blockers": unit_blockers, "why_not_wrappable": [b["message"] for b in blockers], @@ -3737,14 +3717,11 @@ def _kind_symbol_is_known( uses: dict[str, list[FortranUseMapping]], local_symbols: set[str], module_params: dict[str, dict[str, str]], - pyi_context: PyiReadinessContext | None = None, ) -> bool: """Check whether a symbolic kind is declared locally or in parsed imports.""" lowered = symbol.lower() if lowered in local_symbols: return True - if pyi_context is not None and pyi_context.has_constant(symbol): - return True if owning_module and lowered in module_params.get(owning_module.lower(), {}): return True if FortranParser._kind_symbol_visible_from_module_params(symbol, uses, module_params): @@ -3758,8 +3735,6 @@ def _collect_unresolved_derived_type_diagnostics( signatures: list[FortranProcedureSignature], types: list[FortranDerivedType], modules: list[FortranModule], - *, - pyi_context: PyiReadinessContext | None = None, ) -> tuple[list[dict], list[dict]]: """Find derived-type references that are not defined in the parsed source.""" defined_types = {dtype.name.lower() for dtype in types} @@ -3769,9 +3744,7 @@ def _collect_unresolved_derived_type_diagnostics( def _missing_type(kind: str | None) -> bool: base_name = FortranParser._derived_type_base_name(kind) - return bool(base_name) and base_name.lower() not in defined_types and not ( - pyi_context is not None and pyi_context.has_type(base_name) - ) + return bool(base_name) and base_name.lower() not in defined_types for sig in signatures: for arg in sig.arguments: @@ -3812,8 +3785,6 @@ def _collect_unresolved_kind_diagnostics( types: list[FortranDerivedType], modules: list[FortranModule], module_params: dict[str, dict[str, str]], - *, - pyi_context: PyiReadinessContext | None = None, ) -> tuple[list[dict], list[dict]]: """Find symbolic intrinsic kind references not declared in parsed source/imports.""" module_uses = {mod.name.lower(): mod.uses for mod in modules} @@ -3831,7 +3802,6 @@ def _append_unresolved_arg(arg: FortranArgument) -> None: uses=sig.uses, local_symbols=local_symbols, module_params=module_params, - pyi_context=pyi_context, ): continue item = { @@ -3846,16 +3816,16 @@ def _append_unresolved_arg(arg: FortranArgument) -> None: unresolved_args.append(item) for arg in sig.arguments: - if arg.base_type not in {"derived", "procedure"}: + if arg.base_type != "derived": _append_unresolved_arg(arg) - if sig.result and sig.result.base_type not in {"derived", "procedure"}: + if sig.result and sig.result.base_type != "derived": _append_unresolved_arg(sig.result) for dtype in types: uses = module_uses.get(dtype.module.lower(), {}) if dtype.module else {} local_symbols: set[str] = set() for field in dtype.fields: - if field.base_type in {"derived", "procedure"}: + if field.base_type == "derived": continue for symbol in sorted(FortranParser._kind_expression_symbols(field.kind)): if FortranParser._kind_symbol_is_known( @@ -3864,7 +3834,6 @@ def _append_unresolved_arg(arg: FortranArgument) -> None: uses=uses, local_symbols=local_symbols, module_params=module_params, - pyi_context=pyi_context, ): continue item = { @@ -3880,43 +3849,6 @@ def _append_unresolved_arg(arg: FortranArgument) -> None: return unresolved_args, unresolved_fields - @staticmethod - def _collect_callback_argument_diagnostics( - signatures: list[FortranProcedureSignature], - interfaces: list[FortranInterface], - *, - pyi_context: PyiReadinessContext | None = None, - ) -> list[dict]: - """Find procedure dummy arguments whose callback signature is not known.""" - parsed_interfaces = { - iface.name.lower() - for iface in interfaces - if iface.name - } - missing_callbacks: list[dict] = [] - - for sig in signatures: - for arg in sig.arguments: - if arg.base_type != "procedure": - continue - if pyi_context is not None and pyi_context.has_callback_argument(sig.name, arg.name): - continue - if arg.kind and arg.kind.lower() in parsed_interfaces: - continue - missing_callbacks.append({ - "procedure": sig.name, - "module": sig.module, - "argument": arg.name, - "interface": arg.kind or None, - "needs": [ - "callable_signature", - "argument_order", - "return_type", - ], - }) - - return missing_callbacks - @staticmethod def _build_wrap_blockers( *, @@ -3927,7 +3859,6 @@ def _build_wrap_blockers( unresolved_derived_fields: list[dict], unresolved_kind_args: list[dict], unresolved_kind_fields: list[dict], - callback_args_requiring_pyi: list[dict], ) -> list[dict]: """Create explicit, user-facing reasons why a source is not wrap-ready.""" blockers: list[dict] = [] @@ -3973,12 +3904,6 @@ def _build_wrap_blockers( "message": "Some derived-type fields use kind symbols missing from the parsed source/imports.", "items": unresolved_kind_fields, }) - if callback_args_requiring_pyi: - blockers.append({ - "code": "callback_arguments_requiring_pyi", - "message": "Some procedure dummy arguments need callback signatures from a .pyi file.", - "items": callback_args_requiring_pyi, - }) return blockers @staticmethod @@ -3993,7 +3918,6 @@ def _build_unit_blockers( unresolved_derived_fields: list[dict], unresolved_kind_args: list[dict], unresolved_kind_fields: list[dict], - callback_args_requiring_pyi: list[dict], ) -> list[dict]: """Build unit-scoped blocker records without per-unit readiness flags. @@ -4047,7 +3971,6 @@ def derived_type_unit_key(module: str | None, type_owner: str | None) -> tuple[s ] derived_items = [item for item in unresolved_derived_args if same_unit(item, sig)] kind_items = [item for item in unresolved_kind_args if same_unit(item, sig)] - callback_items = [item for item in callback_args_requiring_pyi if same_unit(item, sig)] if missing_items: blockers.append({ "code": "unknown_argument_types", @@ -4066,12 +3989,6 @@ def derived_type_unit_key(module: str | None, type_owner: str | None) -> tuple[s "message": "Some procedure arguments use kind symbols missing from the parsed source/imports.", "items": kind_items, }) - if callback_items: - blockers.append({ - "code": "callback_arguments_requiring_pyi", - "message": "Some procedure dummy arguments need callback signatures from a .pyi file.", - "items": callback_items, - }) if not blockers: continue qualified_name = f"{sig.module}.{sig.name}" if sig.module else sig.name @@ -4501,10 +4418,5 @@ def parse_fortran_project(files, *, encoding: str = "utf-8") -> FortranProject: return _DEFAULT_PARSER.visit_project(files, encoding=encoding) -def assess_wrap_readiness( - code: str, - filename: str | None = None, - *, - pyi_files: list[str | Path] | tuple[str | Path, ...] | None = None, -) -> dict: - return _DEFAULT_PARSER.visit_wrap_readiness(code, filename=filename, pyi_files=pyi_files) +def assess_wrap_readiness(code: str, filename: str | None = None) -> dict: + return _DEFAULT_PARSER.visit_wrap_readiness(code, filename=filename) diff --git a/fortran_parser/pyi_context.py b/fortran_parser/pyi_context.py deleted file mode 100644 index 14137c0a9..000000000 --- a/fortran_parser/pyi_context.py +++ /dev/null @@ -1,162 +0,0 @@ -# -*- coding: utf-8 -*- -"""Read wrapper-facing facts from user-provided `.pyi` files. - -This module is intentionally narrower than the semantic `.pyi` parser. It is -used by wrap-readiness to answer one question: did the user provide enough -interface facts to clear parser-side blockers for imported types, constants, -and callback arguments? -""" - -from __future__ import annotations - -import ast -from dataclasses import dataclass, field -from pathlib import Path - - -@dataclass(frozen=True) -class PyiReadinessFunction: - name: str - arguments: dict[str, str] = field(default_factory=dict) - return_annotation: str | None = None - filename: str | None = None - - -@dataclass -class PyiReadinessContext: - files: list[str] = field(default_factory=list) - types: set[str] = field(default_factory=set) - constants: dict[str, str] = field(default_factory=dict) - functions: dict[str, PyiReadinessFunction] = field(default_factory=dict) - callback_arguments: set[tuple[str, str]] = field(default_factory=set) - - def has_type(self, name: str | None) -> bool: - if not name: - return False - return _canonical_type_name(name) in {item.lower() for item in self.types} - - def has_constant(self, name: str | None) -> bool: - return bool(name) and name.lower() in self.constants - - def has_callback_argument(self, procedure: str | None, argument: str | None) -> bool: - return bool(procedure and argument) and (procedure.lower(), argument.lower()) in self.callback_arguments - - def to_dict(self) -> dict: - return { - "files": list(self.files), - "provided_types": sorted(self.types, key=str.lower), - "provided_constants": dict(sorted(self.constants.items())), - "provided_callbacks": [ - {"procedure": procedure, "argument": argument} - for procedure, argument in sorted(self.callback_arguments) - ], - } - - -def load_pyi_readiness_context(paths: list[str | Path] | tuple[str | Path, ...] | None) -> PyiReadinessContext: - context = PyiReadinessContext() - for raw_path in paths or []: - path = Path(raw_path) - _merge_context(context, parse_pyi_readiness_text(path.read_text(encoding="utf-8"), filename=str(path))) - return context - - -def parse_pyi_readiness_text(source: str, *, filename: str = "") -> PyiReadinessContext: - tree = ast.parse(source, filename=filename) - visitor = _PyiReadinessVisitor(filename) - visitor.visit(tree) - return visitor.context - - -def _merge_context(target: PyiReadinessContext, source: PyiReadinessContext) -> None: - target.files.extend(source.files) - target.types.update(source.types) - target.constants.update(source.constants) - target.functions.update(source.functions) - target.callback_arguments.update(source.callback_arguments) - - -def _canonical_type_name(name: str) -> str: - text = name.strip() - if "(" in text: - text = text.split("(", 1)[0].strip() - return text.lower() - - -def _annotation_text(node: ast.AST | None) -> str | None: - if node is None: - return None - return ast.unparse(node) - - -def _qualified_tail(node: ast.AST) -> str | None: - if isinstance(node, ast.Name): - return node.id - if isinstance(node, ast.Attribute): - return node.attr - return None - - -def _is_subscript_of(node: ast.AST | None, name: str) -> bool: - return ( - isinstance(node, ast.Subscript) - and (_qualified_tail(node.value) or "").lower() == name.lower() - ) - - -def _is_callable_annotation(node: ast.AST | None) -> bool: - return _is_subscript_of(node, "Callable") - - -def _is_final_annotation(node: ast.AST | None) -> bool: - return _is_subscript_of(node, "Final") - - -def _literal_value(node: ast.AST | None) -> str | None: - if node is None: - return None - try: - value = ast.literal_eval(node) - except (ValueError, TypeError): - return None - if isinstance(value, bool): - return ".true." if value else ".false." - if isinstance(value, (int, float, str)): - return str(value) - return None - - -class _PyiReadinessVisitor(ast.NodeVisitor): - def __init__(self, filename: str): - self.filename = filename - self.context = PyiReadinessContext(files=[filename]) - - def visit_ClassDef(self, node: ast.ClassDef) -> None: - self.context.types.add(node.name) - - def visit_AnnAssign(self, node: ast.AnnAssign) -> None: - if not isinstance(node.target, ast.Name): - return - if not _is_final_annotation(node.annotation): - return - value = _literal_value(node.value) - if value is None: - return - self.context.constants[node.target.id.lower()] = value - - def visit_FunctionDef(self, node: ast.FunctionDef) -> None: - arguments: dict[str, str] = {} - for arg in node.args.args: - annotation = _annotation_text(arg.annotation) - if annotation is None: - continue - arguments[arg.arg] = annotation - if _is_callable_annotation(arg.annotation): - self.context.callback_arguments.add((node.name.lower(), arg.arg.lower())) - self.context.functions[node.name.lower()] = PyiReadinessFunction( - name=node.name, - arguments=arguments, - return_annotation=_annotation_text(node.returns), - filename=self.filename, - ) - diff --git a/semantics/__init__.py b/semantics/__init__.py index a6e4cfc9d..16f9db318 100644 --- a/semantics/__init__.py +++ b/semantics/__init__.py @@ -5,8 +5,11 @@ resolve_semantic_compile_time_values, ) from .pyi_parser import convert_pyi_to_ir, load_pyi_file, parse_pyi_text +from .readiness import assess_pyi_wrap_readiness, assess_semantic_wrap_readiness __all__ = ( + "assess_pyi_wrap_readiness", + "assess_semantic_wrap_readiness", "collect_semantic_compile_time_requirements", "convert_pyi_to_ir", "fortran_file_to_semantic_modules", diff --git a/semantics/pyi_parser.py b/semantics/pyi_parser.py index c44fcad70..d39ddd7c0 100644 --- a/semantics/pyi_parser.py +++ b/semantics/pyi_parser.py @@ -129,6 +129,7 @@ def ann_assign(self, node: ast.AnnAssign, *, default_intent: str) -> SemanticArg intent=default_intent, optional=self.default_marks_optional(node.value), visibility=visibility, + default_value=self.literal_default_value(node.value), ) def decorators(self, nodes: list[ast.expr], *, context: str) -> _Decorators: @@ -268,6 +269,8 @@ def semantic_type(self, node: ast.expr) -> SemanticType: if not any(constraint.name == "Constant" for constraint in semantic_type.constraints): semantic_type.constraints.append(SemanticConstraint("Constant")) return semantic_type + if self.matches_name(node, "Callable") or self.is_subscript_of(node, "Callable"): + return self.callable_type(node) name = self.type_name(node) if name == "Unknown": @@ -299,6 +302,33 @@ def constraint(self, node: ast.expr) -> SemanticConstraint: ) raise ValueError(f"Unsupported semantic type constraint: {ast.unparse(node)!r}") + def callable_type(self, node: ast.expr) -> SemanticType: + if not isinstance(node, ast.Subscript): + return SemanticType(name="Callable", dtype="Callable") + + items = self.subscript_items(node) + if len(items) != 2: + raise ValueError(f"Callable expects argument types and a return type: {ast.unparse(node)!r}") + + raw_args, raw_return = items + if isinstance(raw_args, ast.Constant) and raw_args.value is Ellipsis: + return SemanticType( + name="Callable", + dtype="Callable", + metadata={"arguments": None, "return": self.semantic_type(raw_return)}, + ) + if not isinstance(raw_args, ast.List): + raise ValueError(f"Callable arguments must be a list: {ast.unparse(node)!r}") + + return SemanticType( + name="Callable", + dtype="Callable", + metadata={ + "arguments": [self.semantic_type(item) for item in raw_args.elts], + "return": self.semantic_type(raw_return), + }, + ) + def return_projection(self, node: ast.expr) -> tuple[SemanticType | None, list[SemanticArgument]]: if isinstance(node, ast.Constant) and node.value is None: return None, [] @@ -366,6 +396,12 @@ def annotation_target(node: ast.AST) -> str: def default_marks_optional(node: ast.expr | None) -> bool: return isinstance(node, ast.Constant) and node.value in {Ellipsis, None} + @staticmethod + def literal_default_value(node: ast.expr | None) -> str | None: + if node is None or _PyiAstParser.default_marks_optional(node): + return None + return str(ast.literal_eval(node)) + @staticmethod def qualified_name(node: ast.AST) -> tuple[str, ...] | None: if isinstance(node, ast.Name): diff --git a/semantics/pyi_printer.py b/semantics/pyi_printer.py index 5d0e66fa7..6d9d48cb8 100644 --- a/semantics/pyi_printer.py +++ b/semantics/pyi_printer.py @@ -50,12 +50,24 @@ def emit_constraint(self, constraint: SemanticConstraint) -> str: def emit_semantic_type(self, semantic_type: SemanticType) -> str: if semantic_type.name == "Unknown" or semantic_type.dtype == "Unknown": raise ValueError("Cannot emit .pyi with unresolved semantic type 'Unknown'") + if semantic_type.name == "Callable": + return self._emit_callable_type(semantic_type) text = semantic_type.name annotations = [self.emit_constraint(c) for c in semantic_type.constraints] if annotations: text += "[" + ", ".join(annotations) + "]" return text + def _emit_callable_type(self, semantic_type: SemanticType) -> str: + arguments = semantic_type.metadata.get("arguments") + return_type = semantic_type.metadata.get("return") + if isinstance(arguments, list) and return_type is not None: + args = ", ".join(self.emit_semantic_type(arg) for arg in arguments) + return f"Callable[[{args}], {self.emit_semantic_type(return_type)}]" + if return_type is not None: + return f"Callable[..., {self.emit_semantic_type(return_type)}]" + return "Callable" + def emit_argument(self, arg: SemanticArgument) -> str: name = self._parameter_target(arg.name) return self._emit_typed_name( diff --git a/semantics/readiness.py b/semantics/readiness.py new file mode 100644 index 000000000..8cd3decad --- /dev/null +++ b/semantics/readiness.py @@ -0,0 +1,539 @@ +from __future__ import annotations + +import re +from pathlib import Path +from typing import Iterable + +from .models import ( + SemanticArgument, + SemanticClass, + SemanticFunction, + SemanticImport, + SemanticMethod, + SemanticModule, + SemanticType, +) +from .pyi_parser import load_pyi_file + + +__all__ = ("assess_pyi_wrap_readiness", "assess_semantic_wrap_readiness") + + +_BUILTIN_TYPES = frozenset( + { + "Any", + "Bool", + "Callable", + "Complex64", + "Complex128", + "Float32", + "Float64", + "Int8", + "Int16", + "Int32", + "Int64", + "Matrix", + "None", + "String", + "UInt8", + "UInt16", + "UInt32", + "UInt64", + "Vector", + "void", + } +) +_CALLBACK_PLACEHOLDERS = frozenset({"Procedure", "Callback", "FunctionPointer", "CFunctionPointer"}) +_IDENTIFIER_RE = re.compile(r"\b[A-Za-z_]\w*\b") + + +def assess_pyi_wrap_readiness( + paths: str | Path | Iterable[str | Path], + *, + encoding: str = "utf-8", +) -> dict: + """Load one or more edited .pyi files and assess semantic wrap-readiness.""" + expanded = _expand_pyi_paths(paths) + modules = [load_pyi_file(path, encoding=encoding) for path in expanded] + return assess_semantic_wrap_readiness(modules, source=[str(path) for path in expanded]) + + +def assess_semantic_wrap_readiness( + semantic_ir: SemanticModule | Iterable[SemanticModule], + *, + source: str | list[str] | None = None, +) -> dict: + """Assess whether semantic IR is complete enough to drive wrapping. + + The parser is intentionally not consulted here. Once a user edits a .pyi + interface, this semantic check treats that interface as the source of truth. + """ + modules = list(semantic_ir) if not isinstance(semantic_ir, SemanticModule) else [semantic_ir] + checker = _SemanticReadinessChecker(modules) + return checker.assess(source=source) + + +def _expand_pyi_paths(paths: str | Path | Iterable[str | Path]) -> list[Path]: + raw_paths = [paths] if isinstance(paths, (str, Path)) else list(paths) + expanded: list[Path] = [] + for raw in raw_paths: + path = Path(raw) + if path.is_dir(): + expanded.extend(sorted(item for item in path.rglob("*.pyi") if item.is_file())) + else: + expanded.append(path) + return sorted(set(expanded)) + + +class _SemanticReadinessChecker: + def __init__(self, modules: list[SemanticModule]): + self.modules = modules + self.index = _SemanticTypeIndex(modules) + self._blockers: dict[str, dict] = {} + self._unit_blockers: dict[str, dict] = {} + + def assess(self, *, source: str | list[str] | None) -> dict: + counts = self._public_api_counts() + if counts["n_functions"] + counts["n_classes"] + counts["n_variables"] == 0: + self._add_blocker( + "no_public_api", + "The semantic interface does not declare any public wrapper API.", + {"owner": "", "needs": ["public function, class, or variable"]}, + unit="", + unit_kind="module", + ) + + for module in self.modules: + self._check_module(module) + + blockers = list(self._blockers.values()) + return { + "wrappable": not blockers, + "source": source, + "n_modules": len(self.modules), + **counts, + "wrappability_blockers": blockers, + "unit_blockers": list(self._unit_blockers.values()), + "why_not_wrappable": [blocker["message"] for blocker in blockers], + } + + def _public_api_counts(self) -> dict[str, int]: + n_functions = 0 + n_classes = 0 + n_variables = 0 + + for module in self.modules: + n_functions += sum(1 for func in module.functions if _is_public(func)) + n_variables += sum(1 for var in module.variables if _is_public(var)) + for cls in module.classes: + if not _is_public(cls): + continue + n_classes += 1 + n_functions += sum(1 for method in cls.methods if _is_public(method)) + + return { + "n_functions": n_functions, + "n_classes": n_classes, + "n_variables": n_variables, + } + + def _check_module(self, module: SemanticModule) -> None: + module_constants = _constant_values(module.variables) + module_constant_names = _constant_names(module.variables) + + for var in module.variables: + if not _is_public(var): + continue + self._check_argument( + var, + owner=f"{module.name}.{var.name}", + module=module, + known_shape_symbols=set(module_constants), + constant_names=module_constant_names, + unit=f"{module.name}.{var.name}", + unit_kind="variable", + ) + + for cls in module.classes: + if not _is_public(cls): + continue + self._check_class( + cls, + module=module, + module_constants=module_constants, + module_constant_names=module_constant_names, + ) + + for func in module.functions: + if not _is_public(func): + continue + self._check_function( + func, + module=module, + known_shape_symbols=set(module_constants), + constant_names=module_constant_names, + owner=f"{module.name}.{func.name}", + unit=f"{module.name}.{func.name}", + unit_kind="function", + ) + + def _check_class( + self, + cls: SemanticClass, + *, + module: SemanticModule, + module_constants: dict[str, str], + module_constant_names: set[str], + ) -> None: + class_symbols = {field.name for field in cls.fields} + known_shape_symbols = set(module_constants) | class_symbols + constant_names = module_constant_names | _constant_names(cls.fields) + + for field in cls.fields: + self._check_argument( + field, + owner=f"{module.name}.{cls.name}.{field.name}", + module=module, + known_shape_symbols=known_shape_symbols, + constant_names=constant_names, + unit=f"{module.name}.{cls.name}", + unit_kind="class", + ) + + for method in cls.methods: + if not _is_public(method): + continue + self._check_function( + method, + module=module, + known_shape_symbols=known_shape_symbols, + constant_names=constant_names, + owner=f"{module.name}.{cls.name}.{method.name}", + unit=f"{module.name}.{cls.name}.{method.name}", + unit_kind="method", + ) + + def _check_function( + self, + func: SemanticFunction | SemanticMethod, + *, + module: SemanticModule, + known_shape_symbols: set[str], + constant_names: set[str], + owner: str, + unit: str, + unit_kind: str, + ) -> None: + function_symbols = set(known_shape_symbols) | {arg.name for arg in func.arguments} + for arg in func.arguments: + self._check_argument( + arg, + owner=f"{owner}.{arg.name}", + module=module, + known_shape_symbols=function_symbols, + constant_names=constant_names, + unit=unit, + unit_kind=unit_kind, + ) + self._check_type( + func.return_type, + owner=f"{owner}.return", + item="return", + module=module, + known_shape_symbols=function_symbols, + constant_names=constant_names, + unit=unit, + unit_kind=unit_kind, + ) + + def _check_argument( + self, + arg: SemanticArgument, + *, + owner: str, + module: SemanticModule, + known_shape_symbols: set[str], + constant_names: set[str], + unit: str, + unit_kind: str, + ) -> None: + self._check_type( + arg.semantic_type, + owner=owner, + item=arg.name, + module=module, + known_shape_symbols=known_shape_symbols, + constant_names=constant_names, + unit=unit, + unit_kind=unit_kind, + ) + + def _check_type( + self, + semantic_type: SemanticType | None, + *, + owner: str, + item: str, + module: SemanticModule, + known_shape_symbols: set[str], + constant_names: set[str], + unit: str, + unit_kind: str, + ) -> None: + if semantic_type is None: + return + + type_name = semantic_type.name + if type_name in _CALLBACK_PLACEHOLDERS: + self._add_callback_blocker(type_name, owner, item, unit=unit, unit_kind=unit_kind) + return + + if type_name == "Callable": + self._check_callable_type( + semantic_type, + owner=owner, + item=item, + module=module, + known_shape_symbols=known_shape_symbols, + constant_names=constant_names, + unit=unit, + unit_kind=unit_kind, + ) + return + + if not self.index.is_known_type(type_name, module): + self._add_blocker( + "unresolved_semantic_types", + "Some semantic type references are not declared by the .pyi interface or its imports.", + {"owner": owner, "item": item, "type": type_name}, + unit=unit, + unit_kind=unit_kind, + ) + + self._check_shape_symbols( + semantic_type, + owner=owner, + item=item, + known_shape_symbols=known_shape_symbols, + constant_names=constant_names, + unit=unit, + unit_kind=unit_kind, + ) + + def _check_callable_type( + self, + semantic_type: SemanticType, + *, + owner: str, + item: str, + module: SemanticModule, + known_shape_symbols: set[str], + constant_names: set[str], + unit: str, + unit_kind: str, + ) -> None: + arguments = semantic_type.metadata.get("arguments") + return_type = semantic_type.metadata.get("return") + if not isinstance(arguments, list) or return_type is None: + self._add_callback_blocker("Callable", owner, item, unit=unit, unit_kind=unit_kind) + return + + for index, callback_arg in enumerate(arguments): + self._check_type( + callback_arg, + owner=f"{owner}.callback_arg_{index}", + item=f"{item}[{index}]", + module=module, + known_shape_symbols=known_shape_symbols, + constant_names=constant_names, + unit=unit, + unit_kind=unit_kind, + ) + self._check_type( + return_type, + owner=f"{owner}.callback_return", + item=f"{item}.return", + module=module, + known_shape_symbols=known_shape_symbols, + constant_names=constant_names, + unit=unit, + unit_kind=unit_kind, + ) + + def _check_shape_symbols( + self, + semantic_type: SemanticType, + *, + owner: str, + item: str, + known_shape_symbols: set[str], + constant_names: set[str], + unit: str, + unit_kind: str, + ) -> None: + for expression in _shape_expressions(semantic_type): + for symbol in sorted(_shape_symbols(expression)): + if symbol in known_shape_symbols: + continue + if symbol in constant_names: + self._add_blocker( + "missing_compile_time_values", + "Some compile-time constants are declared but do not have literal .pyi values.", + {"owner": owner, "item": item, "symbol": symbol, "expression": expression}, + unit=unit, + unit_kind=unit_kind, + ) + continue + self._add_blocker( + "unresolved_shape_symbols", + "Some shape expressions refer to symbols not supplied by the semantic interface.", + {"owner": owner, "item": item, "symbol": symbol, "expression": expression}, + unit=unit, + unit_kind=unit_kind, + ) + + def _add_callback_blocker( + self, + type_name: str, + owner: str, + item: str, + *, + unit: str, + unit_kind: str, + ) -> None: + self._add_blocker( + "callback_signature_incomplete", + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + { + "owner": owner, + "item": item, + "type": type_name, + "needs": [ + "callback argument order", + "callback argument types", + "callback return type", + ], + }, + unit=unit, + unit_kind=unit_kind, + ) + + def _add_blocker( + self, + code: str, + message: str, + item: dict, + *, + unit: str, + unit_kind: str, + ) -> None: + blocker = self._blockers.setdefault(code, {"code": code, "message": message, "items": []}) + blocker["items"].append(item) + + unit_blocker = self._unit_blockers.setdefault( + unit, + {"unit": unit, "kind": unit_kind, "blockers": []}, + ) + for existing in unit_blocker["blockers"]: + if existing["code"] == code: + existing["items"].append(item) + break + else: + unit_blocker["blockers"].append({"code": code, "message": message, "items": [item]}) + + +class _SemanticTypeIndex: + def __init__(self, modules: list[SemanticModule]): + self.known_types = set(_BUILTIN_TYPES) + self.imported_modules_by_module: dict[str, set[str]] = {} + self.import_aliases_by_module: dict[str, set[str]] = {} + + for module in modules: + self.known_types.update(cls.name for cls in module.classes) + self.known_types.update(f"{module.name}.{cls.name}" for cls in module.classes) + imported_modules, import_aliases, imported_types = _import_index(module.imports) + self.imported_modules_by_module[module.name] = imported_modules + self.import_aliases_by_module[module.name] = import_aliases + self.known_types.update(imported_types) + + def is_known_type(self, name: str, module: SemanticModule) -> bool: + if name in self.known_types: + return True + if "." not in name: + return False + module_name = name.rsplit(".", 1)[0] + first_part = name.split(".", 1)[0] + imported_modules = self.imported_modules_by_module.get(module.name, set()) + import_aliases = self.import_aliases_by_module.get(module.name, set()) + return module_name in imported_modules or first_part in import_aliases + + +def _import_index(imports: list[str | SemanticImport]) -> tuple[set[str], set[str], set[str]]: + imported_modules: set[str] = set() + import_aliases: set[str] = set() + imported_types: set[str] = set() + + for imp in imports: + if isinstance(imp, str): + module_name, _, alias = imp.partition(" as ") + imported_modules.add(module_name.strip()) + if alias: + import_aliases.add(alias.strip()) + continue + + imported_modules.add(imp.module) + for item in imp.items: + exported = item.target or item.source + imported_types.add(exported) + imported_types.add(f"{imp.module}.{item.source}") + if item.target: + imported_types.add(f"{imp.module}.{item.target}") + + return imported_modules, import_aliases, imported_types + + +def _constant_values(arguments: list[SemanticArgument]) -> dict[str, str]: + return { + arg.name: str(arg.default_value) + for arg in arguments + if _is_constant(arg.semantic_type) and arg.default_value is not None + } + + +def _constant_names(arguments: list[SemanticArgument]) -> set[str]: + return {arg.name for arg in arguments if _is_constant(arg.semantic_type)} + + +def _is_constant(semantic_type: SemanticType) -> bool: + return any(constraint.name == "Constant" for constraint in semantic_type.constraints) + + +def _shape_expressions(semantic_type: SemanticType) -> list[str]: + expressions = list(semantic_type.shape) + for constraint in semantic_type.constraints: + if constraint.name == "Shape": + expressions.extend(str(value) for value in _iter_expression_values(constraint.arguments)) + return expressions + + +def _iter_expression_values(value) -> Iterable[str]: + if isinstance(value, str): + yield value + elif isinstance(value, dict): + for item in value.values(): + yield from _iter_expression_values(item) + elif isinstance(value, (list, tuple)): + for item in value: + yield from _iter_expression_values(item) + + +def _shape_symbols(expression: str) -> set[str]: + return { + match.group(0) + for match in _IDENTIFIER_RE.finditer(expression) + if not match.group(0).isdigit() + } + + +def _is_public(node) -> bool: + return getattr(node, "visibility", "public") != "private" diff --git a/tests/parser/test_cli.py b/tests/parser/test_cli.py index 098c11842..04c5c3d21 100644 --- a/tests/parser/test_cli.py +++ b/tests/parser/test_cli.py @@ -103,14 +103,39 @@ def test_cli_parse_print_limit_limits_procedures(tmp_path: Path): def test_cli_wrap_readiness_output(): - cmd = [sys.executable, "-m", "x2py", str(TEST_FILE), "--parse", "--wrap-readiness"] + cmd = [sys.executable, "-m", "x2py", str(TEST_FILE), "--wrap-readiness"] res = subprocess.run(cmd, capture_output=True, text=True, check=True) assert f"File: {TEST_FILE}" in res.stdout + assert "Source: fortran" in res.stdout assert "Wrappable: yes" in res.stdout - assert "No wrap-readiness blockers detected." in res.stdout + assert "No semantic readiness blockers detected." in res.stdout assert "Modules:" not in res.stdout +def test_cli_wrap_readiness_json_output(): + cmd = [sys.executable, "-m", "x2py", str(TEST_FILE), "--wrap-readiness", "--json"] + res = subprocess.run(cmd, capture_output=True, text=True, check=True) + payload = json.loads(res.stdout) + assert payload[str(TEST_FILE)]["source_kind"] == "fortran" + assert payload[str(TEST_FILE)]["wrap_readiness"]["wrappable"] is True + + +def test_cli_parse_can_include_semantic_wrap_readiness(): + cmd = [sys.executable, "-m", "x2py", str(TEST_FILE), "--parse", "--wrap-readiness"] + res = subprocess.run(cmd, capture_output=True, text=True, check=True) + assert "subroutine add1" in res.stdout + assert "Source: fortran" in res.stdout + assert "Wrappable: yes" in res.stdout + + +def test_cli_semantics_can_include_semantic_wrap_readiness(): + cmd = [sys.executable, "-m", "x2py", str(TEST_FILE), "--semantics", "--wrap-readiness"] + res = subprocess.run(cmd, capture_output=True, text=True, check=True) + payload = json.loads(res.stdout) + assert payload[str(TEST_FILE)]["semantic_modules"] + assert payload[str(TEST_FILE)]["wrap_readiness"]["wrappable"] is True + + def test_cli_json_out(tmp_path: Path): out = tmp_path / "report.json" cmd = [ @@ -305,11 +330,11 @@ def test_cli_semantics_without_json_output(): assert "semantic_modules" in payload[str(TEST_FILE)] -def test_cli_semantics_json_requires_parse(): +def test_cli_semantics_json_output(): cmd = [sys.executable, "-m", "x2py", str(TEST_FILE), "--semantics", "--json"] - res = subprocess.run(cmd, capture_output=True, text=True) - assert res.returncode == 2 - assert "JSON output currently supports only the parsing stage" in res.stderr + res = subprocess.run(cmd, capture_output=True, text=True, check=True) + payload = json.loads(res.stdout) + assert payload[str(TEST_FILE)]["semantic_modules"] def test_cli_pyi_output(): @@ -507,7 +532,9 @@ def test_cli_help_includes_examples(): assert "python -m x2py path/to/file.f90 --parse" in res.stdout assert "python -m x2py path/to/file.f90 --parse --show-vars" in res.stdout assert "python -m x2py path/to/file.f90 --parse --print-limit 50" in res.stdout - assert "python -m x2py path/to/file.f90 --parse --wrap-readiness" in res.stdout + assert "python -m x2py path/to/file.f90 --wrap-readiness" in res.stdout + assert "python -m x2py path/to/file.f90 --semantics --wrap-readiness" in res.stdout + assert "python -m x2py path/to/module.pyi --wrap-readiness" in res.stdout assert "python -m x2py path/to/file.f90 --pyi --out module.pyi" in res.stdout @@ -846,9 +873,6 @@ def print(self, syntax): @pytest.mark.parametrize( ("extra_args", "message"), [ - (["--wrap-readiness"], "--wrap-readiness requires --parse"), - (["--parse", "--wrap-readiness", "--json"], "--wrap-readiness cannot be combined with --json"), - (["--parse", "--wrap-readiness", "--out"], "--wrap-readiness cannot be combined with --out"), ([], "Select at least one stage flag"), ], ) @@ -956,7 +980,7 @@ def test_x2py_main_public_api_modes_from_inline_source(tmp_path: Path, monkeypat assert capsys.readouterr().out == "" assert json.loads(json_out.read_text(encoding="utf-8")).get(str(f90)) is not None - monkeypatch.setattr(sys, "argv", ["x2py", str(f90), "--parse", "--wrap-readiness"]) + monkeypatch.setattr(sys, "argv", ["x2py", str(f90), "--wrap-readiness"]) assert x2py_cli.main() == 0 assert "Wrappable: yes" in capsys.readouterr().out diff --git a/tests/parser/test_pyi_readiness_context.py b/tests/parser/test_pyi_readiness_context.py deleted file mode 100644 index 7e1d59d4c..000000000 --- a/tests/parser/test_pyi_readiness_context.py +++ /dev/null @@ -1,428 +0,0 @@ -# -*- coding: utf-8 -*- -"""User-provided .pyi facts can clear wrap-readiness blockers.""" - -import json -import subprocess -import sys -from pathlib import Path - -from x2py import assess_wrap_readiness - - -def _write(path: Path, text: str) -> Path: - path.write_text(text.strip() + "\n", encoding="utf-8") - return path - - -def test_pyi_context_resolves_imported_derived_type_argument(tmp_path: Path): - source = """ -module solver_mod - use state_mod, only: sim_state -contains - subroutine step(state) - type(sim_state), intent(inout) :: state - end subroutine step -end module solver_mod -""" - context = _write( - tmp_path / "state_mod.pyi", - """ -class sim_state: - n: Int32 - values: Float64[Shape('n'), ORDER_F] -""", - ) - - before = assess_wrap_readiness(source, filename="solver.f90") - after = assess_wrap_readiness(source, filename="solver.f90", pyi_files=[context]) - - assert before["wrappable"] is False - assert before["wrappability_blockers"][0]["code"] == "unresolved_derived_type_arguments" - assert after["wrappable"] is True - assert after["unresolved_derived_type_arguments"] == [] - assert after["pyi_context"]["provided_types"] == ["sim_state"] - - -def test_pyi_context_resolves_imported_derived_type_result(tmp_path: Path): - source = """ -function current_state() result(state) - use state_mod, only: sim_state - type(sim_state) :: state -end function current_state -""" - context = _write( - tmp_path / "state_mod.pyi", - """ -class sim_state: - id: Int32 -""", - ) - - before = assess_wrap_readiness(source, filename="current_state.f90") - after = assess_wrap_readiness(source, filename="current_state.f90", pyi_files=[context]) - - assert before["unresolved_derived_type_arguments"][0]["argument"] == "state" - assert after["wrappable"] is True - assert after["unresolved_derived_type_arguments"] == [] - - -def test_pyi_context_resolves_missing_derived_type_field(tmp_path: Path): - source = """ -module mesh_mod - use point_mod, only: point - - type :: mesh - type(point) :: origin - end type mesh -contains - subroutine move(m) - type(mesh), intent(inout) :: m - end subroutine move -end module mesh_mod -""" - context = _write( - tmp_path / "point_mod.pyi", - """ -class point: - x: Float64 - y: Float64 -""", - ) - - before = assess_wrap_readiness(source, filename="mesh.f90") - after = assess_wrap_readiness(source, filename="mesh.f90", pyi_files=[context]) - - assert before["wrappability_blockers"][0]["code"] == "unresolved_derived_type_fields" - assert after["wrappable"] is True - assert after["unresolved_derived_type_fields"] == [] - - -def test_pyi_context_final_constant_resolves_imported_kind_argument(tmp_path: Path): - source = """ -subroutine scale(x) - use kinds_mod, only: rk - real(kind=rk), intent(inout) :: x -end subroutine scale -""" - context = _write( - tmp_path / "kinds_mod.pyi", - """ -from typing import Final - -rk: Final[Int32] = 8 -""", - ) - - before = assess_wrap_readiness(source, filename="scale.f90") - after = assess_wrap_readiness(source, filename="scale.f90", pyi_files=[context]) - - assert before["unresolved_kind_arguments"][0]["kind"] == "rk" - assert after["wrappable"] is True - assert after["unresolved_kind_arguments"] == [] - assert after["pyi_context"]["provided_constants"] == {"rk": "8"} - - -def test_pyi_context_final_constant_resolves_imported_kind_field(tmp_path: Path): - source = """ -module state_mod - use kinds_mod, only: rk - - type :: sim_state - real(kind=rk) :: energy - end type sim_state -contains - subroutine update(state) - type(sim_state), intent(inout) :: state - end subroutine update -end module state_mod -""" - context = _write( - tmp_path / "kinds_mod.pyi", - """ -from typing import Final - -rk: Final[Int32] = 8 -""", - ) - - before = assess_wrap_readiness(source, filename="state.f90") - after = assess_wrap_readiness(source, filename="state.f90", pyi_files=[context]) - - assert before["wrappability_blockers"][0]["code"] == "unresolved_kind_fields" - assert after["wrappable"] is True - assert after["unresolved_kind_fields"] == [] - - -def test_pyi_context_requires_literal_final_value_for_kind_resolution(tmp_path: Path): - source = """ -subroutine scale(x) - use kinds_mod, only: rk - real(kind=rk), intent(inout) :: x -end subroutine scale -""" - context = _write( - tmp_path / "kinds_mod.pyi", - """ -from typing import Final - -rk: Final[Int32] -""", - ) - - report = assess_wrap_readiness(source, filename="scale.f90", pyi_files=[context]) - - assert report["wrappable"] is False - assert report["unresolved_kind_arguments"][0]["kind"] == "rk" - assert report["pyi_context"]["provided_constants"] == {} - - -def test_pyi_context_callable_signature_resolves_callback_and_imported_type(tmp_path: Path): - source = """ -module solver_mod - use state_mod, only: sim_state - use callback_mod, only: objective_fn -contains - subroutine step(state, t, objective, score) - type(sim_state), intent(inout) :: state - real(8), intent(in) :: t - procedure(objective_fn) :: objective - real(8), intent(out) :: score - end subroutine step -end module solver_mod -""" - context = _write( - tmp_path / "solver_context.pyi", - """ -from typing import Callable - -class sim_state: - n: Int32 - values: Float64[Shape('n'), ORDER_F] - -def step( - state: sim_state, - t: Float64, - objective: Callable[[sim_state, Float64], Float64], -) -> tuple[Returns["state", sim_state], Returns["score", Float64]]: ... -""", - ) - - before = assess_wrap_readiness(source, filename="solver.f90") - after = assess_wrap_readiness(source, filename="solver.f90", pyi_files=[context]) - - assert before["wrappable"] is False - assert {blocker["code"] for blocker in before["wrappability_blockers"]} == { - "unresolved_derived_type_arguments", - "callback_arguments_requiring_pyi", - } - assert after["wrappable"] is True - assert after["callback_arguments_requiring_pyi"] == [] - assert after["pyi_context"]["provided_callbacks"] == [ - {"procedure": "step", "argument": "objective"} - ] - - -def test_pyi_context_does_not_clear_callback_without_callable_annotation(tmp_path: Path): - source = """ -subroutine apply(f, x, y) - procedure(callback_fn) :: f - real(8), intent(in) :: x - real(8), intent(out) :: y -end subroutine apply -""" - context = _write( - tmp_path / "apply_context.pyi", - """ -def apply(f: Procedure, x: Float64) -> Returns["y", Float64]: ... -""", - ) - - report = assess_wrap_readiness(source, filename="apply.f90", pyi_files=[context]) - - assert report["wrappable"] is False - assert report["callback_arguments_requiring_pyi"][0]["argument"] == "f" - - -def test_pyi_context_combines_multiple_files(tmp_path: Path): - source = """ -module solver_mod - use state_mod, only: sim_state - use kinds_mod, only: rk - use callback_mod, only: objective_fn -contains - subroutine step(state, objective, score) - type(sim_state), intent(inout) :: state - procedure(objective_fn) :: objective - real(kind=rk), intent(out) :: score - end subroutine step -end module solver_mod -""" - types = _write( - tmp_path / "state_mod.pyi", - """ -class sim_state: - value: Float64 -""", - ) - constants = _write( - tmp_path / "kinds_mod.pyi", - """ -from typing import Final - -rk: Final[Int32] = 8 -""", - ) - callbacks = _write( - tmp_path / "callback_mod.pyi", - """ -from typing import Callable - -def step( - state: sim_state, - objective: Callable[[sim_state], Float64], -) -> tuple[Returns["state", sim_state], Returns["score", Float64]]: ... -""", - ) - - report = assess_wrap_readiness(source, filename="solver.f90", pyi_files=[types, constants, callbacks]) - - assert report["wrappable"] is True - assert set(report["pyi_context"]["files"]) == {str(types), str(constants), str(callbacks)} - assert report["pyi_context"]["provided_constants"] == {"rk": "8"} - - -def test_cli_wrap_readiness_uses_pyi_context(tmp_path: Path): - source = _write( - tmp_path / "solver.f90", - """ -module solver_mod - use state_mod, only: sim_state -contains - subroutine step(state) - type(sim_state), intent(inout) :: state - end subroutine step -end module solver_mod -""", - ) - context = _write( - tmp_path / "state_mod.pyi", - """ -class sim_state: - n: Int32 -""", - ) - cmd = [ - sys.executable, - "-m", - "x2py", - str(source), - "--parse", - "--wrap-readiness", - "--readiness-pyi", - str(context), - ] - - res = subprocess.run(cmd, capture_output=True, text=True, check=True) - - assert "Wrappable: yes" in res.stdout - assert "No wrap-readiness blockers detected." in res.stdout - - -def test_cli_parse_json_includes_pyi_context_and_cleared_readiness(tmp_path: Path): - source = _write( - tmp_path / "scale.f90", - """ -subroutine scale(x) - use kinds_mod, only: rk - real(kind=rk), intent(inout) :: x -end subroutine scale -""", - ) - context = _write( - tmp_path / "kinds_mod.pyi", - """ -from typing import Final - -rk: Final[Int32] = 8 -""", - ) - cmd = [ - sys.executable, - "-m", - "x2py", - str(source), - "--parse", - "--json", - "--readiness-pyi", - str(context), - ] - - res = subprocess.run(cmd, capture_output=True, text=True, check=True) - payload = json.loads(res.stdout) - readiness = payload[str(source)]["wrap_readiness"] - - assert readiness["wrappable"] is True - assert readiness["pyi_context"]["provided_constants"] == {"rk": "8"} - - -def test_cli_repeated_readiness_pyi_files_are_combined(tmp_path: Path): - source = _write( - tmp_path / "solver.f90", - """ -module solver_mod - use state_mod, only: sim_state - use callback_mod, only: objective_fn -contains - subroutine step(state, objective) - type(sim_state), intent(inout) :: state - procedure(objective_fn) :: objective - end subroutine step -end module solver_mod -""", - ) - types = _write( - tmp_path / "state_mod.pyi", - """ -class sim_state: - value: Float64 -""", - ) - callbacks = _write( - tmp_path / "callback_mod.pyi", - """ -from typing import Callable - -def step( - state: sim_state, - objective: Callable[[sim_state], None], -) -> Returns["state", sim_state]: ... -""", - ) - cmd = [ - sys.executable, - "-m", - "x2py", - str(source), - "--parse", - "--wrap-readiness", - "--readiness-pyi", - str(types), - "--readiness-pyi", - str(callbacks), - ] - - res = subprocess.run(cmd, capture_output=True, text=True, check=True) - - assert "Wrappable: yes" in res.stdout - - -def test_cli_readiness_pyi_requires_parse_stage(tmp_path: Path): - context = _write(tmp_path / "state_mod.pyi", "class sim_state:\n value: Float64") - source = _write(tmp_path / "solver.f90", "module solver_mod\nend module solver_mod") - cmd = [sys.executable, "-m", "x2py", str(source), "--pyi", "--readiness-pyi", str(context)] - - res = subprocess.run(cmd, capture_output=True, text=True) - - assert res.returncode != 0 - assert "--readiness-pyi requires --parse" in res.stderr - diff --git a/tests/pyi/test_pyi_to_ir.py b/tests/pyi/test_pyi_to_ir.py index 351e65f33..6e4be7d43 100644 --- a/tests/pyi/test_pyi_to_ir.py +++ b/tests/pyi/test_pyi_to_ir.py @@ -69,6 +69,7 @@ class particle: scale: private[Float64] answer: Final[Int32] hidden_answer: private[Final[Int32]] +literal_answer: Final[Int32] = 42 def touch( p: particle @@ -87,9 +88,33 @@ def touch( assert module.variables[2].name == "hidden_answer" assert module.variables[2].visibility == "private" assert [c.name for c in module.variables[2].semantic_type.constraints] == ["Constant"] + assert module.variables[3].name == "literal_answer" + assert module.variables[3].default_value == "42" assert module.functions[0].arguments[0].intent == "inout" +def test_parse_pyi_text_preserves_callable_signature_metadata(): + module = parse_pyi_text( + """ +from typing import Callable + +class sim_state: + n: Int32 + +def integrate( + state: sim_state, + objective: Callable[[sim_state, Float64], Float64] +) -> Float64: ... +""", + module_name="callbacks", + ) + + callback_type = module.functions[0].arguments[1].semantic_type + assert callback_type.name == "Callable" + assert [arg.name for arg in callback_type.metadata["arguments"]] == ["sim_state", "Float64"] + assert callback_type.metadata["return"].name == "Float64" + + def test_parse_pyi_text_accepts_import_aliases(): module = parse_pyi_text( "from list_input import delete_input_list as delete_input\n", diff --git a/tests/semantics/test_semantic_wrap_readiness.py b/tests/semantics/test_semantic_wrap_readiness.py new file mode 100644 index 000000000..221253868 --- /dev/null +++ b/tests/semantics/test_semantic_wrap_readiness.py @@ -0,0 +1,172 @@ +import json +import subprocess +import sys +from pathlib import Path + +from semantics.pyi_parser import parse_pyi_text +from semantics.readiness import assess_semantic_wrap_readiness + + +def _readiness_from_pyi(source: str): + module = parse_pyi_text(source, module_name="solver") + return assess_semantic_wrap_readiness(module, source="solver.pyi") + + +def _blocker_codes(report: dict) -> set[str]: + return {blocker["code"] for blocker in report["wrappability_blockers"]} + + +def test_completed_pyi_interface_is_semantically_ready(): + report = _readiness_from_pyi( + """ +from typing import Callable, Final + +rk: Final[Int32] = 8 +nmax: Final[Int32] = 32 + +class sim_state: + n: Int32 + values: Float64[Shape('n'), ORDER_F] + +def step( + state: sim_state, + t: Float64, + objective: Callable[[sim_state, Float64], Float64], + scratch: Float64[Shape('nmax'), ORDER_F] +) -> tuple[Returns["state", sim_state], Returns["score", Float64]]: ... +""" + ) + + assert report["wrappable"] is True + assert report["wrappability_blockers"] == [] + + +def test_imported_type_can_complete_semantic_readiness(): + report = _readiness_from_pyi( + """ +from state_mod import sim_state + +def step(state: sim_state) -> Returns["state", sim_state]: ... +""" + ) + + assert report["wrappable"] is True + + +def test_missing_semantic_type_blocks_readiness(): + report = _readiness_from_pyi( + """ +def step(state: sim_state) -> Returns["state", sim_state]: ... +""" + ) + + assert report["wrappable"] is False + assert "unresolved_semantic_types" in _blocker_codes(report) + + +def test_shape_argument_makes_shape_symbol_ready(): + report = _readiness_from_pyi( + """ +def fill(n: Int32, x: Float64[Shape('n'), ORDER_F]) -> Returns["x", Float64[Shape('n'), ORDER_F]]: ... +""" + ) + + assert report["wrappable"] is True + + +def test_final_constant_needs_literal_value_for_shape_readiness(): + report = _readiness_from_pyi( + """ +n: Final[Int32] + +def fill(x: Float64[Shape('n'), ORDER_F]) -> Returns["x", Float64[Shape('n'), ORDER_F]]: ... +""" + ) + + assert report["wrappable"] is False + assert "missing_compile_time_values" in _blocker_codes(report) + + +def test_final_constant_literal_value_makes_shape_ready(): + report = _readiness_from_pyi( + """ +n: Final[Int32] = 16 + +def fill(x: Float64[Shape('n'), ORDER_F]) -> Returns["x", Float64[Shape('n'), ORDER_F]]: ... +""" + ) + + assert report["wrappable"] is True + + +def test_callback_placeholder_blocks_until_callable_signature_is_supplied(): + report = _readiness_from_pyi( + """ +def integrate(objective: Procedure, x0: Float64) -> Float64: ... +""" + ) + + assert report["wrappable"] is False + assert "callback_signature_incomplete" in _blocker_codes(report) + blocker = report["wrappability_blockers"][0]["items"][0] + assert blocker["needs"] == [ + "callback argument order", + "callback argument types", + "callback return type", + ] + + +def test_callable_with_signature_makes_callback_ready(): + report = _readiness_from_pyi( + """ +from typing import Callable + +def integrate(objective: Callable[[Float64], Float64], x0: Float64) -> Float64: ... +""" + ) + + assert report["wrappable"] is True + + +def test_callable_without_argument_list_is_not_enough_for_readiness(): + report = _readiness_from_pyi( + """ +from typing import Callable + +def integrate(objective: Callable[..., Float64], x0: Float64) -> Float64: ... +""" + ) + + assert report["wrappable"] is False + assert "callback_signature_incomplete" in _blocker_codes(report) + + +def test_cli_wrap_readiness_loads_completed_pyi(tmp_path: Path): + pyi = tmp_path / "solver.pyi" + pyi.write_text( + """ +n: Final[Int32] = 8 + +def fill(x: Float64[Shape('n'), ORDER_F]) -> Returns["x", Float64[Shape('n'), ORDER_F]]: ... +""", + encoding="utf-8", + ) + + cmd = [sys.executable, "-m", "x2py", str(pyi), "--wrap-readiness"] + res = subprocess.run(cmd, capture_output=True, text=True, check=True) + + assert "Source: pyi" in res.stdout + assert "Wrappable: yes" in res.stdout + assert "No semantic readiness blockers detected." in res.stdout + + +def test_cli_wrap_readiness_json_loads_pyi(tmp_path: Path): + pyi = tmp_path / "solver.pyi" + pyi.write_text("def fill(n: Int32) -> None: ...\n", encoding="utf-8") + + cmd = [sys.executable, "-m", "x2py", str(pyi), "--wrap-readiness", "--json"] + res = subprocess.run(cmd, capture_output=True, text=True, check=True) + payload = json.loads(res.stdout) + + assert payload[str(pyi)]["source_kind"] == "pyi" + assert payload[str(pyi)]["wrap_readiness"]["wrappable"] is True diff --git a/x2py/__init__.py b/x2py/__init__.py index 8627fd51d..4f1b7e73e 100644 --- a/x2py/__init__.py +++ b/x2py/__init__.py @@ -21,6 +21,7 @@ resolve_semantic_compile_time_values, ) from semantics.pyi_parser import convert_pyi_to_ir, load_pyi_file, parse_pyi_text +from semantics.readiness import assess_pyi_wrap_readiness, assess_semantic_wrap_readiness from .cli import main @@ -36,6 +37,8 @@ "FortranProgram", "FortranProject", "FortranSubmodule", + "assess_pyi_wrap_readiness", + "assess_semantic_wrap_readiness", "assess_wrap_readiness", "collect_semantic_compile_time_requirements", "convert_pyi_to_ir", diff --git a/x2py/cli.py b/x2py/cli.py index 8b9880909..f03c6008d 100644 --- a/x2py/cli.py +++ b/x2py/cli.py @@ -9,7 +9,10 @@ from fortran_parser.models import FortranParseError from fortran_parser.parser import FortranParser -from fortran_parser.cli import _format_report, _format_wrap_readiness +from fortran_parser.cli import _format_report +from semantics.fortran2ir import fortran_file_to_semantic_modules +from semantics.pyi_parser import load_pyi_file +from semantics.readiness import assess_semantic_wrap_readiness _TRUE_VALUES = {"1", "true", "yes", "on"} @@ -45,6 +48,14 @@ def _collect_extensions(path: Path) -> list[Path]: return sorted(p for p in path.rglob("*") if p.suffix.lower() in exts) +def _collect_pyi_extensions(path: Path) -> list[Path]: + return sorted(p for p in path.rglob("*.pyi") if p.is_file()) + + +def _collect_readiness_extensions(path: Path) -> list[Path]: + return sorted({*_collect_extensions(path), *_collect_pyi_extensions(path)}) + + def _expand_paths(paths: list[str]) -> list[Path]: expanded: list[Path] = [] for raw in paths: @@ -56,7 +67,18 @@ def _expand_paths(paths: list[str]) -> list[Path]: return sorted(set(expanded)) -def _parse_report(paths: list[str], *, readiness_pyi_files: list[str] | None = None) -> dict[str, dict]: +def _expand_readiness_paths(paths: list[str]) -> list[Path]: + expanded: list[Path] = [] + for raw in paths: + p = Path(raw) + if p.is_dir(): + expanded.extend(_collect_readiness_extensions(p)) + else: + expanded.append(p) + return sorted(set(expanded)) + + +def _parse_report(paths: list[str]) -> dict[str, dict]: out: dict[str, dict] = {} parser = FortranParser() for p in _expand_paths(paths): @@ -69,11 +91,6 @@ def _parse_report(paths: list[str], *, readiness_pyi_files: list[str] | None = N "submodules": [_to_dict_no_parent(m) for m in parsed.submodules], "programs": [_to_dict_no_parent(m) for m in parsed.programs], "block_data": [_to_dict_no_parent(m) for m in parsed.block_data_units], - "wrap_readiness": parser.visit_wrap_readiness( - code, - filename=str(p), - pyi_files=readiness_pyi_files, - ), } return out @@ -103,6 +120,82 @@ def _format_pyi_report(semantic_report: dict[str, dict]) -> str: lines.append("") return "\n".join(lines).rstrip() + +def _wrap_readiness_report(paths: list[str]) -> dict[str, dict]: + out: dict[str, dict] = {} + parser = FortranParser() + for p in _expand_readiness_paths(paths): + if p.suffix.lower() == ".pyi": + modules = [load_pyi_file(p)] + source_kind = "pyi" + else: + code = p.read_text(encoding="utf-8") + parsed = parser.visit_file(code, filename=str(p)) + modules = fortran_file_to_semantic_modules(parsed, standalone_module_name=p.stem) + source_kind = "fortran" + + out[str(p)] = { + "source_kind": source_kind, + "semantic_modules": [asdict(module) for module in modules], + "wrap_readiness": assess_semantic_wrap_readiness(modules, source=str(p)), + } + return out + + +def _attach_wrap_readiness(payload: dict[str, dict] | None, readiness_report: dict[str, dict] | None) -> None: + if not payload or not readiness_report: + return + for fname, report in payload.items(): + readiness = readiness_report.get(fname) + if readiness is None: + continue + report["wrap_readiness"] = readiness["wrap_readiness"] + + +def _format_semantic_blocker_item(code: str, item) -> str: + if code == "unresolved_semantic_types": + return f"{item['owner']} uses unresolved type {item['type']}" + if code == "unresolved_shape_symbols": + return f"{item['owner']} shape {item['expression']!r} uses unresolved symbol {item['symbol']}" + if code == "missing_compile_time_values": + return f"{item['owner']} needs literal value for Final constant {item['symbol']}" + if code == "callback_signature_incomplete": + needs = ", ".join(item.get("needs") or []) + return f"{item['owner']} needs Callable[[...], ...] metadata ({needs})" + if code == "no_public_api": + needs = ", ".join(item.get("needs") or []) + return f"{item['owner']} needs {needs}" + return str(item) + + +def _format_semantic_readiness(readiness_report: dict[str, dict]) -> str: + lines: list[str] = [] + for fname, payload in readiness_report.items(): + readiness = payload.get("wrap_readiness", {}) + module_names = [ + module.get("name", "") + for module in payload.get("semantic_modules", []) + ] + lines.append(f"File: {fname}") + lines.append(f" Source: {payload.get('source_kind', '')}") + lines.append(f" Semantic modules: {', '.join(module_names) or ''}") + lines.append(f" Wrappable: {'yes' if readiness.get('wrappable') else 'no'}") + lines.append(f" Public functions: {readiness.get('n_functions', 0)}") + lines.append(f" Public classes: {readiness.get('n_classes', 0)}") + lines.append(f" Public variables: {readiness.get('n_variables', 0)}") + blockers = readiness.get("wrappability_blockers") or [] + if blockers: + lines.append(" Why not wrappable:") + for blocker in blockers: + lines.append(f" - {blocker.get('code')}: {blocker.get('message')}") + for item in blocker.get("items") or []: + lines.append(f" * {_format_semantic_blocker_item(blocker.get('code', ''), item)}") + else: + lines.append(" No semantic readiness blockers detected.") + lines.append("") + return "\n".join(lines).rstrip() + + def print_pyi_output(code: str) -> None: # Safe fallback for files, pipes, CI, unsupported terminals, etc. if not sys.stdout.isatty(): @@ -154,21 +247,25 @@ def main() -> int: " Write one JSON file next to each source:\n" " python -m x2py path/to/src_dir --parse --out\n" " Show wrap-readiness only:\n" - " python -m x2py path/to/file.f90 --parse --wrap-readiness\n" - " Show wrap-readiness using user-provided .pyi facts:\n" - " python -m x2py path/to/file.f90 --parse --wrap-readiness --readiness-pyi path/to/context.pyi\n" + " python -m x2py path/to/file.f90 --wrap-readiness\n" " Print semantic IR JSON:\n" " python -m x2py path/to/file.f90 --semantics\n" " Print generated Python stub text:\n" " python -m x2py path/to/file.f90 --pyi\n" " Write generated Python stub text:\n" " python -m x2py path/to/file.f90 --pyi --out module.pyi\n" + " Print semantic IR with readiness attached:\n" + " python -m x2py path/to/file.f90 --semantics --wrap-readiness\n" + " Check edited .pyi semantic readiness:\n" + " python -m x2py path/to/module.pyi --wrap-readiness\n" + " Print semantic readiness JSON:\n" + " python -m x2py path/to/module.pyi --wrap-readiness --json\n" "\nOptional:\n" " Install 'rich' for colored terminal syntax highlighting:\n" " pip install rich" ), ) - parser.add_argument("paths", nargs="+", help="Fortran file(s) or directory path(s)") + parser.add_argument("paths", nargs="+", help="Fortran source file(s), .pyi file(s), or directory path(s)") parser.add_argument("--parse", action="store_true", help="Run and output parser stage report") parser.add_argument( "--show-vars", @@ -190,35 +287,18 @@ def main() -> int: parser.add_argument( "--wrap-readiness", action="store_true", - help="Show wrap-readiness status and blockers for parsed files", + help="Convert Fortran or .pyi input to semantic IR and show wrapper readiness", ) parser.add_argument("--semantics", action="store_true", help="Generate semantic IR models from parsed Fortran modules") parser.add_argument("--pyi", action="store_true", help="Generate Python .pyi content") parser.add_argument("--json", action="store_true", help="Print JSON to stdout") parser.add_argument("--out", nargs="?", const="", type=str, help="Write stage output to file (optional explicit output filename)") - parser.add_argument( - "--readiness-pyi", - action="append", - default=[], - metavar="PATH", - help=( - "Use an edited .pyi file as wrap-readiness context for imported " - "derived types, literal Final[...] constants, and Callable[...] callbacks. " - "May be repeated." - ), - ) parser.add_argument("--no-color", action="store_true", help="Disable ANSI color in parse diagnostics") parser.add_argument("--debug-traceback", action="store_true", help="Re-raise parser errors for debug") args = parser.parse_args() - if args.out is not None and not (args.parse or args.semantics or args.pyi): - parser.error("--out requires a stage flag: choose one of --parse, --semantics, or --pyi") - - if args.wrap_readiness and not args.parse: - parser.error("--wrap-readiness requires --parse") - - if args.readiness_pyi and not args.parse: - parser.error("--readiness-pyi requires --parse") + if args.out is not None and not (args.parse or args.semantics or args.pyi or args.wrap_readiness): + parser.error("--out requires a stage flag: choose one of --parse, --semantics, --pyi, or --wrap-readiness") if (args.show_vars or args.print_limit is not None or args.vars_limit is not None) and not args.parse: parser.error("--show-vars/--print-limit require --parse") @@ -227,28 +307,32 @@ def main() -> int: if print_limit is not None and print_limit < 0: parser.error("--print-limit must be >= 0") - if args.wrap_readiness and args.json: - parser.error("--wrap-readiness cannot be combined with --json") - - if args.wrap_readiness and args.out is not None: - parser.error("--wrap-readiness cannot be combined with --out") - - if not (args.parse or args.semantics or args.pyi): - parser.error("Select at least one stage flag: --parse, --semantics, or --pyi") - - if args.json and not args.parse: - parser.error("JSON output currently supports only the parsing stage. Use --parse with --json/--out.") + if not (args.parse or args.semantics or args.pyi or args.wrap_readiness): + parser.error("Select at least one stage flag: --parse, --semantics, --pyi, or --wrap-readiness") try: - parse_payload = _parse_report(args.paths, readiness_pyi_files=args.readiness_pyi) if args.parse else None + parse_payload = _parse_report(args.paths) if args.parse else None semantic_payload = _semantic_report(args.paths) if (args.semantics or args.pyi) else None + readiness_payload = _wrap_readiness_report(args.paths) if args.wrap_readiness else None + _attach_wrap_readiness(parse_payload, readiness_payload) + _attach_wrap_readiness(semantic_payload, readiness_payload) except FortranParseError as exc: if args.debug_traceback or _env_flag("FORTRAN_PARSER_DEBUG"): raise print(exc.format_diagnostic(color=_diagnostic_color_enabled(disabled=args.no_color), debug=False), file=sys.stderr) return 1 + except (SyntaxError, ValueError) as exc: + if args.debug_traceback or _env_flag("X2PY_DEBUG"): + raise + print(f"x2py: error: {exc}", file=sys.stderr) + return 1 - payload = parse_payload or {} if args.parse else semantic_payload or {} + if args.parse: + payload = parse_payload or {} + elif args.semantics or args.pyi: + payload = semantic_payload or {} + else: + payload = readiness_payload or {} if args.out is not None: if args.json and args.pyi: @@ -273,7 +357,20 @@ def main() -> int: return 0 if args.wrap_readiness: - print(_format_wrap_readiness(parse_payload or {})) + if args.parse and not args.json: + print(_format_report(parse_payload or {}, show_vars=args.show_vars or args.vars_limit is not None, print_limit=print_limit)) + print() + print(_format_semantic_readiness(readiness_payload or {})) + elif args.pyi and not args.json: + print_pyi_output(_format_pyi_report(semantic_payload or {})) + print() + print(_format_semantic_readiness(readiness_payload or {})) + elif args.parse or args.semantics or args.pyi: + print(json.dumps(payload, indent=2)) + elif args.json: + print(json.dumps(readiness_payload or {}, indent=2)) + else: + print(_format_semantic_readiness(readiness_payload or {})) elif args.pyi and not args.json: print_pyi_output(_format_pyi_report(semantic_payload or {})) elif args.parse and not (args.semantics or args.json or args.pyi): From 8862a421cd087ccf4a5f13e7e6d9ccde7eb87c6f Mon Sep 17 00:00:00 2001 From: said Date: Thu, 21 May 2026 06:52:58 +0100 Subject: [PATCH 3/4] codex: move readiness fixtures to semantics --- README.md | 26 +- fortran_parser/cli.py | 60 - fortran_parser/parser.py | 554 +- tests/_shared/fixture_outputs.py | 84 +- tests/parser/test_cli.py | 108 +- .../parser/test_parser_public_entrypoints.py | 20 +- .../parser/test_procedure_and_type_parsing.py | 247 +- tests/parser/test_scope_handling.py | 3 +- tests/parser/test_wrap_readiness.py | 167 - .../fixtures/wrap_readiness_messages.json | 30776 ++++++++++++++++ .../generate_wrap_readiness_fixtures.py | 16 + .../semantics/test_semantic_wrap_readiness.py | 73 + .../test_wrap_readiness_fixture_suite.py | 22 + x2py/__init__.py | 3 +- x2py/cli.py | 8 +- 15 files changed, 31007 insertions(+), 1160 deletions(-) delete mode 100644 tests/parser/test_wrap_readiness.py create mode 100644 tests/semantics/fixtures/wrap_readiness_messages.json create mode 100644 tests/semantics/generate_wrap_readiness_fixtures.py create mode 100644 tests/semantics/test_wrap_readiness_fixture_suite.py diff --git a/README.md b/README.md index 2986738ba..9ec45c6b4 100644 --- a/README.md +++ b/README.md @@ -39,10 +39,10 @@ front-end). Current handled coverage: - Attributes (e.g. `abstract`) and `extends(...)` - Field extraction (intrinsic + `type(...)`) - Type-bound procedures and generic bindings -- **Readiness diagnostics** - - Unsupported-pattern detection +- **Parser diagnostics and metadata** + - Source locations for parser errors - Unknown argument declaration reporting - - Parser-side blocker discovery for early feedback + - Parse-stage unsupported construct reporting ## Public APIs @@ -246,7 +246,9 @@ level and includes `unit_blockers` only for units that own a blocker. `--wrap-readiness` can also be combined with other stages. For example, `--semantics --wrap-readiness` emits semantic IR with a `wrap_readiness` payload attached, and `--parse --wrap-readiness` prints the parse tree followed by the -semantic readiness summary. +semantic readiness summary. Parser JSON remains parse-only; when `--json` is +used with `--parse --wrap-readiness`, the output is split into top-level +`parse` and `wrap_readiness` sections. ### Example 4: semantic IR JSON output @@ -508,13 +510,27 @@ short explanation in the PR. For `.pyi` or semantic IR behavior changes, update the corresponding fixtures under `tests/pyi/fixtures` or `tests/semantics/fixtures`. +Semantic wrap-readiness corpus messages for the general, BLAS, LAPACK, and +SciFortran fixtures are regenerated separately: + +```bash +python tests/semantics/generate_wrap_readiness_fixtures.py +``` + +This writes `tests/semantics/fixtures/wrap_readiness_messages.json`. The file is +a semantic readiness fixture, not a parser golden, even though Fortran fixtures +are used as input. + ## Semantic parser structure The parser exposes stable file/project entrypoints: - `parse_fortran_file(...)` for one source (string or path) returning `FortranFile`. - `parse_fortran_project(...)` for many sources returning `FortranProject`. -- `assess_semantic_wrap_readiness(...)` for wrappability diagnostics over semantic IR. + +Wrap-readiness is intentionally outside the parser model. Use +`fortran_file_to_semantic_modules(...)` or `.pyi` parsing to produce semantic IR, +then call `assess_semantic_wrap_readiness(...)` on that semantic interface. Internally, `FortranParser.visit_file` uses a recursive grammar-style source-unit parser. The file is first sliced into direct diff --git a/fortran_parser/cli.py b/fortran_parser/cli.py index 115714b16..d1dc05ae9 100644 --- a/fortran_parser/cli.py +++ b/fortran_parser/cli.py @@ -75,7 +75,6 @@ def _parse_paths(paths: list[str]) -> dict[str, dict]: "submodules": [_to_dict_no_parent(m) for m in parsed.submodules], "programs": [_to_dict_no_parent(m) for m in parsed.programs], "block_data": [_to_dict_no_parent(m) for m in parsed.block_data_units], - "wrap_readiness": parser.visit_wrap_readiness(code, filename=str(p)), } return out @@ -111,50 +110,6 @@ def _format_pyi_report(semantic_report: dict[str, dict]) -> str: lines.append("") return "\n".join(lines).rstrip() -def _format_blocker_item(code: str, item) -> str: - """Format one wrap-readiness blocker item for human-readable output.""" - if code == "unsupported_constructs": - return f"line {item['line']}: {item['text']}" - if code == "unknown_argument_types": - return str(item) - if code == "unresolved_derived_type_arguments": - providers = ", ".join(item.get("import_modules") or []) or "" - return f"{item['procedure']}:{item['argument']} uses type({item['type']}) from {providers}" - if code == "unresolved_derived_type_fields": - providers = ", ".join(item.get("import_modules") or []) or "" - return f"{item['type_owner']}:{item['field']} uses type({item['type']}) from {providers}" - if code == "unresolved_kind_arguments": - providers = ", ".join(item.get("import_modules") or []) or "" - return f"{item['procedure']}:{item['argument']} uses kind {item['kind']} from {providers}" - if code == "unresolved_kind_fields": - providers = ", ".join(item.get("import_modules") or []) or "" - return f"{item['type_owner']}:{item['field']} uses kind {item['kind']} from {providers}" - return str(item) - - -def _format_wrap_readiness(report: dict[str, dict]) -> str: - """Format only wrap-readiness status and blockers for each parsed file.""" - lines: list[str] = [] - for fname, parsed in report.items(): - readiness = parsed["wrap_readiness"] - status = "yes" if readiness["wrappable"] else "no" - lines.append(f"File: {fname}") - lines.append(f" Wrappable: {status}") - blockers = readiness.get("wrappability_blockers", []) - if blockers: - lines.append(" Why not wrappable:") - for blocker in blockers: - lines.append(f" - {blocker['message']}") - for item in blocker.get("items", []): - lines.append(f" * {_format_blocker_item(blocker['code'], item)}") - else: - lines.append(" No wrap-readiness blockers detected.") - lines.append("") - return "\n".join(lines).rstrip() - - - - def _format_var_type(var: dict) -> str: base = var.get("base_type", "unknown") kind = var.get("kind") @@ -294,14 +249,6 @@ def _format_report( if hidden_blocks > 0: lines.append(f" ... {hidden_blocks} more block data units") -# readiness = parsed["wrap_readiness"] -# lines.append(f" Wrappable: {'yes' if readiness['wrappable'] else 'no'}") -# if readiness.get("wrappability_blockers"): -# lines.append(" Why not wrappable:") -# for blocker in readiness["wrappability_blockers"]: -# lines.append(f" - {blocker['message']}") -# for item in blocker.get("items", []): -# lines.append(f" * {_format_blocker_item(blocker['code'], item)}") lines.append("") return "\n".join(lines).rstrip() @@ -319,11 +266,6 @@ def main() -> int: parser.add_argument("--json", action="store_true", help="Print JSON to stdout") parser.add_argument("--semantics", action="store_true", help="Generate semantic IR models from parsed Fortran modules") parser.add_argument("--pyi", action="store_true", help="Print the generated Python .pyi content from semantic models") - parser.add_argument( - "--wrap-readiness", - action="store_true", - help="Print only whether each input is wrap-ready and, when it is not, why.", - ) parser.add_argument( "--show-vars", action="store_true", @@ -379,8 +321,6 @@ def main() -> int: print(json.dumps(payload, indent=2)) elif args.pyi: print(_format_pyi_report(semantic or {})) - elif args.wrap_readiness: - print(_format_wrap_readiness(report)) elif args.semantics: print(json.dumps(payload, indent=2)) else: diff --git a/fortran_parser/parser.py b/fortran_parser/parser.py index b7a869668..d57ae8336 100644 --- a/fortran_parser/parser.py +++ b/fortran_parser/parser.py @@ -23,12 +23,11 @@ 2) Module-level wrappers - Small convenience entrypoints (`parse_fortran_file`, - `parse_fortran_project`, `assess_wrap_readiness`) backed by one default - parser instance. + `parse_fortran_project`) backed by one default parser instance. Recommended reading order for maintainers: - Start from the module-level public wrappers (`parse_fortran_file`, - `parse_fortran_project`, `assess_wrap_readiness`) + `parse_fortran_project`) - Then read `FortranParser.visit_file` / `visit_project` - Then read the high-level unit visitor methods at the top of the class - Then drill into `_helper_*` implementations and low-level helpers @@ -112,16 +111,6 @@ "identifier": re.compile(r"\b[A-Za-z_][A-Za-z0-9_]*\b"), } _ATTR_PREFIX_WORDS = {"pure", "elemental", "recursive", "impure", "module"} -_INTRINSIC_KIND_MODULES = {"iso_c_binding", "iso_fortran_env"} -_KIND_EXPRESSION_INTRINSICS = { - "kind", - "len", - "selected_char_kind", - "selected_int_kind", - "selected_real_kind", -} -_KIND_EXPRESSION_KEYWORDS = {"and", "or", "not", "true", "false"} - _UNSUPPORTED_PATTERN_KEYS = ( "unsupported_class_star", "unsupported_select_type", @@ -482,96 +471,6 @@ def visit_project( self._insert_unique_scope_symbol(project.interfaces, iface.name.lower(), iface, label="project interface scope") return project - def visit_wrap_readiness(self, code: str, filename: str | None = None) -> dict: - lines = self._preprocessed_lines(code, filename) - parsed_file = self.visit_file(code, filename=filename) - modules = parsed_file.modules - submodules = parsed_file.submodules - programs = parsed_file.programs - block_data = parsed_file.block_data_units - interfaces = [ - *parsed_file.interfaces, - *(iface for module in modules for iface in module.interfaces), - *(iface for submodule in submodules for iface in submodule.interfaces), - ] - signatures = [ - *parsed_file.procedures, - *(proc for module in modules for proc in module.procedures), - *(proc for submodule in submodules for proc in submodule.procedures), - *(proc for iface in interfaces for proc in iface.procedures), - ] - types = [ - *parsed_file.derived_types, - *(dtype for module in modules for dtype in module.derived_types), - *(dtype for submodule in submodules for dtype in submodule.derived_types), - ] - wrap_target_signatures = [sig for sig in signatures if not sig.in_interface] - unsupported: list[dict] = [] - for line, lineno, source_line in lines: - for pattern_key in _UNSUPPORTED_PATTERN_KEYS: - p = _REGEX[pattern_key] - if p.search(line): - unsupported.append({"line": lineno, "text": line.strip(), "pattern": p.pattern}) - break - - missing_decl_args: list[str] = [] - for sig in wrap_target_signatures: - for a in sig.arguments: - if a.base_type == "unknown": - missing_decl_args.append(f"{sig.name}:{a.name}") - - module_params = self._collect_module_parameters(code, filename) - unresolved_derived_args, unresolved_derived_fields = self._collect_unresolved_derived_type_diagnostics( - wrap_target_signatures, - types, - modules, - ) - unresolved_kind_args, unresolved_kind_fields = self._collect_unresolved_kind_diagnostics( - wrap_target_signatures, - types, - modules, - module_params, - ) - blockers = self._build_wrap_blockers( - signatures=signatures, - unsupported=unsupported, - missing_decl_args=missing_decl_args, - unresolved_derived_args=unresolved_derived_args, - unresolved_derived_fields=unresolved_derived_fields, - unresolved_kind_args=unresolved_kind_args, - unresolved_kind_fields=unresolved_kind_fields, - ) - unit_blockers = self._build_unit_blockers( - filename=filename, - signatures=wrap_target_signatures, - types=types, - unsupported=unsupported, - missing_decl_args=missing_decl_args, - unresolved_derived_args=unresolved_derived_args, - unresolved_derived_fields=unresolved_derived_fields, - unresolved_kind_args=unresolved_kind_args, - unresolved_kind_fields=unresolved_kind_fields, - ) - - return { - "n_signatures": len(signatures), - "n_types": len(types), - "n_modules": len(modules), - "n_submodules": len(submodules), - "n_programs": len(programs), - "n_block_data": len(block_data), - "unsupported_constructs": unsupported, - "unknown_argument_types": missing_decl_args, - "unresolved_derived_type_arguments": unresolved_derived_args, - "unresolved_derived_type_fields": unresolved_derived_fields, - "unresolved_kind_arguments": unresolved_kind_args, - "unresolved_kind_fields": unresolved_kind_fields, - "wrappability_blockers": blockers, - "unit_blockers": unit_blockers, - "why_not_wrappable": [b["message"] for b in blockers], - "wrappable": not blockers, - } - def visit_fortran_module(self, code: _SourceOrLines, filename: str | None = None) -> FortranModule: _lines, root_scope, all_units = self._helper_prepare_source_units(code, filename) module_units = [unit for unit in all_units if unit.kind == "module"] @@ -3607,7 +3506,7 @@ def _eval(n): return val if isinstance(val, int) else None # ------------------------------------------------------------------ - # Project and wrap-readiness diagnostics + # Project diagnostics # ------------------------------------------------------------------ @staticmethod @@ -3633,449 +3532,6 @@ def _topological_files(file_deps: dict[str, set[str]]) -> list[str]: ordered.extend(sorted(remaining)) return ordered - @staticmethod - def _visible_import_modules(symbol: str, uses: dict[str, list[FortranUseMapping]]) -> list[str]: - """Return imported modules that could provide ``symbol`` under Fortran USE rules.""" - wanted = symbol.lower() - providers: list[str] = [] - for module_name, only_symbols in uses.items(): - normalized_only = [sym.local_name.lower() for sym in only_symbols] - if not normalized_only or wanted in normalized_only: - providers.append(module_name) - return providers - - @staticmethod - def _derived_type_base_name(kind: str | None) -> str: - return (kind or "").split("(", 1)[0].strip() - - @staticmethod - def _kind_expression_symbols(expr: str | None) -> set[str]: - """Return identifier symbols referenced by a kind/len expression.""" - if expr is None: - return set() - text = expr.strip() - if not text or text == "*": - return set() - parts: list[str] = [] - for item in split_csv(text): - token = item.strip() - if not token: - continue - key, sep, value = token.partition("=") - if sep and key.strip().lower() in {"kind", "len"}: - parts.append(value.strip()) - else: - parts.append(token) - normalized = " ".join(parts) - normalized = re.sub( - r"(? bool: - lowered = symbol.lower() - for module_name, mappings in uses.items(): - if module_name.lower() not in _INTRINSIC_KIND_MODULES: - continue - if not mappings or lowered in {mapping.local_name.lower() for mapping in mappings}: - return True - return False - - @staticmethod - def _kind_symbol_visible_from_module_params( - symbol: str, - uses: dict[str, list[FortranUseMapping]], - module_params: dict[str, dict[str, str]], - ) -> bool: - lowered = symbol.lower() - for module_name, mappings in uses.items(): - params = module_params.get(module_name.lower(), {}) - if not params: - continue - if not mappings and lowered in params: - return True - for mapping in mappings: - if mapping.local_name.lower() != lowered: - continue - if mapping.source.lower() in params: - return True - return False - - @staticmethod - def _kind_symbol_is_known( - symbol: str, - *, - owning_module: str | None, - uses: dict[str, list[FortranUseMapping]], - local_symbols: set[str], - module_params: dict[str, dict[str, str]], - ) -> bool: - """Check whether a symbolic kind is declared locally or in parsed imports.""" - lowered = symbol.lower() - if lowered in local_symbols: - return True - if owning_module and lowered in module_params.get(owning_module.lower(), {}): - return True - if FortranParser._kind_symbol_visible_from_module_params(symbol, uses, module_params): - return True - if FortranParser._kind_symbol_visible_from_intrinsic_use(symbol, uses): - return True - return False - - @staticmethod - def _collect_unresolved_derived_type_diagnostics( - signatures: list[FortranProcedureSignature], - types: list[FortranDerivedType], - modules: list[FortranModule], - ) -> tuple[list[dict], list[dict]]: - """Find derived-type references that are not defined in the parsed source.""" - defined_types = {dtype.name.lower() for dtype in types} - module_uses = {mod.name.lower(): mod.uses for mod in modules} - unresolved_args: list[dict] = [] - unresolved_fields: list[dict] = [] - - def _missing_type(kind: str | None) -> bool: - base_name = FortranParser._derived_type_base_name(kind) - return bool(base_name) and base_name.lower() not in defined_types - - for sig in signatures: - for arg in sig.arguments: - if arg.base_type == "derived" and _missing_type(arg.kind): - unresolved_args.append({ - "procedure": sig.name, - "module": sig.module, - "argument": arg.name, - "type": arg.kind, - "import_modules": FortranParser._visible_import_modules(arg.kind or "", sig.uses), - }) - if sig.result and sig.result.base_type == "derived" and _missing_type(sig.result.kind): - unresolved_args.append({ - "procedure": sig.name, - "module": sig.module, - "argument": sig.result.name, - "type": sig.result.kind, - "import_modules": FortranParser._visible_import_modules(sig.result.kind or "", sig.uses), - }) - - for dtype in types: - uses = module_uses.get(dtype.module.lower(), {}) if dtype.module else {} - for field in dtype.fields: - if field.base_type == "derived" and _missing_type(field.kind): - unresolved_fields.append({ - "type_owner": dtype.name, - "module": dtype.module, - "field": field.name, - "type": field.kind, - "import_modules": FortranParser._visible_import_modules(field.kind or "", uses), - }) - - return unresolved_args, unresolved_fields - - @staticmethod - def _collect_unresolved_kind_diagnostics( - signatures: list[FortranProcedureSignature], - types: list[FortranDerivedType], - modules: list[FortranModule], - module_params: dict[str, dict[str, str]], - ) -> tuple[list[dict], list[dict]]: - """Find symbolic intrinsic kind references not declared in parsed source/imports.""" - module_uses = {mod.name.lower(): mod.uses for mod in modules} - unresolved_args: list[dict] = [] - unresolved_fields: list[dict] = [] - - for sig in signatures: - local_symbols = {name.lower() for name, var in sig.variables.items() if var.value is not None} - - def _append_unresolved_arg(arg: FortranArgument) -> None: - for symbol in sorted(FortranParser._kind_expression_symbols(arg.kind)): - if FortranParser._kind_symbol_is_known( - symbol, - owning_module=sig.module, - uses=sig.uses, - local_symbols=local_symbols, - module_params=module_params, - ): - continue - item = { - "procedure": sig.name, - "module": sig.module, - "argument": arg.name, - "kind": symbol, - "import_modules": FortranParser._visible_import_modules(symbol, sig.uses), - } - if (arg.kind or "").strip().lower() != symbol: - item["kind_expression"] = arg.kind - unresolved_args.append(item) - - for arg in sig.arguments: - if arg.base_type != "derived": - _append_unresolved_arg(arg) - if sig.result and sig.result.base_type != "derived": - _append_unresolved_arg(sig.result) - - for dtype in types: - uses = module_uses.get(dtype.module.lower(), {}) if dtype.module else {} - local_symbols: set[str] = set() - for field in dtype.fields: - if field.base_type == "derived": - continue - for symbol in sorted(FortranParser._kind_expression_symbols(field.kind)): - if FortranParser._kind_symbol_is_known( - symbol, - owning_module=dtype.module, - uses=uses, - local_symbols=local_symbols, - module_params=module_params, - ): - continue - item = { - "type_owner": dtype.name, - "module": dtype.module, - "field": field.name, - "kind": symbol, - "import_modules": FortranParser._visible_import_modules(symbol, uses), - } - if (field.kind or "").strip().lower() != symbol: - item["kind_expression"] = field.kind - unresolved_fields.append(item) - - return unresolved_args, unresolved_fields - - @staticmethod - def _build_wrap_blockers( - *, - signatures: list[FortranProcedureSignature], - unsupported: list[dict], - missing_decl_args: list[str], - unresolved_derived_args: list[dict], - unresolved_derived_fields: list[dict], - unresolved_kind_args: list[dict], - unresolved_kind_fields: list[dict], - ) -> list[dict]: - """Create explicit, user-facing reasons why a source is not wrap-ready.""" - blockers: list[dict] = [] - if not signatures: - blockers.append({ - "code": "no_signatures", - "message": "No procedure signatures were found to wrap.", - "items": [], - }) - if unsupported: - blockers.append({ - "code": "unsupported_constructs", - "message": "Unsupported Fortran constructs were found.", - "items": unsupported, - }) - if missing_decl_args: # pragma: no cover - public parsing resolves or rejects declarations before readiness. - blockers.append({ - "code": "unknown_argument_types", - "message": "Some procedure arguments have no resolved declaration/type.", - "items": missing_decl_args, - }) - if unresolved_derived_args: - blockers.append({ - "code": "unresolved_derived_type_arguments", - "message": "Some derived-type procedure arguments refer to types missing from the parsed source.", - "items": unresolved_derived_args, - }) - if unresolved_derived_fields: - blockers.append({ - "code": "unresolved_derived_type_fields", - "message": "Some derived-type fields refer to types missing from the parsed source.", - "items": unresolved_derived_fields, - }) - if unresolved_kind_args: - blockers.append({ - "code": "unresolved_kind_arguments", - "message": "Some procedure arguments use kind symbols missing from the parsed source/imports.", - "items": unresolved_kind_args, - }) - if unresolved_kind_fields: - blockers.append({ - "code": "unresolved_kind_fields", - "message": "Some derived-type fields use kind symbols missing from the parsed source/imports.", - "items": unresolved_kind_fields, - }) - return blockers - - @staticmethod - def _build_unit_blockers( - *, - filename: str | None, - signatures: list[FortranProcedureSignature], - types: list[FortranDerivedType], - unsupported: list[dict], - missing_decl_args: list[str], - unresolved_derived_args: list[dict], - unresolved_derived_fields: list[dict], - unresolved_kind_args: list[dict], - unresolved_kind_fields: list[dict], - ) -> list[dict]: - """Build unit-scoped blocker records without per-unit readiness flags. - - The file-level record owns diagnostics that do not belong to one procedure - or derived type. Procedure records own argument/result blockers. Derived - type records own field blockers. This lets large files say exactly which - unit prevents wrapping while keeping `wrappable` as a file-level result. - - Example: - ``_build_unit_blockers(signatures=[scale], types=[], ...)`` returns a - procedure item for ``scale`` only when that procedure has blockers. - """ - def same_unit(item: dict, sig: FortranProcedureSignature) -> bool: - return item.get("procedure") == sig.name and item.get("module") == sig.module - - def derived_type_unit_key(module: str | None, type_owner: str | None) -> tuple[str | None, str | None]: - return (module.lower() if module else None, type_owner.lower() if type_owner else None) - - units: list[dict] = [] - if not signatures: - units.append({ - "unit_kind": "file", - "name": filename or "", - "qualified_name": filename or "", - "module": None, - "blockers": [{ - "code": "no_signatures", - "message": "No procedure signatures were found to wrap.", - "items": [], - }], - }) - if unsupported: - units.append({ - "unit_kind": "file", - "name": filename or "", - "qualified_name": filename or "", - "module": None, - "blockers": [{ - "code": "unsupported_constructs", - "message": "Unsupported Fortran constructs were found.", - "items": unsupported, - }], - }) - - for sig in signatures: - blockers: list[dict] = [] - missing_items = [ - item - for item in missing_decl_args - if item.startswith(f"{sig.name}:") - ] - derived_items = [item for item in unresolved_derived_args if same_unit(item, sig)] - kind_items = [item for item in unresolved_kind_args if same_unit(item, sig)] - if missing_items: - blockers.append({ - "code": "unknown_argument_types", - "message": "Some procedure arguments have no resolved declaration/type.", - "items": missing_items, - }) - if derived_items: - blockers.append({ - "code": "unresolved_derived_type_arguments", - "message": "Some derived-type procedure arguments refer to types missing from the parsed source.", - "items": derived_items, - }) - if kind_items: - blockers.append({ - "code": "unresolved_kind_arguments", - "message": "Some procedure arguments use kind symbols missing from the parsed source/imports.", - "items": kind_items, - }) - if not blockers: - continue - qualified_name = f"{sig.module}.{sig.name}" if sig.module else sig.name - units.append({ - "unit_kind": "procedure", - "name": sig.name, - "qualified_name": qualified_name, - "module": sig.module, - "blockers": blockers, - }) - - derived_field_items: dict[tuple[str | None, str | None], list[dict]] = {} - for item in unresolved_derived_fields: - key = derived_type_unit_key(item.get("module"), item.get("type_owner")) - derived_field_items.setdefault(key, []).append(item) - - kind_field_items: dict[tuple[str | None, str | None], list[dict]] = {} - for item in unresolved_kind_fields: - key = derived_type_unit_key(item.get("module"), item.get("type_owner")) - kind_field_items.setdefault(key, []).append(item) - - seen_type_keys: set[tuple[str | None, str | None]] = set() - for dtype in types: - key = derived_type_unit_key(dtype.module, dtype.name) - seen_type_keys.add(key) - blockers = [] - if derived_field_items.get(key): - blockers.append({ - "code": "unresolved_derived_type_fields", - "message": "Some derived-type fields refer to types missing from the parsed source.", - "items": derived_field_items[key], - }) - if kind_field_items.get(key): - blockers.append({ - "code": "unresolved_kind_fields", - "message": "Some derived-type fields use kind symbols missing from the parsed source/imports.", - "items": kind_field_items[key], - }) - if not blockers: - continue - qualified_name = f"{dtype.module}.{dtype.name}" if dtype.module else dtype.name - units.append({ - "unit_kind": "derived_type", - "name": dtype.name, - "qualified_name": qualified_name, - "module": dtype.module, - "blockers": blockers, - }) - - def sort_unit_key(entry: tuple[tuple[str | None, str | None], list[dict]]) -> tuple[str, str]: - module, type_owner = entry[0] - return (module or "", type_owner or "") - - for key, items in sorted(derived_field_items.items(), key=sort_unit_key): - if key in seen_type_keys: - continue - module, type_owner = key - name = items[0].get("type_owner") - units.append({ - "unit_kind": "derived_type", - "name": name, - "qualified_name": f"{module}.{name}" if module and name else name, - "module": items[0].get("module"), - "blockers": [{ - "code": "unresolved_derived_type_fields", - "message": "Some derived-type fields refer to types missing from the parsed source.", - "items": items, - }], - }) - for key, items in sorted(kind_field_items.items(), key=sort_unit_key): - if key in seen_type_keys or key in derived_field_items: - continue - module, type_owner = key - name = items[0].get("type_owner") - units.append({ - "unit_kind": "derived_type", - "name": name, - "qualified_name": f"{module}.{name}" if module and name else name, - "module": items[0].get("module"), - "blockers": [{ - "code": "unresolved_kind_fields", - "message": "Some derived-type fields use kind symbols missing from the parsed source/imports.", - "items": items, - }], - }) - return units - # ------------------------------------------------------------------ # General lexical utilities # ------------------------------------------------------------------ @@ -4416,7 +3872,3 @@ def parse_fortran_file( def parse_fortran_project(files, *, encoding: str = "utf-8") -> FortranProject: return _DEFAULT_PARSER.visit_project(files, encoding=encoding) - - -def assess_wrap_readiness(code: str, filename: str | None = None) -> dict: - return _DEFAULT_PARSER.visit_wrap_readiness(code, filename=filename) diff --git a/tests/_shared/fixture_outputs.py b/tests/_shared/fixture_outputs.py index 1f658f3d1..e770aa56c 100644 --- a/tests/_shared/fixture_outputs.py +++ b/tests/_shared/fixture_outputs.py @@ -3,16 +3,19 @@ from pathlib import Path from x2py import parse_fortran_file -from semantics.fortran2ir import fortran_module_to_semantic_module +from semantics.fortran2ir import fortran_file_to_semantic_modules, fortran_module_to_semantic_module from semantics.pyi_printer import emit_module +from semantics.readiness import assess_semantic_wrap_readiness TESTS_DIR = Path(__file__).resolve().parents[1] FORTRAN_DATA_DIR = TESTS_DIR / "data" / "fortran" GENERAL_FORTRAN_DIR = FORTRAN_DATA_DIR / "general" SEMANTICS_FIXTURE_DIR = TESTS_DIR / "semantics" / "fixtures" / "general" +SEMANTIC_READINESS_FIXTURE_PATH = TESTS_DIR / "semantics" / "fixtures" / "wrap_readiness_messages.json" PYI_FIXTURE_DIR = TESTS_DIR / "pyi" / "fixtures" / "general" FORTRAN_SUFFIXES = {".f", ".f90", ".f95", ".f03", ".f08", ".for", ".f77", ".ftn"} +WRAP_READINESS_CORPUS_DIRS = ("general", "blas", "lapack", "scifortran") def iter_general_fortran_fixtures(): @@ -23,6 +26,26 @@ def iter_general_fortran_fixtures(): ) +def iter_wrap_readiness_fortran_fixtures(): + return sorted( + path + for dirname in WRAP_READINESS_CORPUS_DIRS + for path in (FORTRAN_DATA_DIR / dirname).rglob("*") + if path.is_file() and path.suffix.lower() in FORTRAN_SUFFIXES + ) + + +def readiness_fixture_key(path: Path) -> str: + return path.relative_to(FORTRAN_DATA_DIR).as_posix() + + +def parser_filename_for_fixture(path: Path) -> str: + relpath = readiness_fixture_key(path) + if relpath.startswith("scifortran/"): + return relpath.replace("scifortran/", "SciFortran/", 1) + return relpath + + def parse_fixture(path: Path): source = path.read_text(encoding="utf-8") return parse_fortran_file(source, filename=path.name) @@ -42,6 +65,56 @@ def semantic_payload_for_fixture(path: Path) -> dict: } +def wrap_readiness_message_payload_for_fixture(path: Path) -> dict: + source_key = readiness_fixture_key(path) + try: + source = path.read_text(encoding="utf-8") + parsed = parse_fortran_file(source, filename=parser_filename_for_fixture(path)) + modules = fortran_file_to_semantic_modules(parsed, standalone_module_name=path.stem) + readiness = assess_semantic_wrap_readiness(modules, source=source_key) + except Exception as exc: + return { + "wrappable": False, + "status": "semantic_error", + "messages": [str(exc)], + "blockers": [ + { + "code": "semantic_conversion_error", + "message": str(exc), + "n_items": 0, + } + ], + } + + return { + "wrappable": readiness["wrappable"], + "status": "ok", + "n_modules": readiness["n_modules"], + "n_functions": readiness["n_functions"], + "n_classes": readiness["n_classes"], + "n_variables": readiness["n_variables"], + "messages": list(readiness["why_not_wrappable"]), + "blockers": [ + { + "code": blocker["code"], + "message": blocker["message"], + "n_items": len(blocker.get("items") or []), + } + for blocker in readiness["wrappability_blockers"] + ], + } + + +def wrap_readiness_message_payload_for_corpus() -> dict: + return { + "corpus": list(WRAP_READINESS_CORPUS_DIRS), + "files": { + readiness_fixture_key(path): wrap_readiness_message_payload_for_fixture(path) + for path in iter_wrap_readiness_fortran_fixtures() + }, + } + + def pyi_text_for_fixture(path: Path) -> str: return "\n\n".join( emit_module(module) @@ -69,3 +142,12 @@ def write_pyi_fixture(path: Path) -> Path: out.parent.mkdir(parents=True, exist_ok=True) out.write_text(pyi_text_for_fixture(path) + "\n", encoding="utf-8") return out + + +def write_wrap_readiness_message_fixture() -> Path: + SEMANTIC_READINESS_FIXTURE_PATH.parent.mkdir(parents=True, exist_ok=True) + SEMANTIC_READINESS_FIXTURE_PATH.write_text( + json.dumps(wrap_readiness_message_payload_for_corpus(), indent=2) + "\n", + encoding="utf-8", + ) + return SEMANTIC_READINESS_FIXTURE_PATH diff --git a/tests/parser/test_cli.py b/tests/parser/test_cli.py index 04c5c3d21..bcb44d92a 100644 --- a/tests/parser/test_cli.py +++ b/tests/parser/test_cli.py @@ -102,40 +102,6 @@ def test_cli_parse_print_limit_limits_procedures(tmp_path: Path): assert "Variables:" not in res.stdout -def test_cli_wrap_readiness_output(): - cmd = [sys.executable, "-m", "x2py", str(TEST_FILE), "--wrap-readiness"] - res = subprocess.run(cmd, capture_output=True, text=True, check=True) - assert f"File: {TEST_FILE}" in res.stdout - assert "Source: fortran" in res.stdout - assert "Wrappable: yes" in res.stdout - assert "No semantic readiness blockers detected." in res.stdout - assert "Modules:" not in res.stdout - - -def test_cli_wrap_readiness_json_output(): - cmd = [sys.executable, "-m", "x2py", str(TEST_FILE), "--wrap-readiness", "--json"] - res = subprocess.run(cmd, capture_output=True, text=True, check=True) - payload = json.loads(res.stdout) - assert payload[str(TEST_FILE)]["source_kind"] == "fortran" - assert payload[str(TEST_FILE)]["wrap_readiness"]["wrappable"] is True - - -def test_cli_parse_can_include_semantic_wrap_readiness(): - cmd = [sys.executable, "-m", "x2py", str(TEST_FILE), "--parse", "--wrap-readiness"] - res = subprocess.run(cmd, capture_output=True, text=True, check=True) - assert "subroutine add1" in res.stdout - assert "Source: fortran" in res.stdout - assert "Wrappable: yes" in res.stdout - - -def test_cli_semantics_can_include_semantic_wrap_readiness(): - cmd = [sys.executable, "-m", "x2py", str(TEST_FILE), "--semantics", "--wrap-readiness"] - res = subprocess.run(cmd, capture_output=True, text=True, check=True) - payload = json.loads(res.stdout) - assert payload[str(TEST_FILE)]["semantic_modules"] - assert payload[str(TEST_FILE)]["wrap_readiness"]["wrappable"] is True - - def test_cli_json_out(tmp_path: Path): out = tmp_path / "report.json" cmd = [ @@ -173,6 +139,7 @@ def test_cli_json_output_without_out(): res = subprocess.run(cmd, capture_output=True, text=True, check=True) payload = json.loads(res.stdout) assert str(TEST_FILE) in payload + assert "wrap_readiness" not in payload[str(TEST_FILE)] def test_cli_pyi_output_without_out(): @@ -532,9 +499,6 @@ def test_cli_help_includes_examples(): assert "python -m x2py path/to/file.f90 --parse" in res.stdout assert "python -m x2py path/to/file.f90 --parse --show-vars" in res.stdout assert "python -m x2py path/to/file.f90 --parse --print-limit 50" in res.stdout - assert "python -m x2py path/to/file.f90 --wrap-readiness" in res.stdout - assert "python -m x2py path/to/file.f90 --semantics --wrap-readiness" in res.stdout - assert "python -m x2py path/to/module.pyi --wrap-readiness" in res.stdout assert "python -m x2py path/to/file.f90 --pyi --out module.pyi" in res.stdout @@ -609,59 +573,6 @@ class Node: def test_fortran_parser_cli_formatting_branches(): - blocker_items = [ - ( - "unsupported_constructs", - {"line": 3, "text": "common /blk/ x"}, - "line 3: common /blk/ x", - ), - ("unknown_argument_types", {"arg": "x"}, "{'arg': 'x'}"), - ( - "unresolved_derived_type_arguments", - {"procedure": "step", "argument": "state", "type": "state_t", "import_modules": ["state_mod"]}, - "step:state uses type(state_t) from state_mod", - ), - ( - "unresolved_derived_type_fields", - {"type_owner": "state_t", "field": "grid", "type": "grid_t", "import_modules": []}, - "state_t:grid uses type(grid_t) from ", - ), - ( - "unresolved_kind_arguments", - {"procedure": "scale", "argument": "x", "kind": "rk", "import_modules": ["kinds"]}, - "scale:x uses kind rk from kinds", - ), - ( - "unresolved_kind_fields", - {"type_owner": "state_t", "field": "value", "kind": "rk", "import_modules": []}, - "state_t:value uses kind rk from ", - ), - ("other", {"payload": 1}, "{'payload': 1}"), - ] - - for code, item, expected in blocker_items: - assert fortran_parser_cli._format_blocker_item(code, item) == expected - - readiness = fortran_parser_cli._format_wrap_readiness( - { - "bad.f90": { - "wrap_readiness": { - "wrappable": False, - "wrappability_blockers": [ - { - "code": "unsupported_constructs", - "message": "Unsupported constructs were found.", - "items": [{"line": 3, "text": "common /blk/ x"}], - } - ], - } - } - } - ) - assert "Wrappable: no" in readiness - assert "Why not wrappable:" in readiness - assert "* line 3: common /blk/ x" in readiness - report = fortran_parser_cli._format_report( { "types.f90": { @@ -671,7 +582,6 @@ def test_fortran_parser_cli_formatting_branches(): "submodules": [], "programs": [], "block_data": [], - "wrap_readiness": {"wrappable": True, "wrappability_blockers": []}, } } ) @@ -738,7 +648,6 @@ def test_fortran_parser_cli_format_report_print_limit_covers_sections(): {"name": None, "variables": [var_a, var_b]}, {"name": "named_block", "variables": []}, ], - "wrap_readiness": {"wrappable": True, "wrappability_blockers": []}, } }, show_vars=True, @@ -773,7 +682,7 @@ def test_fortran_parser_cli_format_report_print_limit_covers_sections(): assert fortran_parser_cli._format_variable_lines([], indent=" ", print_limit=1) == [] -def test_fortran_parser_cli_json_wrap_readiness_and_parse_errors(tmp_path: Path): +def test_fortran_parser_cli_json_and_parse_errors(tmp_path: Path): good = tmp_path / "good.f90" good.write_text("subroutine work(n)\n integer, intent(in) :: n\nend subroutine work\n", encoding="utf-8") @@ -781,10 +690,6 @@ def test_fortran_parser_cli_json_wrap_readiness_and_parse_errors(tmp_path: Path) json_res = subprocess.run(json_cmd, capture_output=True, text=True, check=True) assert str(good) in json.loads(json_res.stdout) - wrap_cmd = [sys.executable, "-m", "fortran_parser", str(good), "--wrap-readiness"] - wrap_res = subprocess.run(wrap_cmd, capture_output=True, text=True, check=True) - assert "Wrappable: yes" in wrap_res.stdout - bad = tmp_path / "bad.f90" bad.write_text("subroutine bad(x)\n weirdtype :: x\nend subroutine bad\n", encoding="utf-8") bad_cmd = [sys.executable, "-m", "fortran_parser", str(bad), "--no-color"] @@ -950,11 +855,6 @@ def test_fortran_parser_main_public_api_modes_from_inline_source(tmp_path: Path, assert "File:" in pyi_out assert "def work(" in pyi_out - monkeypatch.setattr(sys, "argv", ["fortran_parser", str(f90), "--wrap-readiness"]) - assert fortran_parser_cli.main() == 0 - wrap_out = capsys.readouterr().out - assert "Wrappable: yes" in wrap_out - monkeypatch.setattr(sys, "argv", ["fortran_parser", str(f90)]) assert fortran_parser_cli.main() == 0 readable = capsys.readouterr().out @@ -980,10 +880,6 @@ def test_x2py_main_public_api_modes_from_inline_source(tmp_path: Path, monkeypat assert capsys.readouterr().out == "" assert json.loads(json_out.read_text(encoding="utf-8")).get(str(f90)) is not None - monkeypatch.setattr(sys, "argv", ["x2py", str(f90), "--wrap-readiness"]) - assert x2py_cli.main() == 0 - assert "Wrappable: yes" in capsys.readouterr().out - monkeypatch.setattr(sys, "argv", ["x2py", str(f90), "--pyi"]) assert x2py_cli.main() == 0 assert "def work(" in capsys.readouterr().out diff --git a/tests/parser/test_parser_public_entrypoints.py b/tests/parser/test_parser_public_entrypoints.py index 2a4c086f1..4de59daba 100644 --- a/tests/parser/test_parser_public_entrypoints.py +++ b/tests/parser/test_parser_public_entrypoints.py @@ -4,7 +4,7 @@ import pytest from fortran_parser.parser import FortranParser -from x2py import FortranParseError, assess_wrap_readiness, parse_fortran_file, parse_fortran_project +from x2py import FortranParseError, parse_fortran_file, parse_fortran_project def test_parser_public_entrypoint_aliases_and_singular_contracts_use_inline_sources(): parser = FortranParser() @@ -21,7 +21,6 @@ def test_parser_public_entrypoint_aliases_and_singular_contracts_use_inline_sour assert parser.visit_file(module_code).modules[0].procedures[0].name == "ping" assert "alias_mod" in parser.visit_project({"alias.f90": module_code}).modules assert "alias_mod.ping" in parser.visit_project({"alias.f90": module_code}).procedures - assert parser.visit_wrap_readiness(module_code)["wrappable"] is True assert parser.visit_fortran_module("module single_mod\nend module single_mod\n").name == "single_mod" assert parser.visit_fortran_program("program driver\nend program driver\n").name == "driver" @@ -108,22 +107,7 @@ def test_public_instance_visitor_entrypoints_use_source_strings(): """ ) -def test_public_assess_wrap_readiness_alias_and_module_parameter_noise(tmp_path): - parser = FortranParser() - code = """ -module noisy_params_mod - integer, parameter :: rk = 8, ignored_token -contains - subroutine scale(x) - real(kind=rk), intent(inout) :: x - end subroutine scale -end module noisy_params_mod -""" - - report = parser.visit_wrap_readiness(code, filename="noisy_params.f90") - - assert report["wrappable"] is True - +def test_public_project_parse_from_path_sequence(tmp_path): source_path = tmp_path / "listed_project.f90" source_path.write_text( """ diff --git a/tests/parser/test_procedure_and_type_parsing.py b/tests/parser/test_procedure_and_type_parsing.py index 6e9f72100..07eb6221b 100644 --- a/tests/parser/test_procedure_and_type_parsing.py +++ b/tests/parser/test_procedure_and_type_parsing.py @@ -4,7 +4,7 @@ import pytest from fortran_parser.models import FortranFunctionCall, FortranSlice, FortranUseMapping, FortranVariable -from x2py import FortranParseError, assess_wrap_readiness, parse_fortran_file, parse_fortran_project +from x2py import FortranParseError, parse_fortran_file, parse_fortran_project collect_project_procedure_signatures = lambda files: list(parse_fortran_project(files).procedures.values()) parse_fortran_modules = lambda code, filename=None: parse_fortran_file(code, filename=filename).modules @@ -762,245 +762,6 @@ def test_compile_time_shape_eval_with_local_and_imported_params(): assert sig.arguments[0].shape == ["m*2"] -def test_assess_wrap_readiness_supported_and_unsupported(): - supported = """ -subroutine saxpy(n, x, y) - integer, intent(in) :: n - real(kind=8), intent(in) :: x(:) - real(kind=8), intent(inout) :: y(:) -end subroutine saxpy -""" - report_ok = assess_wrap_readiness(supported) - assert report_ok["wrappable"] is True - assert report_ok["unsupported_constructs"] == [] - - unsupported = """ -subroutine s(a) - class(*), intent(inout) :: a -end subroutine s -""" - report_bad = assess_wrap_readiness(unsupported) - assert report_bad["wrappable"] is False - assert report_bad["unsupported_constructs"] - - -def test_assess_wrap_readiness_explains_no_procedures_found(): - code = """ -module constants - integer, parameter :: n = 4 -end module constants -""" - report = assess_wrap_readiness(code, filename="constants.f90") - assert report["wrappable"] is False - assert report["why_not_wrappable"] == ["No procedure signatures were found to wrap."] - assert report["wrappability_blockers"] == [ - { - "code": "no_signatures", - "message": "No procedure signatures were found to wrap.", - "items": [], - } - ] - - -def test_assess_wrap_readiness_explains_unsupported_constructs(): - code = """ -subroutine visit(obj) - class(*), intent(inout) :: obj -end subroutine visit -""" - report = assess_wrap_readiness(code, filename="unsupported.f90") - assert report["wrappable"] is False - assert [b["code"] for b in report["wrappability_blockers"]] == ["unsupported_constructs"] - assert report["wrappability_blockers"][0]["items"][0]["text"] == "class(*), intent(inout) :: obj" - - -def test_assess_wrap_readiness_reports_imported_derived_type_argument_without_definition(): - code = """ -module solver - use state_mod, only: sim_state -contains -subroutine step(state) - type(sim_state), intent(inout) :: state -end subroutine step -end module solver -""" - report = assess_wrap_readiness(code, filename="solver.f90") - assert report["wrappable"] is False - assert report["unresolved_derived_type_arguments"] == [ - { - "procedure": "step", - "module": "solver", - "argument": "state", - "type": "sim_state", - "import_modules": ["state_mod"], - } - ] - - -def test_assess_wrap_readiness_accepts_derived_type_argument_defined_in_same_source(): - code = """ -module state_mod - type :: sim_state - real :: value - end type sim_state -end module state_mod - -module solver - use state_mod, only: sim_state -contains -subroutine step(state) - type(sim_state), intent(inout) :: state -end subroutine step -end module solver -""" - report = assess_wrap_readiness(code, filename="solver_with_state.f90") - assert report["wrappable"] is True - assert report["unresolved_derived_type_arguments"] == [] - - -def test_assess_wrap_readiness_reports_imported_derived_type_field_without_definition(): - code = """ -module mesh_mod - use point_mod, only: point - type :: mesh - type(point) :: origin - end type mesh -contains -subroutine update(m) - type(mesh), intent(inout) :: m -end subroutine update -end module mesh_mod -""" - report = assess_wrap_readiness(code, filename="mesh.f90") - assert report["wrappable"] is False - assert report["unresolved_derived_type_arguments"] == [] - assert report["unresolved_derived_type_fields"] == [ - { - "type_owner": "mesh", - "module": "mesh_mod", - "field": "origin", - "type": "point", - "import_modules": ["point_mod"], - } - ] - - -def test_assess_wrap_readiness_reports_imported_kind_argument_without_definition(): - code = """ -subroutine scale(x) - use kinds_mod, only: rk - real(kind=rk), intent(inout) :: x -end subroutine scale -""" - report = assess_wrap_readiness(code, filename="scale.f90") - assert report["wrappable"] is False - assert report["unresolved_kind_arguments"] == [ - { - "procedure": "scale", - "module": None, - "argument": "x", - "kind": "rk", - "import_modules": ["kinds_mod"], - } - ] - assert [b["code"] for b in report["wrappability_blockers"]] == ["unresolved_kind_arguments"] - scale_unit = next(item for item in report["unit_blockers"] if item["name"] == "scale") - assert "wrappable" not in scale_unit - assert [b["code"] for b in scale_unit["blockers"]] == ["unresolved_kind_arguments"] - - -def test_wrap_readiness_reports_each_procedure_unit_independently(): - code = """ -module mixed_ready_mod -contains -subroutine ok(x) - real(8), intent(inout) :: x -end subroutine ok - -subroutine bad(y) - use missing_kinds, only: rk - real(kind=rk), intent(inout) :: y -end subroutine bad -end module mixed_ready_mod -""" - report = assess_wrap_readiness(code, filename="mixed_ready.f90") - units = { - item["qualified_name"]: item - for item in report["unit_blockers"] - if item["unit_kind"] == "procedure" - } - - assert report["wrappable"] is False - assert "mixed_ready_mod.ok" not in units - assert "wrappable" not in units["mixed_ready_mod.bad"] - assert units["mixed_ready_mod.bad"]["blockers"][0]["code"] == "unresolved_kind_arguments" - - -def test_assess_wrap_readiness_reports_imported_kind_field_without_definition(): - code = """ -module state_mod - use kinds_mod, only: rk - type :: sim_state - real(kind=rk) :: value - end type sim_state -contains -subroutine update(state) - type(sim_state), intent(inout) :: state -end subroutine update -end module state_mod -""" - report = assess_wrap_readiness(code, filename="state.f90") - assert report["wrappable"] is False - assert report["unresolved_derived_type_fields"] == [] - assert report["unresolved_kind_fields"] == [ - { - "type_owner": "sim_state", - "module": "state_mod", - "field": "value", - "kind": "rk", - "import_modules": ["kinds_mod"], - } - ] - - -def test_assess_wrap_readiness_accumulates_multiple_blocker_reasons(): - code = """ -module state_mod - use point_mod, only: point - use kinds_mod, only: rk - type :: sim_state - type(point) :: origin - real(kind=rk) :: value - end type sim_state -contains -subroutine update(state, x) - type(missing_state), intent(inout) :: state - real(kind=rk), intent(inout) :: x -end subroutine update -end module state_mod -""" - report = assess_wrap_readiness(code, filename="multi_blocker.f90") - assert report["wrappable"] is False - assert [b["code"] for b in report["wrappability_blockers"]] == [ - "unresolved_derived_type_arguments", - "unresolved_derived_type_fields", - "unresolved_kind_arguments", - "unresolved_kind_fields", - ] - - -def test_assess_wrap_readiness_accepts_intrinsic_module_kind_symbols(): - code = """ -subroutine scale(x) - use iso_c_binding, only: c_double - real(kind=c_double), intent(inout) :: x -end subroutine scale -""" - report = assess_wrap_readiness(code, filename="intrinsic_kind.f90") - assert report["wrappable"] is True - assert report["unresolved_kind_arguments"] == [] - - def test_parse_namespace_dependency_resolution(tmp_path): dep = tmp_path / "kinds.f90" user = tmp_path / "solver.f90" @@ -1532,12 +1293,6 @@ def test_submodule_module_procedure_stub_and_additional_program_units(): assert block_data[0].name == "init_data" assert [v.name for v in block_data[0].variables] == ["seed"] - readiness = assess_wrap_readiness(code) - assert readiness["n_submodules"] == 1 - assert readiness["n_programs"] == 1 - assert readiness["n_block_data"] == 1 - - def test_procedure_dummy_declaration_tracks_local_interface_kind(): code = """ subroutine caller(cb) diff --git a/tests/parser/test_scope_handling.py b/tests/parser/test_scope_handling.py index 2d9031b22..867afd341 100644 --- a/tests/parser/test_scope_handling.py +++ b/tests/parser/test_scope_handling.py @@ -1,6 +1,6 @@ import pytest -from x2py import assess_wrap_readiness, parse_fortran_file +from x2py import parse_fortran_file from fortran_parser.models import FortranParseError def test_same_argument_name_in_different_procedures_is_allowed(): @@ -285,7 +285,6 @@ def test_module_parameter_shape_is_visible_to_contained_function_scope(): assert proc.arguments[0].base_type == "real" assert proc.result.base_type == "real" assert proc.variables == {} - assert assess_wrap_readiness(code, filename="scope_module_shape_param_ok.f90")["wrappable"] is True def test_fortran_parser_class_entrypoint(): diff --git a/tests/parser/test_wrap_readiness.py b/tests/parser/test_wrap_readiness.py deleted file mode 100644 index 0e6eccdcd..000000000 --- a/tests/parser/test_wrap_readiness.py +++ /dev/null @@ -1,167 +0,0 @@ -# -*- coding: utf-8 -*- -"""Wrap-readiness decisions and blocker reporting.""" - -from x2py import assess_wrap_readiness - -def test_wrap_readiness_reports_unresolved_function_result_type_and_kind(): - code = """ -function make_state() result(state) - use state_mod, only: sim_state - type(sim_state) :: state -end function make_state - -function make_value() result(value) - use kinds_mod, only: rk - real(kind=rk) :: value -end function make_value -""" - - report = assess_wrap_readiness(code) - - assert report["wrappable"] is False - assert report["unresolved_derived_type_arguments"] == [ - { - "procedure": "make_state", - "module": None, - "argument": "state", - "type": "sim_state", - "import_modules": ["state_mod"], - } - ] - assert report["unresolved_kind_arguments"] == [ - { - "procedure": "make_value", - "module": None, - "argument": "value", - "kind": "rk", - "import_modules": ["kinds_mod"], - } - ] - -def test_wrap_readiness_accepts_module_and_use_associated_kind_parameters(): - code = """ -module kinds_mod - integer, parameter :: rk = selected_real_kind(12) -end module kinds_mod - -module solver_mod - use kinds_mod - integer, parameter :: ik = selected_int_kind(9) -contains - subroutine scale(x, i) - real(kind=rk), intent(inout) :: x - integer(kind=ik), intent(out) :: i - end subroutine scale -end module solver_mod -""" - - report = assess_wrap_readiness(code) - - assert report["wrappable"] is True - assert report["unresolved_kind_arguments"] == [] - -def test_wrap_readiness_requires_intrinsic_kind_symbols_to_be_imported(): - missing_import = """ -subroutine scale(x) - real(kind=c_double), intent(inout) :: x -end subroutine scale -""" - report = assess_wrap_readiness(missing_import) - - assert report["wrappable"] is False - assert report["unresolved_kind_arguments"] == [ - { - "procedure": "scale", - "module": None, - "argument": "x", - "kind": "c_double", - "import_modules": [], - } - ] - - imported = """ -subroutine scale(x, y) - use, intrinsic :: iso_c_binding, only: c_double, cd => c_float - real(kind=c_double), intent(inout) :: x - real(kind=cd), intent(inout) :: y -end subroutine scale -""" - report = assess_wrap_readiness(imported) - - assert report["wrappable"] is True - assert report["unresolved_kind_arguments"] == [] - -def test_wrap_readiness_accepts_arbitrary_imported_kind_symbols_and_expressions(): - code = """ -module kinds_mod - integer, parameter :: wp = selected_real_kind(12) - integer, parameter :: extra = 1 -end module kinds_mod - -module solver_mod -contains - subroutine scale(x, name) - use kinds_mod, only: local_wp => wp, extra - real(kind=local_wp + extra), intent(inout) :: x - character(len=extra, kind=local_wp), intent(out) :: name - end subroutine scale -end module solver_mod -""" - - report = assess_wrap_readiness(code) - - assert report["wrappable"] is True - assert report["unresolved_kind_arguments"] == [] - -def test_wrap_readiness_reports_missing_symbols_inside_kind_expressions(): - code = """ -module kinds_mod - integer, parameter :: wp = selected_real_kind(12) -end module kinds_mod - -subroutine scale(x) - use kinds_mod, only: wp - real(kind=wp + missing_offset), intent(inout) :: x -end subroutine scale -""" - - report = assess_wrap_readiness(code) - - assert report["wrappable"] is False - assert report["unresolved_kind_arguments"] == [ - { - "procedure": "scale", - "module": None, - "argument": "x", - "kind": "missing_offset", - "import_modules": [], - "kind_expression": "wp + missing_offset", - } - ] - -def test_readiness_accepts_procedure_local_kind_parameter(): - code = """ -subroutine scale(x) - integer, parameter :: rk = 8 - real(kind=rk), intent(inout) :: x -end subroutine scale -""" - - report = assess_wrap_readiness(code, filename="local_kind.f90") - - assert report["wrappable"] is True - assert report["unresolved_kind_arguments"] == [] - -def test_wrap_readiness_infers_interface_argument_types_for_readiness(): - code = """ -interface - subroutine cb(x) - implicit none - end subroutine cb -end interface -""" - - report = assess_wrap_readiness(code, filename="unknown_interface_arg.f90") - - assert report["wrappable"] is True - assert report["unknown_argument_types"] == [] diff --git a/tests/semantics/fixtures/wrap_readiness_messages.json b/tests/semantics/fixtures/wrap_readiness_messages.json new file mode 100644 index 000000000..0b0c67b39 --- /dev/null +++ b/tests/semantics/fixtures/wrap_readiness_messages.json @@ -0,0 +1,30776 @@ +{ + "corpus": [ + "general", + "blas", + "lapack", + "scifortran" + ], + "files": { + "blas/caxpy.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/ccopy.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/cdotc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/cdotu.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/cgbmv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/cgemm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/cgemmtr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/cgemv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/cgerc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/cgeru.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/chbmv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/chemm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/chemv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/cher.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/cher2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/cher2k.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/cherk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/chpmv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/chpr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/chpr2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/crotg.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/cscal.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/csrot.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/csscal.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/cswap.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/csymm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/csyr2k.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/csyrk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/ctbmv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/ctbsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/ctpmv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/ctpsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/ctrmm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/ctrmv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/ctrsm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/ctrsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dasum.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/daxpy.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dcabs1.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "blas/dcopy.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/ddot.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dgbmv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dgemm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dgemmtr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dgemv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dger.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dnrm2.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/drot.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/drotg.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/drotm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/drotmg.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dsbmv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dscal.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dsdot.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dspmv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dspr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dspr2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dswap.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dsymm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dsymv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dsyr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dsyr2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dsyr2k.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dsyrk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dtbmv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dtbsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dtpmv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dtpsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dtrmm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dtrmv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dtrsm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dtrsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/dzasum.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "blas/dznrm2.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/icamax.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/idamax.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/isamax.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/izamax.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "blas/lsame.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/sasum.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/saxpy.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/scabs1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/scasum.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/scnrm2.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/scopy.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/sdot.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/sdsdot.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/sgbmv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/sgemm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/sgemmtr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/sgemv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/sger.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/snrm2.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/srot.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/srotg.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/srotm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/srotmg.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/ssbmv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/sscal.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/sspmv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/sspr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/sspr2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/sswap.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/ssymm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/ssymv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/ssyr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/ssyr2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/ssyr2k.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/ssyrk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/stbmv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/stbsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/stpmv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/stpsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/strmm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/strmv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/strsm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/strsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/xerbla.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/xerbla_array.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/zaxpy.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "blas/zcopy.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "blas/zdotc.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "blas/zdotu.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "blas/zdrot.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "blas/zdscal.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "blas/zgbmv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "blas/zgemm.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "blas/zgemmtr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "blas/zgemv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "blas/zgerc.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "blas/zgeru.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "blas/zhbmv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "blas/zhemm.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "blas/zhemv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "blas/zher.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "blas/zher2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "blas/zher2k.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "blas/zherk.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "blas/zhpmv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "blas/zhpr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "blas/zhpr2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "blas/zrotg.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "blas/zscal.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "blas/zswap.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "blas/zsymm.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "blas/zsyr2k.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "blas/zsyrk.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "blas/ztbmv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "blas/ztbsv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "blas/ztpmv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "blas/ztpsv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "blas/ztrmm.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "blas/ztrmv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "blas/ztrsm.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "blas/ztrsv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "general/assumed_shape_and_derived_args.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 3, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface.", + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 2 + }, + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "general/basic_subroutine.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "general/compile_time_all_exprs.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 9, + "messages": [ + "Some compile-time constants are declared but do not have literal .pyi values." + ], + "blockers": [ + { + "code": "missing_compile_time_values", + "message": "Some compile-time constants are declared but do not have literal .pyi values.", + "n_items": 28 + } + ] + }, + "general/compile_time_shape_exprs.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 2, + "messages": [ + "Some compile-time constants are declared but do not have literal .pyi values." + ], + "blockers": [ + { + "code": "missing_compile_time_values", + "message": "Some compile-time constants are declared but do not have literal .pyi values.", + "n_items": 4 + } + ] + }, + "general/derived_type.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 1, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "general/derived_types_and_methods.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 0, + "n_classes": 2, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "general/f77_subroutine.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "general/modern_pyi_example.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 6, + "n_classes": 2, + "n_variables": 1, + "messages": [], + "blockers": [] + }, + "general/module_vars_use.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 0, + "n_classes": 0, + "n_variables": 2, + "messages": [], + "blockers": [] + }, + "general/procedures_and_functions.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "general/scope_name_reuse_combinations.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 8, + "n_classes": 1, + "n_variables": 5, + "messages": [], + "blockers": [] + }, + "lapack/cbbcsd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cbdsqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgbbrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgbcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgbequ.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgbequb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgbrfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgbrfsx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgbsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgbsvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgbsvxx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgbtf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgbtrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgbtrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgebak.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgebal.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgebd2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgebrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgecon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgedmd.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgedmdq.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgeequ.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgeequb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgees.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgeesx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgeev.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgeevx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgehd2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgehrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgejsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgelq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgelq2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgelqf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgelqt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgelqt3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgels.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgelsd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgelss.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgelst.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgelsy.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgemlq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgemlqt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgemqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgemqrt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgeql2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgeqlf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgeqp3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgeqp3rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgeqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgeqr2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgeqr2p.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgeqrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgeqrfp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgeqrt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgeqrt2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgeqrt3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgerfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgerfsx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgerq2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgerqf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgesc2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgesdd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgesv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgesvd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgesvdq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgesvdx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgesvj.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgesvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgesvxx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgetc2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgetf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgetrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgetrf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgetri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgetrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgetsls.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgetsqrhrt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cggbak.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cggbal.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgges.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgges3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cggesx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cggev.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cggev3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cggevx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cggglm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgghd3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgghrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgglse.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cggqrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cggrqf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cggsvd3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cggsvp3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgsvj0.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgsvj1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgtcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgtrfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgtsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgtsvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgttrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgttrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cgtts2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chb2st_kernels.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chbev.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chbev_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chbevd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chbevd_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chbevx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chbevx_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chbgst.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chbgv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chbgvd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chbgvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chbtrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/checon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/checon_3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/checon_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cheequb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cheev.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cheev_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cheevd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cheevd_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cheevr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cheevr_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cheevx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cheevx_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chegs2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chegst.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chegv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chegv_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chegvd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chegvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cherfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cherfsx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chesv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chesv_aa.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chesv_aa_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chesv_rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chesv_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chesvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chesvxx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cheswapr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetd2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetf2_rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetf2_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetrd_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetrd_hb2st.F": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetrd_he2hb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetrf_aa.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetrf_aa_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetrf_rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetrf_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetri2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetri2x.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetri_3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetri_3x.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetri_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetrs2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetrs_3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetrs_aa.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetrs_aa_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chetrs_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chfrk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chgeqz.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chla_transtype.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chpcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chpev.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chpevd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chpevx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chpgst.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chpgv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chpgvd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chpgvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chprfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chpsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chpsvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chptrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chptrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chptri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chptrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chsein.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/chseqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_gbamv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_gbrcond_c.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_gbrcond_x.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_gbrfsx_extended.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_gbrpvgrw.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_geamv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_gercond_c.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_gercond_x.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_gerfsx_extended.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_gerpvgrw.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_heamv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_hercond_c.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_hercond_x.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_herfsx_extended.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_herpvgrw.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_lin_berr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_porcond_c.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_porcond_x.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_porfsx_extended.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_porpvgrw.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_syamv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_syrcond_c.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_syrcond_x.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_syrfsx_extended.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_syrpvgrw.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cla_wwaddw.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clabrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clacgv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clacn2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clacon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clacp2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clacpy.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clacrm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clacrt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cladiv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claed0.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claed7.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claed8.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claein.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claesy.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claev2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clag2z.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/clags2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clagtm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clahef.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clahef_aa.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clahef_rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clahef_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clahqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clahr2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claic1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clals0.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clalsa.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clalsd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clamswlq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clamtsqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clangb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clange.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clangt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clanhb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clanhe.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clanhf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clanhp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clanhs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clanht.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clansb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clansp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clansy.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clantb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clantp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clantr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clapll.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clapmr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clapmt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claqgb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claqge.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claqhb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claqhe.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claqhp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claqp2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claqp2rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claqp3rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claqps.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claqr0.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claqr1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claqr2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claqr3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claqr4.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claqr5.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claqsb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claqsp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claqsy.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claqz0.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claqz1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claqz2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claqz3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clar1v.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clar2v.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clarcm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clarf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clarf1f.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clarf1l.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clarfb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clarfb_gett.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clarfg.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clarfgp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clarft.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clarfx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clarfy.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clargv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clarnv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clarrv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clarscl2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clartg.f90": { + "wrappable": false, + "status": "semantic_error", + "messages": [ + "Unsupported Fortran semantic type for variable 'f': complex(kind=wp)" + ], + "blockers": [ + { + "code": "semantic_conversion_error", + "message": "Unsupported Fortran semantic type for variable 'f': complex(kind=wp)", + "n_items": 0 + } + ] + }, + "lapack/clartv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clarz.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clarzb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clarzt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clascl.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clascl2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claset.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clasr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/classq.f90": { + "wrappable": false, + "status": "semantic_error", + "messages": [ + "Unsupported Fortran semantic type for variable 'x': complex(kind=wp)" + ], + "blockers": [ + { + "code": "semantic_conversion_error", + "message": "Unsupported Fortran semantic type for variable 'x': complex(kind=wp)", + "n_items": 0 + } + ] + }, + "lapack/claswlq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claswp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clasyf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clasyf_aa.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clasyf_rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clasyf_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clatbs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clatdf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clatps.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clatrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clatrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clatrs3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clatrz.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clatsqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claunhr_col_getrfnp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/claunhr_col_getrfnp2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clauu2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/clauum.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpbcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpbequ.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpbrfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpbstf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpbsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpbsvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpbtf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpbtrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpbtrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpftrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpftri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpftrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpocon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpoequ.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpoequb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cporfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cporfsx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cposv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cposvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cposvxx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpotf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpotrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpotrf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpotri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpotrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cppcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cppequ.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpprfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cppsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cppsvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpptrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpptri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpptrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpstf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpstrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cptcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpteqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cptrfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cptsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cptsvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpttrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cpttrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cptts2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/crot.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/crscl.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cspcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cspmv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cspr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csprfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cspsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cspsvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csptrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csptri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csptrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csrscl.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cstedc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cstegr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cstein.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cstemr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csteqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csycon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csycon_3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csycon_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csyconv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csyconvf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csyconvf_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csyequb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csymv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csyr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csyrfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csyrfsx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csysv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csysv_aa.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csysv_aa_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csysv_rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csysv_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csysvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csysvxx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csyswapr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csytf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csytf2_rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csytf2_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csytrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csytrf_aa.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csytrf_aa_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csytrf_rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csytrf_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csytri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csytri2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csytri2x.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csytri_3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csytri_3x.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csytri_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csytrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csytrs2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csytrs_3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csytrs_aa.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csytrs_aa_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/csytrs_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctbcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctbrfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctbtrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctfsm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctftri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctfttp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctfttr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctgevc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctgex2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctgexc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctgsen.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctgsja.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctgsna.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctgsy2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctgsyl.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctpcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctplqt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctplqt2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctpmlqt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctpmqrt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctpqrt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctpqrt2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctprfb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctprfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctptri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctptrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctpttf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctpttr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctrcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctrevc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctrevc3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctrexc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctrrfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctrsen.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctrsna.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctrsyl.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctrsyl3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctrti2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctrtri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctrtrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctrttf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctrttp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ctzrzf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cunbdb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cunbdb1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cunbdb2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cunbdb3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cunbdb4.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cunbdb5.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cunbdb6.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cuncsd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cuncsd2by1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cung2l.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cung2r.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cungbr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cunghr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cungl2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cunglq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cungql.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cungqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cungr2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cungrq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cungtr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cungtsqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cungtsqr_row.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cunhr_col.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cunm22.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cunm2l.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cunm2r.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cunmbr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cunmhr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cunml2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cunmlq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cunmql.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cunmqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cunmr2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cunmr3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cunmrq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cunmrz.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cunmtr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cupgtr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/cupmtr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dbbcsd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dbdsdc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dbdsqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dbdsvdx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ddisna.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgbbrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgbcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgbequ.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgbequb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgbrfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgbrfsx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgbsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgbsvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgbsvxx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgbtf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgbtrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgbtrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgebak.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgebal.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgebd2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgebrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgecon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgedmd.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgedmdq.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgeequ.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgeequb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgees.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgeesx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgeev.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgeevx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgehd2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgehrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgejsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgelq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgelq2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgelqf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgelqt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgelqt3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgels.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgelsd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgelss.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgelst.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgelsy.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgemlq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgemlqt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgemqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgemqrt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgeql2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgeqlf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgeqp3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgeqp3rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgeqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgeqr2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgeqr2p.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgeqrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgeqrfp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgeqrt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgeqrt2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgeqrt3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgerfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgerfsx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgerq2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgerqf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgesc2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgesdd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgesv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgesvd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgesvdq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgesvdx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgesvj.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgesvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgesvxx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgetc2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgetf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgetrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgetrf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgetri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgetrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgetsls.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgetsqrhrt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dggbak.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dggbal.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgges.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgges3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dggesx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dggev.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dggev3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dggevx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dggglm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgghd3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgghrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgglse.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dggqrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dggrqf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dggsvd3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dggsvp3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgsvj0.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgsvj1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgtcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgtrfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgtsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgtsvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgttrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgttrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dgtts2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dhgeqz.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dhsein.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dhseqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/disnan.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dla_gbamv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dla_gbrcond.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dla_gbrfsx_extended.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dla_gbrpvgrw.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dla_geamv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dla_gercond.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dla_gerfsx_extended.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dla_gerpvgrw.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dla_lin_berr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dla_porcond.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dla_porfsx_extended.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dla_porpvgrw.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dla_syamv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dla_syrcond.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dla_syrfsx_extended.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dla_syrpvgrw.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dla_wwaddw.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlabad.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlabrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlacn2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlacon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlacpy.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dladiv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 3, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlae2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaebz.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaed0.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaed1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaed2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaed3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaed4.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaed5.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaed6.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaed7.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaed8.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaed9.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaeda.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaein.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaev2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaexc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlag2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlag2s.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlags2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlagtf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlagtm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlagts.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlagv2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlahqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlahr2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaic1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaisnan.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaln2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlals0.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlalsa.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlalsd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlamrg.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlamswlq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlamtsqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaneg.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlangb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlange.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlangt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlanhs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlansb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlansf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlansp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlanst.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlansy.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlantb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlantp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlantr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlanv2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaorhr_col_getrfnp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaorhr_col_getrfnp2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlapll.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlapmr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlapmt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlapy2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlapy3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaqgb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaqge.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaqp2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaqp2rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaqp3rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaqps.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaqr0.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaqr1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaqr2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaqr3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaqr4.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaqr5.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaqsb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaqsp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaqsy.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaqtr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaqz0.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaqz1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaqz2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaqz3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaqz4.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlar1v.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlar2v.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarf1f.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarf1l.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarfb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarfb_gett.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarfg.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarfgp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarft.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarfx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarfy.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlargv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarmm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarnv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarra.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarrb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarrc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarre.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarrj.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarrk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarrr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarrv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarscl2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlartg.f90": { + "wrappable": false, + "status": "semantic_error", + "messages": [ + "Unsupported Fortran semantic type for variable 'f': real(kind=wp)" + ], + "blockers": [ + { + "code": "semantic_conversion_error", + "message": "Unsupported Fortran semantic type for variable 'f': real(kind=wp)", + "n_items": 0 + } + ] + }, + "lapack/dlartgp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlartgs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlartv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaruv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarz.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarzb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlarzt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlas2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlascl.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlascl2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasd0.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasd1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasd2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasd3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasd4.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasd5.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasd6.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasd7.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasd8.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasda.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasdq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasdt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaset.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasq1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasq2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasq3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasq4.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasq5.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasq6.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasrt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlassq.f90": { + "wrappable": false, + "status": "semantic_error", + "messages": [ + "Unsupported Fortran semantic type for variable 'x': real(kind=wp)" + ], + "blockers": [ + { + "code": "semantic_conversion_error", + "message": "Unsupported Fortran semantic type for variable 'x': real(kind=wp)", + "n_items": 0 + } + ] + }, + "lapack/dlasv2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaswlq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlaswp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasy2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasyf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasyf_aa.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasyf_rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlasyf_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlat2s.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlatbs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlatdf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlatps.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlatrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlatrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlatrs3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlatrz.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlatsqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlauu2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dlauum.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dopgtr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dopmtr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorbdb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorbdb1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorbdb2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorbdb3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorbdb4.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorbdb5.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorbdb6.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorcsd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorcsd2by1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorg2l.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorg2r.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorgbr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorghr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorgl2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorglq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorgql.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorgqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorgr2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorgrq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorgtr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorgtsqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorgtsqr_row.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorhr_col.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorm22.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorm2l.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorm2r.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dormbr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dormhr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dorml2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dormlq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dormql.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dormqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dormr2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dormr3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dormrq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dormrz.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dormtr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpbcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpbequ.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpbrfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpbstf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpbsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpbsvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpbtf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpbtrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpbtrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpftrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpftri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpftrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpocon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpoequ.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpoequb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dporfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dporfsx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dposv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dposvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dposvxx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpotf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpotrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpotrf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpotri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpotrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dppcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dppequ.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpprfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dppsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dppsvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpptrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpptri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpptrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpstf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpstrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dptcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpteqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dptrfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dptsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dptsvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpttrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dpttrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dptts2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/drscl.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsb2st_kernels.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsbev.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsbev_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsbevd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsbevd_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsbevx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsbevx_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsbgst.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsbgv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsbgvd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsbgvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsbtrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsfrk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsgesv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dspcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dspev.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dspevd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dspevx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dspgst.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dspgv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dspgvd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dspgvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsposv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsprfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dspsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dspsvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsptrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsptrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsptri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsptrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dstebz.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dstedc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dstegr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dstein.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dstemr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsteqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsterf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dstev.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dstevd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dstevr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dstevx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsycon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsycon_3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsycon_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsyconv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsyconvf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsyconvf_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsyequb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsyev.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsyev_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsyevd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsyevd_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsyevr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsyevr_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsyevx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsyevx_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsygs2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsygst.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsygv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsygv_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsygvd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsygvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsyrfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsyrfsx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsysv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsysv_aa.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsysv_aa_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsysv_rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsysv_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsysvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsysvxx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsyswapr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytd2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytf2_rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytf2_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytrd_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytrd_sb2st.F": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytrd_sy2sb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytrf_aa.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytrf_aa_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytrf_rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytrf_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytri2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytri2x.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytri_3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytri_3x.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytri_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytrs2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytrs_3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytrs_aa.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytrs_aa_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dsytrs_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtbcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtbrfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtbtrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtfsm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtftri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtfttp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtfttr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtgevc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtgex2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtgexc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtgsen.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtgsja.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtgsna.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtgsy2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtgsyl.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtpcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtplqt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtplqt2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtpmlqt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtpmqrt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtpqrt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtpqrt2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtprfb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtprfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtptri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtptrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtpttf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtpttr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtrcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtrevc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtrevc3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtrexc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtrrfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtrsen.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtrsna.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtrsyl.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtrsyl3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtrti2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtrtri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtrtrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtrttf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtrttp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dtzrzf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/dzsum1.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/icmax1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ieeeck.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ilaclc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ilaclr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/iladiag.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/iladlc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/iladlr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ilaenv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ilaenv2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ilaprec.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ilaslc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ilaslr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ilatrans.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ilauplo.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ilazlc.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/ilazlr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/iparam2stage.F": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/iparmq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/izmax1.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/la_constants.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 0, + "n_classes": 0, + "n_variables": 52, + "messages": [], + "blockers": [] + }, + "lapack/la_xisnan.F90": { + "wrappable": false, + "status": "semantic_error", + "messages": [ + "Unsupported Fortran semantic type for variable 'x': real(kind=wp)" + ], + "blockers": [ + { + "code": "semantic_conversion_error", + "message": "Unsupported Fortran semantic type for variable 'x': real(kind=wp)", + "n_items": 0 + } + ] + }, + "lapack/lsamen.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sbbcsd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sbdsdc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sbdsqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sbdsvdx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/scsum1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sdisna.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgbbrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgbcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgbequ.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgbequb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgbrfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgbrfsx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgbsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgbsvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgbsvxx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgbtf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgbtrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgbtrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgebak.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgebal.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgebd2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgebrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgecon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgedmd.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgedmdq.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgeequ.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgeequb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgees.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgeesx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgeev.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgeevx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgehd2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgehrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgejsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgelq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgelq2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgelqf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgelqt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgelqt3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgels.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgelsd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgelss.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgelst.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgelsy.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgemlq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgemlqt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgemqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgemqrt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgeql2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgeqlf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgeqp3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgeqp3rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgeqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgeqr2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgeqr2p.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgeqrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgeqrfp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgeqrt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgeqrt2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgeqrt3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgerfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgerfsx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgerq2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgerqf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgesc2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgesdd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgesv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgesvd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgesvdq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgesvdx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgesvj.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgesvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgesvxx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgetc2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgetf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgetrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgetrf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgetri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgetrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgetsls.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgetsqrhrt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sggbak.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sggbal.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgges.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgges3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sggesx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sggev.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sggev3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sggevx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sggglm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgghd3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgghrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgglse.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sggqrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sggrqf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sggsvd3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sggsvp3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgsvj0.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgsvj1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgtcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgtrfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgtsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgtsvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgttrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgttrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sgtts2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/shgeqz.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/shsein.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/shseqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sisnan.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sla_gbamv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sla_gbrcond.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sla_gbrfsx_extended.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sla_gbrpvgrw.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sla_geamv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sla_gercond.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sla_gerfsx_extended.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sla_gerpvgrw.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sla_lin_berr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sla_porcond.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sla_porfsx_extended.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sla_porpvgrw.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sla_syamv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sla_syrcond.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sla_syrfsx_extended.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sla_syrpvgrw.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sla_wwaddw.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slabad.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slabrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slacn2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slacon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slacpy.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sladiv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 3, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slae2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaebz.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaed0.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaed1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaed2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaed3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaed4.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaed5.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaed6.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaed7.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaed8.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaed9.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaeda.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaein.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaev2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaexc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slag2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slag2d.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slags2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slagtf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slagtm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slagts.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slagv2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slahqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slahr2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaic1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaisnan.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaln2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slals0.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slalsa.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slalsd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slamrg.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slamswlq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slamtsqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaneg.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slangb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slange.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slangt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slanhs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slansb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slansf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slansp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slanst.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slansy.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slantb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slantp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slantr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slanv2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaorhr_col_getrfnp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaorhr_col_getrfnp2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slapll.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slapmr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slapmt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slapy2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slapy3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaqgb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaqge.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaqp2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaqp2rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaqp3rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaqps.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaqr0.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaqr1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaqr2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaqr3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaqr4.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaqr5.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaqsb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaqsp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaqsy.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaqtr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaqz0.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaqz1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaqz2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaqz3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaqz4.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slar1v.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slar2v.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarf1f.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarf1l.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarfb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarfb_gett.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarfg.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarfgp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarft.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarfx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarfy.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slargv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarmm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarnv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarra.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarrb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarrc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarre.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarrj.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarrk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarrr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarrv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarscl2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slartg.f90": { + "wrappable": false, + "status": "semantic_error", + "messages": [ + "Unsupported Fortran semantic type for variable 'f': real(kind=wp)" + ], + "blockers": [ + { + "code": "semantic_conversion_error", + "message": "Unsupported Fortran semantic type for variable 'f': real(kind=wp)", + "n_items": 0 + } + ] + }, + "lapack/slartgp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slartgs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slartv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaruv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarz.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarzb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slarzt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slas2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slascl.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slascl2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasd0.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasd1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasd2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasd3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasd4.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasd5.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasd6.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasd7.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasd8.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasda.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasdq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasdt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaset.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasq1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasq2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasq3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasq4.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasq5.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasq6.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasrt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slassq.f90": { + "wrappable": false, + "status": "semantic_error", + "messages": [ + "Unsupported Fortran semantic type for variable 'x': real(kind=wp)" + ], + "blockers": [ + { + "code": "semantic_conversion_error", + "message": "Unsupported Fortran semantic type for variable 'x': real(kind=wp)", + "n_items": 0 + } + ] + }, + "lapack/slasv2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaswlq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slaswp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasy2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasyf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasyf_aa.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasyf_rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slasyf_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slatbs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slatdf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slatps.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slatrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slatrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slatrs3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slatrz.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slatsqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slauu2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/slauum.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sopgtr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sopmtr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorbdb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorbdb1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorbdb2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorbdb3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorbdb4.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorbdb5.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorbdb6.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorcsd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorcsd2by1.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorg2l.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorg2r.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorgbr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorghr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorgl2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorglq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorgql.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorgqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorgr2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorgrq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorgtr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorgtsqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorgtsqr_row.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorhr_col.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorm22.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorm2l.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorm2r.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sormbr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sormhr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sorml2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sormlq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sormql.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sormqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sormr2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sormr3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sormrq.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sormrz.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sormtr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spbcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spbequ.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spbrfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spbstf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spbsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spbsvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spbtf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spbtrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spbtrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spftrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spftri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spftrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spocon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spoequ.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spoequb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sporfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sporfsx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sposv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sposvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sposvxx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spotf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spotrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spotrf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spotri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spotrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sppcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sppequ.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spprfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sppsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sppsvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spptrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spptri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spptrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spstf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spstrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sptcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spteqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sptrfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sptsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sptsvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spttrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/spttrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sptts2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/srscl.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssb2st_kernels.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssbev.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssbev_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssbevd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssbevd_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssbevx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssbevx_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssbgst.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssbgv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssbgvd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssbgvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssbtrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssfrk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sspcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sspev.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sspevd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sspevx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sspgst.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sspgv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sspgvd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sspgvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssprfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sspsv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sspsvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssptrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssptrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssptri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssptrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sstebz.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sstedc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sstegr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sstein.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sstemr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssteqr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssterf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sstev.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sstevd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sstevr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/sstevx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssycon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssycon_3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssycon_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssyconv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssyconvf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssyconvf_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssyequb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssyev.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssyev_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssyevd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssyevd_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssyevr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssyevr_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssyevx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssyevx_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssygs2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssygst.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssygv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssygv_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssygvd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssygvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssyrfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssyrfsx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssysv.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssysv_aa.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssysv_aa_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssysv_rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssysv_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssysvx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssysvxx.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssyswapr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytd2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytf2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytf2_rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytf2_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytrd.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytrd_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytrd_sb2st.F": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytrd_sy2sb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytrf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytrf_aa.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytrf_aa_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytrf_rk.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytrf_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytri2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytri2x.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytri_3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytri_3x.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytri_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytrs2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytrs_3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytrs_aa.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytrs_aa_2stage.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/ssytrs_rook.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stbcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stbrfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stbtrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stfsm.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stftri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stfttp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stfttr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stgevc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stgex2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stgexc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stgsen.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stgsja.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stgsna.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stgsy2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stgsyl.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stpcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stplqt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stplqt2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stpmlqt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stpmqrt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stpqrt.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stpqrt2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stprfb.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stprfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stptri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stptrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stpttf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stpttr.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/strcon.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/strevc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/strevc3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/strexc.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/strrfs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/strsen.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/strsna.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/strsyl.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/strsyl3.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/strti2.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/strtri.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/strtrs.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/strttf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/strttp.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/stzrzf.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/xerbla.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/xerbla_array.f": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/zbbcsd.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zbdsqr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zcgesv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zcposv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zdrscl.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zgbbrd.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zgbcon.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zgbequ.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zgbequb.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zgbrfs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zgbrfsx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zgbsv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zgbsvx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zgbsvxx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zgbtf2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zgbtrf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zgbtrs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zgebak.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zgebal.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zgebd2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zgebrd.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zgecon.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zgedmd.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/zgedmdq.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "lapack/zgeequ.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zgeequb.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zgees.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zgeesx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zgeev.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zgeevx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zgehd2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgehrd.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgejsv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zgelq.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgelq2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgelqf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgelqt.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgelqt3.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zgels.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgelsd.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgelss.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgelst.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgelsy.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgemlq.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zgemlqt.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zgemqr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zgemqrt.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zgeql2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgeqlf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgeqp3.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgeqp3rk.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgeqr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgeqr2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgeqr2p.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgeqrf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgeqrfp.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgeqrt.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgeqrt2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zgeqrt3.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zgerfs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zgerfsx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zgerq2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgerqf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgesc2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zgesdd.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zgesv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zgesvd.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zgesvdq.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zgesvdx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zgesvj.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgesvx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zgesvxx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zgetc2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zgetf2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zgetrf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zgetrf2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zgetri.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zgetrs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zgetsls.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zgetsqrhrt.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zggbak.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zggbal.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zgges.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 7 + } + ] + }, + "lapack/zgges3.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 7 + } + ] + }, + "lapack/zggesx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 7 + } + ] + }, + "lapack/zggev.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 7 + } + ] + }, + "lapack/zggev3.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 7 + } + ] + }, + "lapack/zggevx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 7 + } + ] + }, + "lapack/zggglm.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 6 + } + ] + }, + "lapack/zgghd3.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zgghrd.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zgglse.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 6 + } + ] + }, + "lapack/zggqrf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zggrqf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zggsvd3.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 6 + } + ] + }, + "lapack/zggsvp3.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 7 + } + ] + }, + "lapack/zgsvj0.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zgsvj1.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zgtcon.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zgtrfs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 10 + } + ] + }, + "lapack/zgtsv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zgtsvx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 10 + } + ] + }, + "lapack/zgttrf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zgttrs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zgtts2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zhb2st_kernels.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zhbev.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhbev_2stage.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhbevd.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhbevd_2stage.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhbevx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zhbevx_2stage.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zhbgst.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zhbgv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zhbgvd.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zhbgvx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zhbtrd.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhecon.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zhecon_3.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhecon_rook.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zheequb.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zheev.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zheev_2stage.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zheevd.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zheevd_2stage.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zheevr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zheevr_2stage.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zheevx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zheevx_2stage.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhegs2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zhegst.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zhegv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhegv_2stage.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhegvd.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhegvx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zherfs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zherfsx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zhesv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhesv_aa.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhesv_aa_2stage.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zhesv_rk.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zhesv_rook.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhesvx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zhesvxx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zheswapr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zhetd2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zhetf2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zhetf2_rk.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zhetf2_rook.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zhetrd.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhetrd_2stage.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zhetrd_hb2st.F": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhetrd_he2hb.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zhetrf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zhetrf_aa.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zhetrf_aa_2stage.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhetrf_rk.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhetrf_rook.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zhetri.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zhetri2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zhetri2x.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zhetri_3.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhetri_3x.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhetri_rook.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zhetrs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zhetrs2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhetrs_3.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhetrs_aa.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhetrs_aa_2stage.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhetrs_rook.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zhfrk.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zhgeqz.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 7 + } + ] + }, + "lapack/zhpcon.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zhpev.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhpevd.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhpevx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zhpgst.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zhpgv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zhpgvd.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zhpgvx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zhprfs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zhpsv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zhpsvx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zhptrd.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zhptrf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zhptri.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zhptrs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zhsein.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zhseqr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zla_gbamv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zla_gbrcond_c.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zla_gbrcond_x.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zla_gbrfsx_extended.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 7 + } + ] + }, + "lapack/zla_gbrpvgrw.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zla_geamv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zla_gercond_c.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zla_gercond_x.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zla_gerfsx_extended.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 7 + } + ] + }, + "lapack/zla_gerpvgrw.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zla_heamv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zla_hercond_c.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zla_hercond_x.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zla_herfsx_extended.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 7 + } + ] + }, + "lapack/zla_herpvgrw.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zla_lin_berr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zla_porcond_c.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zla_porcond_x.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zla_porfsx_extended.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 7 + } + ] + }, + "lapack/zla_porpvgrw.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zla_syamv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zla_syrcond_c.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zla_syrcond_x.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zla_syrfsx_extended.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 7 + } + ] + }, + "lapack/zla_syrpvgrw.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zla_wwaddw.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zlabrd.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zlacgv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlacn2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zlacon.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zlacp2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlacpy.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zlacrm.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zlacrt.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zladiv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zlaed0.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zlaed7.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zlaed8.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zlaein.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zlaesy.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 8 + } + ] + }, + "lapack/zlaev2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zlag2c.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlags2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zlagtm.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zlahef.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zlahef_aa.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zlahef_rk.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zlahef_rook.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zlahqr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zlahr2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zlaic1.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zlals0.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zlalsa.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zlalsd.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zlamswlq.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zlamtsqr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zlangb.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlange.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlangt.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zlanhb.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlanhe.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlanhf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlanhp.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlanhs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlanht.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlansb.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlansp.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlansy.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlantb.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlantp.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlantr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlapll.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zlapmr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlapmt.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlaqgb.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlaqge.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlaqhb.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlaqhe.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlaqhp.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlaqp2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zlaqp2rk.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zlaqp3rk.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zlaqps.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zlaqr0.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zlaqr1.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zlaqr2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 7 + } + ] + }, + "lapack/zlaqr3.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 7 + } + ] + }, + "lapack/zlaqr4.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zlaqr5.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 7 + } + ] + }, + "lapack/zlaqsb.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlaqsp.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlaqsy.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlaqz0.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 7 + } + ] + }, + "lapack/zlaqz1.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zlaqz2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 9 + } + ] + }, + "lapack/zlaqz3.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 9 + } + ] + }, + "lapack/zlar1v.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlar2v.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zlarcm.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zlarf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zlarf1f.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zlarf1l.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zlarfb.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zlarfb_gett.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zlarfg.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zlarfgp.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zlarft.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zlarfx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zlarfy.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zlargv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zlarnv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlarrv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlarscl2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlartg.f90": { + "wrappable": false, + "status": "semantic_error", + "messages": [ + "Unsupported Fortran semantic type for variable 'f': complex(kind=wp)" + ], + "blockers": [ + { + "code": "semantic_conversion_error", + "message": "Unsupported Fortran semantic type for variable 'f': complex(kind=wp)", + "n_items": 0 + } + ] + }, + "lapack/zlartv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zlarz.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zlarzb.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zlarzt.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zlascl.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlascl2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlaset.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zlasr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlassq.f90": { + "wrappable": false, + "status": "semantic_error", + "messages": [ + "Unsupported Fortran semantic type for variable 'x': complex(kind=wp)" + ], + "blockers": [ + { + "code": "semantic_conversion_error", + "message": "Unsupported Fortran semantic type for variable 'x': complex(kind=wp)", + "n_items": 0 + } + ] + }, + "lapack/zlaswlq.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zlaswp.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlasyf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zlasyf_aa.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zlasyf_rk.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zlasyf_rook.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zlat2c.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlatbs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zlatdf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zlatps.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zlatrd.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zlatrs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zlatrs3.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zlatrz.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zlatsqr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zlaunhr_col_getrfnp.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zlaunhr_col_getrfnp2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zlauu2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zlauum.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zpbcon.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zpbequ.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zpbrfs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zpbstf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zpbsv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zpbsvx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zpbtf2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zpbtrf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zpbtrs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zpftrf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zpftri.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zpftrs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zpocon.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zpoequ.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zpoequb.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zporfs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zporfsx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zposv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zposvx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zposvxx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zpotf2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zpotrf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zpotrf2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zpotri.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zpotrs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zppcon.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zppequ.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zpprfs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zppsv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zppsvx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zpptrf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zpptri.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zpptrs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zpstf2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zpstrf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zptcon.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zpteqr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zptrfs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zptsv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zptsvx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zpttrf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zpttrs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zptts2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zrot.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zrscl.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zspcon.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zspmv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zspr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zsprfs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zspsv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zspsvx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zsptrf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zsptri.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zsptrs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zstedc.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zstegr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zstein.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zstemr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zsteqr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zsycon.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zsycon_3.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zsycon_rook.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zsyconv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zsyconvf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zsyconvf_rook.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zsyequb.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zsymv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zsyr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zsyrfs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zsyrfsx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zsysv.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zsysv_aa.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zsysv_aa_2stage.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zsysv_rk.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zsysv_rook.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zsysvx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zsysvxx.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zsyswapr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zsytf2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zsytf2_rk.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zsytf2_rook.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/zsytrf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zsytrf_aa.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zsytrf_aa_2stage.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zsytrf_rk.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zsytrf_rook.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zsytri.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zsytri2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zsytri2x.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zsytri_3.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zsytri_3x.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zsytri_rook.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zsytrs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/zsytrs2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zsytrs_3.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zsytrs_aa.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zsytrs_aa_2stage.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zsytrs_rook.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/ztbcon.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/ztbrfs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/ztbtrs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/ztfsm.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/ztftri.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/ztfttp.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/ztfttr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/ztgevc.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/ztgex2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/ztgexc.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/ztgsen.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 7 + } + ] + }, + "lapack/ztgsja.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 6 + } + ] + }, + "lapack/ztgsna.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/ztgsy2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 6 + } + ] + }, + "lapack/ztgsyl.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 7 + } + ] + }, + "lapack/ztpcon.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/ztplqt.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/ztplqt2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/ztpmlqt.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/ztpmqrt.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/ztpqrt.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/ztpqrt2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/ztprfb.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/ztprfs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/ztptri.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/ztptrs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/ztpttf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/ztpttr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/ztrcon.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/ztrevc.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/ztrevc3.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/ztrexc.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/ztrrfs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/ztrsen.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/ztrsna.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/ztrsyl.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/ztrsyl3.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/ztrti2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/ztrtri.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 1 + } + ] + }, + "lapack/ztrtrs.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/ztrttf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/ztrttp.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 2 + } + ] + }, + "lapack/ztzrzf.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zunbdb.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 9 + } + ] + }, + "lapack/zunbdb1.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 6 + } + ] + }, + "lapack/zunbdb2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 6 + } + ] + }, + "lapack/zunbdb3.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 6 + } + ] + }, + "lapack/zunbdb4.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 7 + } + ] + }, + "lapack/zunbdb5.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zunbdb6.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + } + ] + }, + "lapack/zuncsd.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 9 + } + ] + }, + "lapack/zuncsd2by1.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 6 + } + ] + }, + "lapack/zung2l.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zung2r.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zungbr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zunghr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zungl2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zunglq.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zungql.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zungqr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zungr2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zungrq.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zungtr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zungtsqr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zungtsqr_row.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zunhr_col.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zunm22.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + } + ] + }, + "lapack/zunm2l.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zunm2r.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zunmbr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zunmhr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zunml2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zunmlq.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zunmql.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zunmqr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zunmr2.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zunmr3.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zunmrq.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zunmrz.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zunmtr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zupgtr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "lapack/zupmtr.f": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 4 + } + ] + }, + "scifortran/01_sf_fft_fftpack.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 0, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/01_sf_interpolate_interp.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 0, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/01_sf_optimize_fsolve.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 0, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/01_test_io_arrays.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 0, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/01_test_sf_arrays.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 0, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/01_test_sf_colors.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 0, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/01_test_sf_constants.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 0, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/01_test_sf_derivate_deriv.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 0, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/01_test_sf_fonts.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 0, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/01_test_sf_integrate_quad.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 0, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/01_test_sf_parsing.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 0, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/01_test_sf_spin.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 0, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/01_test_sf_timer.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 0, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/02_sf_optimize_leastsq.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 0, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/02_test_sf_derivate_fdjac.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 0, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/02_test_sf_integrate_gauss.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 0, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/02_test_sf_misc.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 0, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/03_sf_optimize_curvefit.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 0, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/04_sf_optimize_cgfit.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 0, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/ASSERTING.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/FFT_FFTPACK.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 30, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 16 + } + ] + }, + "scifortran/GAUSS_QUADRATURE.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/IOFILE.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 21, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/IOPLOT.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/IOREAD.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/LIST_INPUT.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 4, + "n_classes": 1, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/MOD_QUADPACK.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/SCIFOR.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/SF_ARRAYS.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 6, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 4 + } + ] + }, + "scifortran/SF_BLACS.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 10, + "n_classes": 0, + "n_variables": 6, + "messages": [], + "blockers": [] + }, + "scifortran/SF_COLORS.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 8, + "n_classes": 1, + "n_variables": 657, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 2 + } + ] + }, + "scifortran/SF_CONSTANTS.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 12, + "n_classes": 0, + "n_variables": 96, + "messages": [], + "blockers": [] + }, + "scifortran/SF_DERIVATE.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 6, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 12 + } + ] + }, + "scifortran/SF_FFT.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 30, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 8 + } + ] + }, + "scifortran/SF_FONTS.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 16, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/SF_INTEGRATE.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/SF_INTERPOLATE.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 0, + "n_classes": 2, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/SF_IOTOOLS.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/SF_LINALG.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/SF_MISC.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/SF_MPI.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 19, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/SF_OPTIMIZE.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/SF_PARSE_INPUT.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/SF_RANDOM.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 4, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/SF_SPARSE.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/SF_SPARSE_ARRAY_ALGEBRA.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 8, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 24 + } + ] + }, + "scifortran/SF_SPARSE_ARRAY_COO.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 8, + "n_classes": 2, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/SF_SPARSE_ARRAY_CSC.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 0, + "n_classes": 2, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/SF_SPARSE_ARRAY_CSR.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 0, + "n_classes": 2, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/SF_SPARSE_COMMON.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 6, + "n_classes": 1, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 2 + } + ] + }, + "scifortran/SF_SPECIAL.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 6, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/SF_SPIN.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/SF_SP_LINALG.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/SF_STAT.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 7, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 6 + } + ] + }, + "scifortran/SF_TIMER.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 6, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/adaptive_mix.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 4 + } + ] + }, + "scifortran/arpack_c.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 1 + }, + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 2 + } + ] + }, + "scifortran/arpack_d.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 1 + }, + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 2 + } + ] + }, + "scifortran/brent.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 6, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 8 + } + ] + }, + "scifortran/broyden1.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 1 + } + ] + }, + "scifortran/broyden_mix.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 8 + } + ] + }, + "scifortran/c1f2kb.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/c1f2kf.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/c1f3kb.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/c1f3kf.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/c1f4kb.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/c1f4kf.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/c1f5kb.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/c1f5kf.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/c1fgkb.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/c1fgkf.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/c1fm1b.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/c1fm1f.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cfft1b.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cfft1f.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cfft1i.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cfft2b.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cfft2f.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cfft2i.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cfftmb.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cfftmf.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cfftmi.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/chkder.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cmf2kb.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cmf2kf.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cmf3kb.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cmf3kf.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cmf4kb.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cmf4kf.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cmf5kb.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cmf5kf.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cmfgkb.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cmfgkf.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cmfm1b.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cmfm1f.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cosq1b.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cosq1f.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cosq1i.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cosqb1.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cosqf1.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cosqmb.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cosqmf.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cosqmi.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cost1b.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cost1f.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/cost1i.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/costb1.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/costf1.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/costmb.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/costmf.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/costmi.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/curvefit.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 4, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 6 + }, + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 8 + } + ] + }, + "scifortran/derivate_fjacobian_c.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 12, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 12 + }, + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 32 + } + ] + }, + "scifortran/derivate_fjacobian_d.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 12, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 12 + }, + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 32 + } + ] + }, + "scifortran/dogleg.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/dvdson_serial.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 1 + } + ] + }, + "scifortran/enorm.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/enorm2.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/fdjac1.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 1 + } + ] + }, + "scifortran/fdjac2.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 1 + } + ] + }, + "scifortran/fmin_Nelder_Mead.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 1 + }, + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 2 + } + ] + }, + "scifortran/fmin_bfgs.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 3 + } + ] + }, + "scifortran/fmin_cg.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 3, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 3 + }, + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 2 + } + ] + }, + "scifortran/fmin_cg_cgplus.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 3, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 3 + }, + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 2 + } + ] + }, + "scifortran/fmin_cg_minimize.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 3, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 2 + } + ] + }, + "scifortran/froot_scalar.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 5, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 5 + } + ] + }, + "scifortran/fsolve.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 4, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 6 + } + ] + }, + "scifortran/functions_bethe.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 5, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/functions_wofz.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/functions_zerf.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/histogram.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 9, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 8 + } + ] + }, + "scifortran/hybrd.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 1 + } + ] + }, + "scifortran/hybrd1.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 1 + } + ] + }, + "scifortran/hybrj.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 1 + } + ] + }, + "scifortran/hybrj1.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 1 + } + ] + }, + "scifortran/icbacn.F90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/icbadn.F90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/icbads.F90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/icbasn.F90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/icbass.F90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/icbazn.F90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/icbpcn.F90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/icbpdn.F90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/icbpds.F90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/icbpsn.F90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/icbpss.F90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/icbpzn.F90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/integrate_func_1d.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 8, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 8 + } + ] + }, + "scifortran/integrate_func_2d.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 8, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 8 + } + ] + }, + "scifortran/integrate_quad_func.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 1 + } + ] + }, + "scifortran/integrate_quad_sample.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/integrate_sample_1d.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 12, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 8 + } + ] + }, + "scifortran/integrate_sample_2d.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 4, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/interpolate_cubspl_routines.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 3, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/interpolate_finter_1d.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 5, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports.", + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 5 + }, + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 8 + } + ] + }, + "scifortran/interpolate_finter_2d.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 3, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports.", + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 3 + }, + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 8 + } + ] + }, + "scifortran/interpolate_nr.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 3, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/interpolate_pack.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 20, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/interpolate_pppack.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 41, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 4 + } + ] + }, + "scifortran/ioplot_3d.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 4, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 8 + } + ] + }, + "scifortran/ioplot_M.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 12, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 116 + } + ] + }, + "scifortran/ioplot_P.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 6, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/ioplot_V.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 6, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 80 + } + ] + }, + "scifortran/ioplot_data.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 9, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 18 + } + ] + }, + "scifortran/ioplot_save_array.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 16, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/ioplot_splot.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 14, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 28 + } + ] + }, + "scifortran/ioplot_splot3d.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 4, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 8 + } + ] + }, + "scifortran/ioread_M.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 12, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 116 + } + ] + }, + "scifortran/ioread_P.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 6, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/ioread_V.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 6, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 80 + } + ] + }, + "scifortran/ioread_data.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 9, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 12 + } + ] + }, + "scifortran/ioread_read_array.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 16, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/ioread_sread.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 14, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 28 + } + ] + }, + "scifortran/kernel_density_1d.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 21, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 20 + } + ] + }, + "scifortran/kernel_density_2d.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 13, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some semantic type references are not declared by the .pyi interface or its imports.", + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Some semantic type references are not declared by the .pyi interface or its imports.", + "n_items": 12 + }, + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 4 + } + ] + }, + "scifortran/lanczos_c.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 3, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 3 + }, + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 4 + } + ] + }, + "scifortran/lanczos_d.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 3, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 3 + }, + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 4 + } + ] + }, + "scifortran/leastsq.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 4, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 6 + } + ] + }, + "scifortran/linalg_auxiliary.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 26, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 4 + } + ] + }, + "scifortran/linalg_blacs_aux.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 4, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/linalg_blas.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 4, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 8 + } + ] + }, + "scifortran/linalg_build_tridiag.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 4, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 16 + } + ] + }, + "scifortran/linalg_check_tridiag.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 4, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/linalg_eig.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/linalg_eigh.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 5, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 10 + } + ] + }, + "scifortran/linalg_eigh_jacobi.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 18 + } + ] + }, + "scifortran/linalg_eigvals.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 4 + } + ] + }, + "scifortran/linalg_eigvalsh.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 4 + } + ] + }, + "scifortran/linalg_external_products.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 13, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 28 + } + ] + }, + "scifortran/linalg_get_tridiag.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 4, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 12 + } + ] + }, + "scifortran/linalg_inv.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/linalg_inv_gj.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 8, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/linalg_inv_her.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/linalg_inv_sym.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/linalg_inv_triang.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/linalg_inv_tridiag.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 8, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/linalg_lstsq.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/linalg_p_blas.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 4, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 12 + } + ] + }, + "scifortran/linalg_p_eigh.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 4 + } + ] + }, + "scifortran/linalg_p_inv.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/linalg_solve.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 4, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/linalg_svd.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/linalg_svdvals.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/linear_mix.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 14, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 112 + } + ] + }, + "scifortran/lmder.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 1 + } + ] + }, + "scifortran/lmder1.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 1 + } + ] + }, + "scifortran/lmdif.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 1 + } + ] + }, + "scifortran/lmdif1.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 1 + } + ] + }, + "scifortran/lmpar.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/lmstr.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 1 + } + ] + }, + "scifortran/lmstr1.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 1 + } + ] + }, + "scifortran/mcsqb1.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/mcsqf1.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/mcstb1.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/mcstf1.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/mpi_bcast.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 32, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/mpi_lanczos_c.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 3, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 3 + }, + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 4 + } + ] + }, + "scifortran/mpi_lanczos_d.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 3, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 3 + }, + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 4 + } + ] + }, + "scifortran/mradb2.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/mradb3.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/mradb4.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/mradb5.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/mradbg.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/mradf2.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/mradf3.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/mradf4.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/mradf5.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/mradfg.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/mrftb1.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/mrftf1.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/mrfti1.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/msntb1.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/msntf1.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/optimize_broyden_routines.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 2, + "n_functions": 16, + "n_classes": 0, + "n_variables": 3, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 2 + }, + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 10 + } + ] + }, + "scifortran/optimize_cgfit_routines.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 9, + "n_classes": 0, + "n_variables": 5, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 6 + } + ] + }, + "scifortran/parpack_c.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 1 + }, + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 2 + } + ] + }, + "scifortran/parpack_d.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "callback_signature_incomplete", + "message": "Some callback or procedure arguments need complete Callable[[...], ...] metadata in the .pyi file.", + "n_items": 1 + }, + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 2 + } + ] + }, + "scifortran/qform.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/qrfac.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/qrsolv.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/quadpack_aux.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 19, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/quadpack_qag.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/quadpack_qagi.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/quadpack_qagp.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/quadpack_qags.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/quadpack_qawc.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/quadpack_qawf.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/quadpack_qawo.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/quadpack_qaws.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 2, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/quadpack_qng.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/r1f2kb.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/r1f2kf.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/r1f3kb.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/r1f3kf.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/r1f4kb.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/r1f4kf.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/r1f5kb.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/r1f5kf.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/r1fgkb.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/r1fgkf.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/r1mpyq.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/r1updt.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/r2w.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/r8_factor.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/r8_mcfti1.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/r8_tables.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/r8vec_print.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/random_mt.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 35, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/random_routines.f90": { + "wrappable": false, + "status": "semantic_error", + "messages": [ + "Unsupported Fortran semantic type for variable 'x': real(kind=dp)" + ], + "blockers": [ + { + "code": "semantic_conversion_error", + "message": "Unsupported Fortran semantic type for variable 'x': real(kind=dp)", + "n_items": 0 + } + ] + }, + "scifortran/rfft1b.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/rfft1f.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/rfft1i.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/rfft2b.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/rfft2f.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/rfft2i.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/rfftb1.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/rfftf1.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/rffti1.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/rfftmb.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/rfftmf.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/rfftmi.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/rwupdt.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/sinq1b.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/sinq1f.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/sinq1i.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/sinqmb.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/sinqmf.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/sinqmi.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/sint1b.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/sint1f.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/sint1i.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/sintb1.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/sintf1.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/sintmb.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/sintmf.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/sintmi.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/special_functions.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 1, + "n_functions": 165, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "Some shape expressions refer to symbols not supplied by the semantic interface." + ], + "blockers": [ + { + "code": "unresolved_shape_symbols", + "message": "Some shape expressions refer to symbols not supplied by the semantic interface.", + "n_items": 4 + } + ] + }, + "scifortran/src__SF_IOTOOLS__.old__ioread_control.f90": { + "wrappable": false, + "status": "ok", + "n_modules": 0, + "n_functions": 0, + "n_classes": 0, + "n_variables": 0, + "messages": [ + "The semantic interface does not declare any public wrapper API." + ], + "blockers": [ + { + "code": "no_public_api", + "message": "The semantic interface does not declare any public wrapper API.", + "n_items": 1 + } + ] + }, + "scifortran/src__SF_IOTOOLS__ioread_control.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/timestamp.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/w2r.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/xercon.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + }, + "scifortran/xerfft.f90": { + "wrappable": true, + "status": "ok", + "n_modules": 1, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "messages": [], + "blockers": [] + } + } +} diff --git a/tests/semantics/generate_wrap_readiness_fixtures.py b/tests/semantics/generate_wrap_readiness_fixtures.py new file mode 100644 index 000000000..fc7efb6fd --- /dev/null +++ b/tests/semantics/generate_wrap_readiness_fixtures.py @@ -0,0 +1,16 @@ +"""Generate semantic wrap-readiness message fixtures for Fortran corpora.""" + +import sys +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parents[2])) + +from tests._shared.fixture_outputs import write_wrap_readiness_message_fixture + + +def main() -> None: + print(f"updated {write_wrap_readiness_message_fixture()}") + + +if __name__ == "__main__": + main() diff --git a/tests/semantics/test_semantic_wrap_readiness.py b/tests/semantics/test_semantic_wrap_readiness.py index 221253868..e0c0cc8c4 100644 --- a/tests/semantics/test_semantic_wrap_readiness.py +++ b/tests/semantics/test_semantic_wrap_readiness.py @@ -5,6 +5,10 @@ from semantics.pyi_parser import parse_pyi_text from semantics.readiness import assess_semantic_wrap_readiness +from x2py import cli as x2py_cli + + +TEST_FILE = Path(__file__).parent.parent / "data" / "fortran" / "general" / "basic_subroutine.f90" def _readiness_from_pyi(source: str): @@ -170,3 +174,72 @@ def test_cli_wrap_readiness_json_loads_pyi(tmp_path: Path): assert payload[str(pyi)]["source_kind"] == "pyi" assert payload[str(pyi)]["wrap_readiness"]["wrappable"] is True + + +def test_cli_wrap_readiness_output_from_fortran(): + cmd = [sys.executable, "-m", "x2py", str(TEST_FILE), "--wrap-readiness"] + res = subprocess.run(cmd, capture_output=True, text=True, check=True) + assert f"File: {TEST_FILE}" in res.stdout + assert "Source: fortran" in res.stdout + assert "Wrappable: yes" in res.stdout + assert "No semantic readiness blockers detected." in res.stdout + assert "Modules:" not in res.stdout + + +def test_cli_wrap_readiness_json_output_from_fortran(): + cmd = [sys.executable, "-m", "x2py", str(TEST_FILE), "--wrap-readiness", "--json"] + res = subprocess.run(cmd, capture_output=True, text=True, check=True) + payload = json.loads(res.stdout) + assert payload[str(TEST_FILE)]["source_kind"] == "fortran" + assert payload[str(TEST_FILE)]["wrap_readiness"]["wrappable"] is True + + +def test_cli_parse_can_print_semantic_wrap_readiness(): + cmd = [sys.executable, "-m", "x2py", str(TEST_FILE), "--parse", "--wrap-readiness"] + res = subprocess.run(cmd, capture_output=True, text=True, check=True) + assert "subroutine add1" in res.stdout + assert "Source: fortran" in res.stdout + assert "Wrappable: yes" in res.stdout + + +def test_cli_parse_wrap_readiness_json_keeps_stage_payloads_separate(): + cmd = [sys.executable, "-m", "x2py", str(TEST_FILE), "--parse", "--wrap-readiness", "--json"] + res = subprocess.run(cmd, capture_output=True, text=True, check=True) + payload = json.loads(res.stdout) + assert str(TEST_FILE) in payload["parse"] + assert "wrap_readiness" not in payload["parse"][str(TEST_FILE)] + assert payload["wrap_readiness"][str(TEST_FILE)]["wrap_readiness"]["wrappable"] is True + + +def test_cli_semantics_can_include_semantic_wrap_readiness(): + cmd = [sys.executable, "-m", "x2py", str(TEST_FILE), "--semantics", "--wrap-readiness"] + res = subprocess.run(cmd, capture_output=True, text=True, check=True) + payload = json.loads(res.stdout) + assert payload[str(TEST_FILE)]["semantic_modules"] + assert payload[str(TEST_FILE)]["wrap_readiness"]["wrappable"] is True + + +def test_cli_help_includes_semantic_wrap_readiness_examples(): + cmd = [sys.executable, "-m", "x2py", "--help"] + res = subprocess.run(cmd, capture_output=True, text=True, check=True) + assert "python -m x2py path/to/file.f90 --wrap-readiness" in res.stdout + assert "python -m x2py path/to/file.f90 --semantics --wrap-readiness" in res.stdout + assert "python -m x2py path/to/module.pyi --wrap-readiness" in res.stdout + + +def test_x2py_main_wrap_readiness_mode_from_inline_source(tmp_path: Path, monkeypatch, capsys): + f90 = tmp_path / "mini.f90" + f90.write_text( + """module m +contains + subroutine work(n) + integer, intent(in) :: n + end subroutine work +end module m +""", + encoding="utf-8", + ) + + monkeypatch.setattr(sys, "argv", ["x2py", str(f90), "--wrap-readiness"]) + assert x2py_cli.main() == 0 + assert "Wrappable: yes" in capsys.readouterr().out diff --git a/tests/semantics/test_wrap_readiness_fixture_suite.py b/tests/semantics/test_wrap_readiness_fixture_suite.py new file mode 100644 index 000000000..cb4c23613 --- /dev/null +++ b/tests/semantics/test_wrap_readiness_fixture_suite.py @@ -0,0 +1,22 @@ +import json + +from tests._shared.fixture_outputs import ( + SEMANTIC_READINESS_FIXTURE_PATH, + iter_wrap_readiness_fortran_fixtures, + readiness_fixture_key, + wrap_readiness_message_payload_for_corpus, +) + + +def test_wrap_readiness_fixture_suite_has_corpus_files(): + files = iter_wrap_readiness_fortran_fixtures() + assert files, "No Fortran corpus files found for semantic readiness fixtures" + keys = {readiness_fixture_key(path) for path in files} + assert any(key.startswith("blas/") for key in keys) + assert any(key.startswith("lapack/") for key in keys) + assert any(key.startswith("scifortran/") for key in keys) + + +def test_wrap_readiness_fixture_matches_fortran_corpus(): + expected = json.loads(SEMANTIC_READINESS_FIXTURE_PATH.read_text(encoding="utf-8")) + assert wrap_readiness_message_payload_for_corpus() == expected diff --git a/x2py/__init__.py b/x2py/__init__.py index 4f1b7e73e..f6ad8819a 100644 --- a/x2py/__init__.py +++ b/x2py/__init__.py @@ -13,7 +13,7 @@ FortranProject, FortranSubmodule, ) -from fortran_parser.parser import assess_wrap_readiness, parse_fortran_file, parse_fortran_project +from fortran_parser.parser import parse_fortran_file, parse_fortran_project from semantics.fortran2ir import ( collect_semantic_compile_time_requirements, fortran_file_to_semantic_modules, @@ -39,7 +39,6 @@ "FortranSubmodule", "assess_pyi_wrap_readiness", "assess_semantic_wrap_readiness", - "assess_wrap_readiness", "collect_semantic_compile_time_requirements", "convert_pyi_to_ir", "fortran_file_to_semantic_modules", diff --git a/x2py/cli.py b/x2py/cli.py index f03c6008d..82dac6185 100644 --- a/x2py/cli.py +++ b/x2py/cli.py @@ -314,7 +314,6 @@ def main() -> int: parse_payload = _parse_report(args.paths) if args.parse else None semantic_payload = _semantic_report(args.paths) if (args.semantics or args.pyi) else None readiness_payload = _wrap_readiness_report(args.paths) if args.wrap_readiness else None - _attach_wrap_readiness(parse_payload, readiness_payload) _attach_wrap_readiness(semantic_payload, readiness_payload) except FortranParseError as exc: if args.debug_traceback or _env_flag("FORTRAN_PARSER_DEBUG"): @@ -327,7 +326,12 @@ def main() -> int: print(f"x2py: error: {exc}", file=sys.stderr) return 1 - if args.parse: + if args.parse and args.wrap_readiness and (args.json or args.out is not None): + payload = { + "parse": parse_payload or {}, + "wrap_readiness": readiness_payload or {}, + } + elif args.parse: payload = parse_payload or {} elif args.semantics or args.pyi: payload = semantic_payload or {} From 36dec35fc92e32d764786b858e5b89b6f587eb26 Mon Sep 17 00:00:00 2001 From: said Date: Thu, 21 May 2026 07:12:13 +0100 Subject: [PATCH 4/4] codex: update parser readiness reference --- parser_implementation_reference.md | 98 ++++++----- .../semantics/test_semantic_wrap_readiness.py | 156 ++++++++++++++++-- 2 files changed, 205 insertions(+), 49 deletions(-) diff --git a/parser_implementation_reference.md b/parser_implementation_reference.md index ff22c7486..ea416d50b 100644 --- a/parser_implementation_reference.md +++ b/parser_implementation_reference.md @@ -14,8 +14,8 @@ another source language. - Parse multi-file projects with dependency-aware ordering. - Resolve compile-time symbols used in type kinds and array shapes, both local and cross-file via imported modules. -- Produce wrap-readiness diagnostics (`unsupported_constructs`, unknown - argument declarations, aggregate wrappable boolean, and unit-scoped blockers). +- Keep parser output parse-only. Wrap-readiness is assessed after conversion to + semantic IR, either from parsed Fortran or from an edited `.pyi` interface. - Provide CLI output in both human-readable tree form and JSON form. ## 2) Language coverage actually implemented @@ -87,11 +87,10 @@ another source language. Numeric, symbolic, and expression-like kind tokens are preserved when the declaration grammar can recognize the surrounding datatype. This is not "any datatype"; unknown base datatypes still fail fast as unsupported declarations. -- Symbolic kind/length references are validated generically for wrap readiness: - they must be local parameters, module parameters, resolved from parsed - `use`-associated module parameters, or explicitly visible through an - intrinsic kind module such as `iso_c_binding` or `iso_fortran_env`. Intrinsic - kind names are not globally accepted without a visible `use` import. +- Symbolic kind/length references are preserved and resolved where the parser + has enough local, module, or project context. Remaining syntactically valid + symbols are carried forward for semantic conversion/readiness instead of + becoming parser JSON readiness fields. ### 2.4 Compile-time symbol and expression resolution @@ -108,7 +107,7 @@ another source language. - Procedure-local parameter expressions can be folded into argument shapes during procedure finalization. Module-level and `use`-associated parameters used in procedure argument shapes remain symbolic in the signature while - still being considered valid scope references for readiness diagnostics. + still being visible to downstream semantic conversion/readiness. - Module/program variable parameter values, character lengths, and shapes are resolved through the same cached compile-time resolver where safe. - The resolver caches symbol and expression results per scope and evaluates a @@ -159,22 +158,30 @@ another source language. - Submodule procedure implementations recognized via `module subroutine/function` and `module procedure`. - Main `program` and `block data` units are parsed into dedicated model objects. -### 2.9 Wrap-readiness analysis - -- Unsupported construct patterns explicitly scanned: - - assumed-type polymorphic `class(*)` - - `select type` - - coarray forms - - `procedure, pointer` - - `type(c_ptr)` -- Unknown argument declaration tracking (`base_type == "unknown"`). -- Summary report fields: - - `n_signatures`, `n_types`, `n_modules`, `n_submodules`, `n_programs`, `n_block_data` - - `unsupported_constructs` - - `unknown_argument_types` - - `unit_blockers` with records only for procedure/derived-type/file units - that own blockers. Unit records do not carry a ready-to-wrap flag. - - `wrappable` +### 2.9 Parser/semantic readiness boundary + +- The parser no longer owns wrap-readiness. +- `FortranParser` does not expose `visit_wrap_readiness(...)`. +- `fortran_parser.parser` does not expose `assess_wrap_readiness(...)`. +- Parser JSON does not contain `wrap_readiness`, `wrappable`, + `wrappability_blockers`, `unit_blockers`, `unsupported_constructs`, or + `unknown_argument_types` readiness payloads. +- Parser responsibility ends at producing typed parse models and parse-stage + diagnostics such as `FortranParseError`. +- Readiness is a semantic feature: + - For Fortran input, `x2py --wrap-readiness` parses the source, converts the + parsed model to semantic IR, and assesses that semantic interface. + - For `.pyi` input, `x2py --wrap-readiness` parses the edited stub directly to + semantic IR and assesses that interface. + - The edited `.pyi` is the source of truth when the user supplies missing + wrapper information such as imported types, compile-time constants, or + callback signatures. +- Combining `x2py --parse --wrap-readiness --json` keeps stage payloads + separate: + - top-level `parse` contains parse-only JSON + - top-level `wrap_readiness` contains semantic readiness JSON +- Combining `x2py --semantics --wrap-readiness` attaches the readiness payload to + the semantic report because both payloads are semantic-stage artifacts. ## 3) Output/data model behavior @@ -192,8 +199,8 @@ another source language. - file dependency graph - module-to-file and submodule-to-file indexes - merged modules/submodules/programs/block-data/types/signatures -- CLI JSON output emits per-file buckets for signatures, types, modules, - readiness report. +- CLI JSON output emits per-file parser buckets for signatures, types, modules, + submodules, programs, and block data. - CLI human output prints tree-like structure grouped by file/module/procedure. - Parser JSON serializes explicit `use` symbols as objects containing `source` and `target`. Bare imports still use an empty list. @@ -209,6 +216,8 @@ another source language. - Parser JSON serializes both parameter `value` and `symbolic_value`. `value` is literal/evaluated only; compiler-specific or unresolved expressions keep `value: null` and preserve the original expression in `symbolic_value`. +- Semantic readiness JSON is emitted by `x2py --wrap-readiness`, not by + `fortran_parser` parse JSON. ## 4) Test strategy implemented (current workflow) @@ -246,7 +255,7 @@ Covers, among others: - local parameter propagation into argument kinds - compile-time shape expression evaluation helpers - shape symbol collection helpers -- readiness diagnostics and unsupported detection +- parse-stage diagnostics and unsupported declaration handling ### 4.3 Fixture and corpus regression (`tests/parser/test_fortran_fixture_suite.py`) @@ -276,6 +285,10 @@ continues to validate the serialized model shape. - Semantic and `.pyi` fixture generators are separate: - `python tests/semantics/generate_semantic_fixtures.py` - `python tests/pyi/generate_pyi_fixtures.py` +- Semantic wrap-readiness message fixtures are separate from parser goldens: + - `python tests/semantics/generate_wrap_readiness_fixtures.py` + - generated output: `tests/semantics/fixtures/wrap_readiness_messages.json` + - covered corpus: `general`, `blas`, `lapack`, and `scifortran` ### 4.5 CLI tests (`tests/parser/test_cli.py`) @@ -288,6 +301,12 @@ Validates command-line behavior for: - parse-error diagnostics without tracebacks by default - developer traceback opt-in through `--debug-traceback` and `FORTRAN_PARSER_DEBUG=1` - default ANSI color for diagnostics, with `--no-color` and `NO_COLOR=1` opt-out +- parser JSON remains parse-only and does not include semantic readiness fields + +Semantic readiness CLI behavior is tested in +`tests/semantics/test_semantic_wrap_readiness.py`, including `.pyi` input, +Fortran input, combined `--parse --wrap-readiness` human output, combined JSON +stage separation, and `--semantics --wrap-readiness`. ### 4.6 Error handling tests (`tests/parser/test_error_handling.py`) @@ -353,7 +372,8 @@ ask it to implement each of these layers explicitly: 9. Interface/contract block parser. 10. Symbol resolver for local and cross-file compile-time constants. 11. Project namespace parser with dependency ordering. -12. Readiness validator with unsupported-pattern rules + unknown type checks. +12. Semantic readiness validator outside the parser, fed by semantic IR from + parsed source or `.pyi`. 13. CLI with tree output + JSON output + file emission. 14. Unit tests per feature + fixture/golden regression suite + golden regeneration script. @@ -472,8 +492,9 @@ implemented today: - **Module parameter references in contained procedure shapes**: a contained procedure argument such as `real :: x(n)` may refer to a module-level parameter `n`. The signature keeps the shape token symbolic (`"n"`) while - readiness validation treats it as a valid scoped reference. This protects - module-level parameters from being mistaken for undeclared procedure locals. + downstream semantic readiness can use the semantic compile-time metadata. This + protects module-level parameters from being mistaken for undeclared procedure + locals. - **Interface scope tracking**: procedures parsed inside `interface ... end interface` are represented separately and flagged as interface procedures. Interface-local argument declarations do not conflict with host declarations; @@ -588,9 +609,10 @@ When updating parser behavior, keep this fail-fast contract aligned with tests: For example, `module`/`interface` syntax in a `.f77` file is parsed if the fixed-form preprocessor produces valid logical lines, and legacy star-kind syntax in `.f90` is parsed when the declaration grammar recognizes it. - - Wrapper generation/readiness should decide whether a parsed feature is safe - to wrap. Parser errors should be about unsupported grammar/metadata, not - about a filename implying an older or newer language standard. + - Wrapper generation/readiness should decide from semantic IR or `.pyi` + whether a parsed feature is safe to wrap. Parser errors should be about + unsupported grammar/metadata, not about a filename implying an older or newer + language standard. - **Unknown datatype declaration (hard error):** - Procedure declarations, derived-type fields, and module-variable declarations raise `FortranParseError` when the datatype declaration is unknown/unsupported instead of silently skipping. - **Datatype and kind support is bounded by the declaration grammar:** @@ -605,9 +627,8 @@ When updating parser behavior, keep this fail-fast contract aligned with tests: statement; names such as `c_double`, `real64`, or aliases introduced through `only: local => remote` are not hard-coded as globally available. - Unresolved but syntactically valid kind symbols are not parser errors by - themselves; wrap-readiness reports them as `unresolved_kind_arguments` or - `unresolved_kind_fields` when they cannot be found in the parsed source or - imports. + themselves; semantic conversion/readiness decides whether the final interface + has enough compile-time information. - Semantic conversion is stricter than parsing: a parsed intrinsic `base_type`/`kind` pair must map to a concrete semantic type, otherwise conversion raises instead of emitting `Unknown`. Generated `.pyi` output and @@ -624,8 +645,9 @@ When updating parser behavior, keep this fail-fast contract aligned with tests: - The parser is intentionally strict about unknown declarations and internal metadata consistency, but permissive about mixed-era Fortran syntax that can be parsed unambiguously. - - "Unsupported but recognized" constructs are still surfaced via readiness - diagnostics where appropriate; unknown datatype syntax should crash early. + - "Unsupported but recognized" constructs may be carried far enough for + semantic readiness or `.pyi` completion to decide wrappability. Unknown + datatype syntax should crash early. - **Preprocessor-conditional duplicate procedures (guarded allowance):** - The parser does **not** run a full C preprocessor stage before parsing. - While slicing source units, simple directive structure is tracked for diff --git a/tests/semantics/test_semantic_wrap_readiness.py b/tests/semantics/test_semantic_wrap_readiness.py index e0c0cc8c4..1df0d754f 100644 --- a/tests/semantics/test_semantic_wrap_readiness.py +++ b/tests/semantics/test_semantic_wrap_readiness.py @@ -3,6 +3,8 @@ import sys from pathlib import Path +import pytest + from semantics.pyi_parser import parse_pyi_text from semantics.readiness import assess_semantic_wrap_readiness from x2py import cli as x2py_cli @@ -20,6 +22,20 @@ def _blocker_codes(report: dict) -> set[str]: return {blocker["code"] for blocker in report["wrappability_blockers"]} +def _write_ready_fortran(path: Path) -> Path: + path.write_text( + """module m +contains + subroutine work(n) + integer, intent(in) :: n + end subroutine work +end module m +""", + encoding="utf-8", + ) + return path + + def test_completed_pyi_interface_is_semantically_ready(): report = _readiness_from_pyi( """ @@ -228,18 +244,136 @@ def test_cli_help_includes_semantic_wrap_readiness_examples(): def test_x2py_main_wrap_readiness_mode_from_inline_source(tmp_path: Path, monkeypatch, capsys): - f90 = tmp_path / "mini.f90" - f90.write_text( - """module m -contains - subroutine work(n) - integer, intent(in) :: n - end subroutine work -end module m -""", - encoding="utf-8", - ) + f90 = _write_ready_fortran(tmp_path / "mini.f90") monkeypatch.setattr(sys, "argv", ["x2py", str(f90), "--wrap-readiness"]) assert x2py_cli.main() == 0 assert "Wrappable: yes" in capsys.readouterr().out + + +def test_x2py_main_parse_wrap_readiness_json_keeps_payloads_separate(tmp_path: Path, monkeypatch, capsys): + f90 = _write_ready_fortran(tmp_path / "mini.f90") + + monkeypatch.setattr(sys, "argv", ["x2py", str(f90), "--parse", "--wrap-readiness", "--json"]) + assert x2py_cli.main() == 0 + payload = json.loads(capsys.readouterr().out) + + assert str(f90) in payload["parse"] + assert "wrap_readiness" not in payload["parse"][str(f90)] + assert payload["wrap_readiness"][str(f90)]["wrap_readiness"]["wrappable"] is True + + +def test_x2py_main_parse_wrap_readiness_out_keeps_payloads_separate(tmp_path: Path, monkeypatch, capsys): + f90 = _write_ready_fortran(tmp_path / "mini.f90") + out = tmp_path / "report.json" + + monkeypatch.setattr(sys, "argv", ["x2py", str(f90), "--parse", "--wrap-readiness", "--out", str(out)]) + assert x2py_cli.main() == 0 + assert capsys.readouterr().out == "" + payload = json.loads(out.read_text(encoding="utf-8")) + + assert str(f90) in payload["parse"] + assert "wrap_readiness" not in payload["parse"][str(f90)] + assert payload["wrap_readiness"][str(f90)]["wrap_readiness"]["wrappable"] is True + + +def test_x2py_main_semantics_wrap_readiness_attaches_semantic_payload(tmp_path: Path, monkeypatch, capsys): + f90 = _write_ready_fortran(tmp_path / "mini.f90") + + monkeypatch.setattr(sys, "argv", ["x2py", str(f90), "--semantics", "--wrap-readiness"]) + assert x2py_cli.main() == 0 + payload = json.loads(capsys.readouterr().out) + + assert payload[str(f90)]["semantic_modules"] + assert payload[str(f90)]["wrap_readiness"]["wrappable"] is True + + +def test_x2py_main_wrap_readiness_json_directory_expands_fortran_and_pyi(tmp_path: Path, monkeypatch, capsys): + f90 = _write_ready_fortran(tmp_path / "mini.f90") + pyi = tmp_path / "solver.pyi" + pyi.write_text("def fill(n: Int32) -> None: ...\n", encoding="utf-8") + + monkeypatch.setattr(sys, "argv", ["x2py", str(tmp_path), "--wrap-readiness", "--json"]) + assert x2py_cli.main() == 0 + payload = json.loads(capsys.readouterr().out) + + assert payload[str(f90)]["source_kind"] == "fortran" + assert payload[str(pyi)]["source_kind"] == "pyi" + + +def test_x2py_main_semantic_readiness_blocker_formatting(): + text = x2py_cli._format_semantic_readiness( + { + "solver.pyi": { + "source_kind": "pyi", + "semantic_modules": [{"name": "solver"}], + "wrap_readiness": { + "wrappable": False, + "n_functions": 1, + "n_classes": 0, + "n_variables": 0, + "wrappability_blockers": [ + { + "code": "unresolved_semantic_types", + "message": "Unresolved semantic types.", + "items": [{"owner": "step", "type": "sim_state"}], + }, + { + "code": "unresolved_shape_symbols", + "message": "Unresolved shape symbols.", + "items": [{"owner": "fill", "expression": "n", "symbol": "n"}], + }, + { + "code": "missing_compile_time_values", + "message": "Missing compile-time values.", + "items": [{"owner": "fill", "symbol": "n"}], + }, + { + "code": "callback_signature_incomplete", + "message": "Callback signature incomplete.", + "items": [{"owner": "integrate.objective", "needs": ["callback argument types"]}], + }, + { + "code": "no_public_api", + "message": "No public API.", + "items": [{"owner": "empty", "needs": ["public functions"]}], + }, + { + "code": "custom", + "message": "Custom blocker.", + "items": [{"payload": 1}], + }, + ], + }, + } + } + ) + + assert "step uses unresolved type sim_state" in text + assert "fill shape 'n' uses unresolved symbol n" in text + assert "fill needs literal value for Final constant n" in text + assert "integrate.objective needs Callable[[...], ...] metadata (callback argument types)" in text + assert "empty needs public functions" in text + assert "{'payload': 1}" in text + + +def test_x2py_main_argument_validation_errors(tmp_path: Path, monkeypatch, capsys): + f90 = _write_ready_fortran(tmp_path / "mini.f90") + + monkeypatch.setattr(sys, "argv", ["x2py", str(f90), "--show-vars"]) + with pytest.raises(SystemExit) as show_vars_error: + x2py_cli.main() + assert show_vars_error.value.code == 2 + assert "--show-vars/--print-limit require --parse" in capsys.readouterr().err + + monkeypatch.setattr(sys, "argv", ["x2py", str(f90), "--parse", "--print-limit", "-1"]) + with pytest.raises(SystemExit) as print_limit_error: + x2py_cli.main() + assert print_limit_error.value.code == 2 + assert "--print-limit must be >= 0" in capsys.readouterr().err + + monkeypatch.setattr(sys, "argv", ["x2py", str(f90)]) + with pytest.raises(SystemExit) as stage_error: + x2py_cli.main() + assert stage_error.value.code == 2 + assert "Select at least one stage flag" in capsys.readouterr().err