18542693371

Committed 15 Oct 2025 09:07PM UTC coverage: 88.199% (-0.6%) from 88.811%

Build # 18542693371

Build Type

push

github

Committed by

rjfarmer

Commit Message

Fix string test

Run Details

1009 of 1144 relevant lines covered (88.2%)

0.88 hits per line

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

95.45

/gfModParser/modules/operators.py

import operator

from .. import utils
from . import utils as u


class Interfaces:

    _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,
    }

    def __init__(self, interfaces, *, version):
        """
        For overriding inbuilt functions (like +,*,-,/ etc)
        """
        self._raw = interfaces
        self._interfaces = None
        self.version = version

    def _load(self):
        self._interfaces = {}
        face = utils.bracket_split(self._raw)[0]

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

    def keys(self) -> list:
        if self._interfaces is None:
            self._load()

        return self._interfaces.keys()

    def __getitem__(self, key):
        if self._interfaces is None:
            self._load()

        return self._interfaces[key]

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


class Operators:
    def __init__(self, operators, *, version):
        """
        Provides custom operators like .my_op.
        """
        self._raw = operators
        self._operators = None
        self.version = version

    def _load(self):
        self._operators = {}
        face = utils.bracket_split(self._raw)[0]

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

    def keys(self) -> list:
        if self._operators is None:
            self._load()

        return self._operators.keys()

    def __getitem__(self, key):
        if self._operators is None:
            self._load()

        return self._operators[key]


class Generics:
    def __init__(self, generics, *, version):
        """
        Provides generic interfaces (type overloading)
        """
        self._raw = generics
        self._generics = None
        self.version = version

    def _load(self):
        self._generics = {}
        face = utils.bracket_split(self._raw)[0]

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

    def keys(self) -> list:
        if self._generics is None:
            self._load()

        return self._generics.keys()

    def __getitem__(self, key):
        if self._generics is None:
            self._load()

        return self._generics[key]

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

rjfarmer / gfModParser / 18542693371

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