18631856668

Committed 19 Oct 2025 02:34PM UTC coverage: 88.036%. Remained the same

Build # 18631856668

Build Type

push

github

Committed by

rjfarmer

Commit Message

Add limits to CI jobs

Run Details

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

# SPDX-License-Identifier: GPL-2.0+

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

rjfarmer / gfModParser / 18631856668

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