Australian Postcodes MCP Server

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