19041620429

Committed 03 Nov 2025 04:27PM UTC coverage: 88.116% (+0.02%) from 88.099%

Build # 19041620429

Build Type

push

github

Committed by

rjfarmer

Commit Message

Remove line limits

Run Details

1001 of 1136 relevant lines covered (88.12%)

0.88 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

64.42

/gfModParser/utils.py

# SPDX-License-Identifier: GPL-2.0+

import numpy as np
from packaging.version import Version
from typing import Any, Union

try:
    import pyquadp as pyq  # type: ignore[import-not-found]

    PYQ_IMPORTED = True
except ImportError:
    PYQ_IMPORTED = False


def gfortran_mod_map(version: Version) -> Version:
    """
    Map gfortran version to Mod file version
    """
    if version < Version("4.8.1"):
        return Version("9")
    elif version < Version("4.9.2"):
        return Version("10")
    elif version < Version("5.1.0"):
        return Version("12")
    elif version < Version("8.0.0"):
        return Version("14")
    elif version < Version("15.0.0"):
        return Version("15")
    elif version.major == 15:
        return Version("16")
    else:
        raise ValueError(f"Unknown gfortran version {version}")


def string_clean(string: str) -> str:
    if string is None:
        return ""
    if string.startswith("'") or string.startswith('"'):
        string = string[1:]
    if string.endswith("'") or string.endswith('"'):
        string = string[:-1]

    return string


def hextofloat(s: str, kind: int = 4) -> Union[float, np.double, "pyq.qfloat"]:
    # Given hex like parameter '0.12decde@9' returns 5065465344.0
    if "@" in s:
        man, e = s.split("@")
        exp = int(e)
    else:
        man = s
        exp = 0

    if kind == 16:
        if PYQ_IMPORTED:
            return pyq.qfloat.fromhex(man) * 16**exp
        else:
            raise ValueError("Please install pyQuadp to handle quad precision numbers")
    elif kind == 8:
        return np.double.fromhex(man) * 16**exp  # type: ignore[attr-defined]
    else:
        return float.fromhex(man) * 16**exp


def dtype(type, kind, len=-1) -> np.dtype:
    if type == "REAL":
        if kind == 4:
            return np.dtype(np.float32)
        elif kind == 8:
            return np.dtype(np.float64)
        elif kind == 16:
            return np.dtype(np.float128)
    elif type == "INTEGER":
        if kind == 1:
            return np.dtype(np.int8)
        elif kind == 2:
            return np.dtype(np.int16)
        elif kind == 4:
            return np.dtype(np.int32)
        elif kind == 8:
            return np.dtype(np.int64)
        elif kind == 16:
            return np.dtype(np.int128)
    elif type == "UNSIGNED":
        if kind == 4:
            return np.dtype(np.uint32)
        elif kind == 8:
            return np.dtype(np.uint64)
        elif kind == 16:
            return np.dtype(np.uint128)
    elif type == "CHARACTER":
        return np.dtype(f"S{len}")
    elif type == "COMPLEX":
        if kind == 4:
            return np.dtype(np.complex64)
        elif kind == 8:
            return np.dtype(np.complex128)
        elif kind == 16:
            return np.dtype(np.complex256)
    elif type == "LOGICAL":
        return np.dtype(np.int32)

    raise NotImplementedError(f"Type={type} kind={kind}")


def bracket_split(string) -> list[Any]:
    def _helper(substring):
        items = []
        tmp = []
        for item in substring:
            if item == "(":
                result, closeparen = _helper(substring)
                if not closeparen:
                    raise ValueError("Unbalanced parentheses")
                items.append(result)
            elif item == ")":
                t = "".join(tmp).strip()
                if len(t):
                    items.append(t)
                return items, True
            else:
                if item != " ":
                    tmp.append(item)
                else:
                    t = "".join(tmp).strip()
                    if len(t):
                        items.append(t)
                        tmp = []
        return items, False

    return _helper(iter(string))[0]

1	# SPDX-License-Identifier: GPL-2.0+
2
3	import numpy as np	1✔
4	from packaging.version import Version	1✔
5	from typing import Any, Union	1✔
6
7	try:	1✔
8	import pyquadp as pyq # type: ignore[import-not-found]	1✔
9
10	PYQ_IMPORTED = True	×
11	except ImportError:	1✔
12	PYQ_IMPORTED = False	1✔
13
14
15	def gfortran_mod_map(version: Version) -> Version:	1✔
16	"""
17	Map gfortran version to Mod file version
18	"""
19	if version < Version("4.8.1"):	×
20	return Version("9")	×
21	elif version < Version("4.9.2"):	×
22	return Version("10")	×
23	elif version < Version("5.1.0"):	×
24	return Version("12")	×
25	elif version < Version("8.0.0"):	×
26	return Version("14")	×
27	elif version < Version("15.0.0"):	×
28	return Version("15")	×
29	elif version.major == 15:	×
30	return Version("16")	×
31	else:
32	raise ValueError(f"Unknown gfortran version {version}")	×
33
34
35	def string_clean(string: str) -> str:	1✔
36	if string is None:	1✔
37	return ""	1✔
38	if string.startswith("'") or string.startswith('"'):	1✔
39	string = string[1:]	1✔
40	if string.endswith("'") or string.endswith('"'):	1✔
41	string = string[:-1]	1✔
42
43	return string	1✔
44
45
46	def hextofloat(s: str, kind: int = 4) -> Union[float, np.double, "pyq.qfloat"]:	1✔
47	# Given hex like parameter '0.12decde@9' returns 5065465344.0
48	if "@" in s:	1✔
49	man, e = s.split("@")	1✔
50	exp = int(e)	1✔
51	else:
52	man = s	1✔
53	exp = 0	1✔
54
55	if kind == 16:	1✔
56	if PYQ_IMPORTED:	×
57	return pyq.qfloat.fromhex(man) * 16**exp	×
58	else:
59	raise ValueError("Please install pyQuadp to handle quad precision numbers")	×
60	elif kind == 8:	1✔
61	return np.double.fromhex(man) * 16**exp # type: ignore[attr-defined]	1✔
62	else:
63	return float.fromhex(man) * 16**exp	1✔
64
65
66	def dtype(type, kind, len=-1) -> np.dtype:	1✔
67	if type == "REAL":	1✔
68	if kind == 4:	1✔
69	return np.dtype(np.float32)	1✔
70	elif kind == 8:	1✔
71	return np.dtype(np.float64)	1✔
72	elif kind == 16:	×
73	return np.dtype(np.float128)	×
74	elif type == "INTEGER":	1✔
75	if kind == 1:	1✔
76	return np.dtype(np.int8)	1✔
77	elif kind == 2:	1✔
78	return np.dtype(np.int16)	1✔
79	elif kind == 4:	1✔
80	return np.dtype(np.int32)	1✔
81	elif kind == 8:	×
82	return np.dtype(np.int64)	×
83	elif kind == 16:	×
84	return np.dtype(np.int128)	×
85	elif type == "UNSIGNED":	1✔
86	if kind == 4:	×
87	return np.dtype(np.uint32)	×
88	elif kind == 8:	×
89	return np.dtype(np.uint64)	×
90	elif kind == 16:	×
91	return np.dtype(np.uint128)	×
92	elif type == "CHARACTER":	1✔
93	return np.dtype(f"S{len}")	1✔
94	elif type == "COMPLEX":	1✔
95	if kind == 4:	×
96	return np.dtype(np.complex64)	×
97	elif kind == 8:	×
98	return np.dtype(np.complex128)	×
99	elif kind == 16:	×
100	return np.dtype(np.complex256)	×
101	elif type == "LOGICAL":	1✔
102	return np.dtype(np.int32)	1✔
103
104	raise NotImplementedError(f"Type={type} kind={kind}")	×
105
106
107	def bracket_split(string) -> list[Any]:	1✔
108	def _helper(substring):	1✔
109	items = []	1✔
110	tmp = []	1✔
111	for item in substring:	1✔
112	if item == "(":	1✔
113	result, closeparen = _helper(substring)	1✔
114	if not closeparen:	1✔
115	raise ValueError("Unbalanced parentheses")	×
116	items.append(result)	1✔
117	elif item == ")":	1✔
118	t = "".join(tmp).strip()	1✔
119	if len(t):	1✔
120	items.append(t)	1✔
121	return items, True	1✔
122	else:
123	if item != " ":	1✔
124	tmp.append(item)	1✔
125	else:
126	t = "".join(tmp).strip()	1✔
127	if len(t):	1✔
128	items.append(t)	1✔
129	tmp = []	1✔
130	return items, False	1✔
131
132	return _helper(iter(string))[0]	1✔

rjfarmer / gfModParser / 19041620429

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous