25961481404

Committed 16 May 2026 12:05PM UTC coverage: 96.206% (-0.2%) from 96.356%

Build # 25961481404

Build Type

push

github

Committed by

rjfarmer

Commit Message

Revert "Make pyquadp required dependency"

This reverts commit d40759eed.

Coverage Stats

9 of 11 new or added lines in 1 file covered. (81.82%)

1141 of 1186 relevant lines covered (96.21%)

0.96 hits per line

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

98.08

/gfModParser/utils.py

# SPDX-License-Identifier: GPL-2.0+

from typing import Any, Union

import numpy as np
from packaging.version import Version

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

rjfarmer / gfModParser / 25961481404

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