18614139848

Committed 18 Oct 2025 09:59AM UTC coverage: 88.036% (-0.3%) from 88.291%

Build # 18614139848

Build Type

push

github

Committed by

rjfarmer

Commit Message

More typing

Coverage Stats

70 of 73 new or added lines in 8 files covered. (95.89%)

986 of 1120 relevant lines covered (88.04%)

0.88 hits per line

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

93.48

/gfModParser/modules/operators.py

import operator
from packaging.version import Version
from functools import cache, cached_property
import abc

from .. import utils
from . import utils as u


_default_ops = {
    "UPLUS": operator.__add__,
    "UMINUS": operator.__sub__,
    "PLUS": operator.__add__,
    "MINUS": operator.__sub__,
    "TIMES": operator.__mul__,
    "DIVIDE": operator.__truediv__,
    "POWER": operator.__pow__,
    "CONCAT": operator.__add__,  # Only for strings
    "AND": operator.__and__,
    "OR": operator.__or__,
    "EQV": operator.__eq__,
    "NEQV": operator.__ne__,
    "EQ_SIGN": operator.__eq__,
    "EQ": operator.__eq__,
    "NE_SIGN": operator.__ne__,
    "NE": operator.__ne__,
    "GT_SIGN": operator.__gt__,
    "GT": operator.__gt__,
    "GE_SIGN": operator.__ge__,
    "GE": operator.__ge__,
    "LT_SIGN": operator.__le__,
    "LT": operator.__le__,
    "LE_SIGN": operator.__le__,
    "LE": operator.__le__,
    "NOT": operator.__not__,
    "PARENTHESES": None,
    "USER": None,
    "NULL": None,
}


class base_interface(abc.ABC):
    def __init__(self, symbols, *, version: Version) -> None:
        self._raw = symbols
        self.version = version

    @abc.abstractmethod
    def extract(self) -> dict[str, u.ListSymbols]:
        raise NotImplementedError

    def keys(self):
        return self.extract().keys()

    def __getitem__(self, key: str) -> u.ListSymbols:
        return self.extract()[key]

    def values(self):
        return self.extract().values()

    def items(self):
        return self.extract().items()


class Interfaces(base_interface):
    """
    For overriding inbuilt functions (like +,*,-,/ etc)
    """

    @cache
    def extract(self):
        res = {}
        face = utils.bracket_split(self._raw)[0]

        for index, value in enumerate(face):
            if len(value):
                key = list(_default_ops.keys())[index]
                res[key] = u.ListSymbols(value, version=self.version)
        return res

    def op(self, key):
        return _default_ops[key]


class Generics(base_interface):
    """
    Provides generic interfaces (type overloading)
    """

    @cache
    def extract(self):
        res = {}
        face = utils.bracket_split(self._raw)[0]

        for value in face:
            (name, _, *num) = value
            name = utils.string_clean(name)
            res[name] = u.ListSymbols(num, version=self.version)
        return res


class Operators(Generics):
    """
    Provides custom operators like .my_op.
    """

    pass

1	import operator	1✔
2	from packaging.version import Version	1✔
3	from functools import cache, cached_property	1✔
4	import abc	1✔
5
6	from .. import utils	1✔
7	from . import utils as u	1✔
8
9
10	_default_ops = {	1✔
11	"UPLUS": operator.__add__,
12	"UMINUS": operator.__sub__,
13	"PLUS": operator.__add__,
14	"MINUS": operator.__sub__,
15	"TIMES": operator.__mul__,
16	"DIVIDE": operator.__truediv__,
17	"POWER": operator.__pow__,
18	"CONCAT": operator.__add__, # Only for strings
19	"AND": operator.__and__,
20	"OR": operator.__or__,
21	"EQV": operator.__eq__,
22	"NEQV": operator.__ne__,
23	"EQ_SIGN": operator.__eq__,
24	"EQ": operator.__eq__,
25	"NE_SIGN": operator.__ne__,
26	"NE": operator.__ne__,
27	"GT_SIGN": operator.__gt__,
28	"GT": operator.__gt__,
29	"GE_SIGN": operator.__ge__,
30	"GE": operator.__ge__,
31	"LT_SIGN": operator.__le__,
32	"LT": operator.__le__,
33	"LE_SIGN": operator.__le__,
34	"LE": operator.__le__,
35	"NOT": operator.__not__,
36	"PARENTHESES": None,
37	"USER": None,
38	"NULL": None,
39	}
40
41
42	class base_interface(abc.ABC):	1✔
43	def __init__(self, symbols, *, version: Version) -> None:	1✔
44	self._raw = symbols	1✔
45	self.version = version	1✔
46
47	@abc.abstractmethod	1✔
48	def extract(self) -> dict[str, u.ListSymbols]:	1✔
NEW 49	raise NotImplementedError	×
50
51	def keys(self):	1✔
52	return self.extract().keys()	1✔
53
54	def __getitem__(self, key: str) -> u.ListSymbols:	1✔
55	return self.extract()[key]	1✔
56
57	def values(self):	1✔
NEW 58	return self.extract().values()	×
59
60	def items(self):	1✔
NEW 61	return self.extract().items()	×
62
63
64	class Interfaces(base_interface):	1✔
65	"""
66	For overriding inbuilt functions (like +,*,-,/ etc)
67	"""
68
69	@cache	1✔
70	def extract(self):	1✔
71	res = {}	1✔
72	face = utils.bracket_split(self._raw)[0]	1✔
73
74	for index, value in enumerate(face):	1✔
75	if len(value):	1✔
76	key = list(_default_ops.keys())[index]	1✔
77	res[key] = u.ListSymbols(value, version=self.version)	1✔
78	return res	1✔
79
80	def op(self, key):	1✔
81	return _default_ops[key]	1✔
82
83
84	class Generics(base_interface):	1✔
85	"""
86	Provides generic interfaces (type overloading)
87	"""
88
89	@cache	1✔
90	def extract(self):	1✔
91	res = {}	1✔
92	face = utils.bracket_split(self._raw)[0]	1✔
93
94	for value in face:	1✔
95	(name, _, *num) = value	1✔
96	name = utils.string_clean(name)	1✔
97	res[name] = u.ListSymbols(num, version=self.version)	1✔
98	return res	1✔
99
100
101	class Operators(Generics):	1✔
102	"""
103	Provides custom operators like .my_op.
104	"""
105
106	pass	1✔

rjfarmer / gfModParser / 18614139848

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