15376618812

Committed 01 Jun 2025 03:24PM UTC coverage: 90.789% (+0.7%) from 90.135%

Build # 15376618812

Build Type

push

github

Committed by

rjfarmer

Commit Message

Add interfaces, operators, and generics

Run Details

93 of 96 new or added lines in 3 files covered. (96.88%)

20 existing lines in 2 files now uncovered.

966 of 1064 relevant lines covered (90.79%)

0.91 hits per line

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

95.52

/gfModParser/modules/operators.py

import operator
import pyparsing

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 = pyparsing.OneOrMore(pyparsing.nestedExpr()).parseString(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):
        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 = pyparsing.OneOrMore(pyparsing.nestedExpr()).parseString(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):
        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 = pyparsing.OneOrMore(pyparsing.nestedExpr()).parseString(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):
        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	import pyparsing	1✔
3
4	from .. import utils	1✔
5	from . import utils as u	1✔
6
7
8	class Interfaces:	1✔
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	def __init__(self, interfaces, *, version):	1✔
42	"""
43	For overriding inbuilt functions (like +,*,-,/ etc)
44	"""
45	self._raw = interfaces	1✔
46	self._interfaces = None	1✔
47	self.version = version	1✔
48
49	def _load(self):	1✔
50	self._interfaces = {}	1✔
51	face = pyparsing.OneOrMore(pyparsing.nestedExpr()).parseString(self._raw)[0]	1✔
52
53	for index, value in enumerate(face):	1✔
54	if len(value):	1✔
55	key = list(self._default_ops.keys())[index]	1✔
56	self._interfaces[key] = u.ListSymbols(value, version=self.version)	1✔
57
58	def keys(self):	1✔
59	if self._interfaces is None:	1✔
60	self._load()	1✔
61
62	return self._interfaces.keys()	1✔
63
64	def __getitem__(self, key):	1✔
65	if self._interfaces is None:	1✔
NEW 66	self._load()	×
67
68	return self._interfaces[key]	1✔
69
70	def op(self, key):	1✔
71	return self._default_ops[key]	1✔
72
73
74	class Operators:	1✔
75	def __init__(self, operators, *, version):	1✔
76	"""
77	Provides custom operators like .my_op.
78	"""
79	self._raw = operators	1✔
80	self._operators = None	1✔
81	self.version = version	1✔
82
83	def _load(self):	1✔
84	self._operators = {}	1✔
85	face = pyparsing.OneOrMore(pyparsing.nestedExpr()).parseString(self._raw)[0]	1✔
86
87	for value in face:	1✔
88	(name, _, *num) = value	1✔
89	name = utils.string_clean(name)	1✔
90	self._operators[name] = u.ListSymbols(num, version=self.version)	1✔
91
92	def keys(self):	1✔
93	if self._operators is None:	1✔
94	self._load()	1✔
95
96	return self._operators.keys()	1✔
97
98	def __getitem__(self, key):	1✔
99	if self._operators is None:	1✔
NEW 100	self._load()	×
101
102	return self._operators[key]	1✔
103
104
105	class Generics:	1✔
106	def __init__(self, generics, *, version):	1✔
107	"""
108	Provides generic interfaces (type overloading)
109	"""
110	self._raw = generics	1✔
111	self._generics = None	1✔
112	self.version = version	1✔
113
114	def _load(self):	1✔
115	self._generics = {}	1✔
116	face = pyparsing.OneOrMore(pyparsing.nestedExpr()).parseString(self._raw)[0]	1✔
117
118	for value in face:	1✔
119	(name, _, *num) = value	1✔
120	name = utils.string_clean(name)	1✔
121	self._generics[name] = u.ListSymbols(num, version=self.version)	1✔
122
123	def keys(self):	1✔
124	if self._generics is None:	1✔
125	self._load()	1✔
126
127	return self._generics.keys()	1✔
128
129	def __getitem__(self, key):	1✔
130	if self._generics is None:	1✔
NEW 131	self._load()	×
132
133	return self._generics[key]	1✔

rjfarmer / gfModParser / 15376618812

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