Update Python versions and remove deprecation errors

.github/workflows/python-package.yml

@@ -16,7 +16,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.8", "3.9", "3.10"]
+        python-version: ["3.10", "3.11", "3.12"]
 
     steps:
     - uses: actions/checkout@v3

setup.py

@@ -40,5 +40,5 @@
     classifiers=[
         "License :: OSI Approved :: Eclipse Public License 1.0 (EPL-1.0)"
     ],
-    python_requires='>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*',
+    python_requires='>=2.7, >=3.10', 
 )

src/amply/amply.py

@@ -53,13 +53,13 @@
     Word,
     ZeroOrMore,
     alphanums,
-    delimitedList,
+    DelimitedList,
     lineEnd,
     nums,
-    oneOf,
+    one_of,
 )
 
-ParserElement.enablePackrat()
+ParserElement.enable_packrat()
 
 
 __all__ = ["Amply", "AmplyError"]
@@ -610,14 +610,14 @@ def mark_transposed(tokens):
 # What follows is a Pyparsing description of the grammar
 
 index = Word(alphanums, exact=1)
-symbol = Word(alphanums + "_", bodyChars=alphanums + "_", min=1)
-sign = Optional(oneOf("+ -"))
-integer = Combine(sign + Word(nums)).setParseAction(lambda t: int(t[0]))
+symbol = Word(alphanums + "_", body_chars=alphanums + "_", min=1)
+sign = Optional(one_of("+ -"))
+integer = Combine(sign + Word(nums)).set_parse_action(lambda t: int(t[0]))
 number = Combine(
     Word("+-" + nums, nums)
     + Optional("." + Optional(Word(nums)))
-    + Optional(oneOf("e E") + Word("+-" + nums, nums))
-).setParseAction(lambda t: float(t[0]))
+    + Optional(one_of("e E") + Word("+-" + nums, nums))
+).set_parse_action(lambda t: float(t[0]))
 
 LPAREN = Suppress("(")
 RPAREN = Suppress(")")
@@ -636,12 +636,12 @@ def mark_transposed(tokens):
 KW_DEFAULT = Keyword("default")
 
 single = number ^ symbol | QuotedString('"') | QuotedString("'")
-tuple_ = Group(LPAREN + delimitedList(single) + RPAREN)
+tuple_ = Group(LPAREN + DelimitedList(single) + RPAREN)
 
 domain_index = Suppress(index + Keyword("in"))
 subscript_domain = (
     LBRACE
-    + delimitedList(Optional(domain_index) + symbol).setResultsName("subscripts")
+    + DelimitedList(Optional(domain_index) + symbol).set_results_name("subscripts")
     + RBRACE
 )
 
@@ -656,18 +656,18 @@ def mark_transposed(tokens):
 matrix_row = Group(single + OneOrMore(PLUS | MINUS))
 matrix_data = (
     ":"
-    + OneOrMore(single).setResultsName("columns")
+    + OneOrMore(single).set_results_name("columns")
     + ":="
-    + OneOrMore(matrix_row).setResultsName("data")
+    + OneOrMore(matrix_row).set_results_name("data")
 )
-matrix_data.setParseAction(MatrixData)
+matrix_data.set_parse_action(MatrixData)
 
 tr_matrix_data = Suppress("(tr)") + matrix_data
-tr_matrix_data.setParseAction(mark_transposed)
+tr_matrix_data.set_parse_action(mark_transposed)
 
 set_slice_component = number | symbol | "*"
-set_slice_record = LPAREN + NotAny("tr") + delimitedList(set_slice_component) + RPAREN
-set_slice_record.setParseAction(SliceRecord)
+set_slice_record = LPAREN + NotAny("tr") + DelimitedList(set_slice_component) + RPAREN
+set_slice_record.set_parse_action(SliceRecord)
 
 _set_record = set_slice_record | matrix_data | tr_matrix_data | Suppress(":=")
 set_record = simple_data | _set_record
@@ -677,23 +677,23 @@ def mark_transposed(tokens):
     KW_SET
     + symbol
     + Optional(subscript_domain)
-    + Optional(Keyword("dimen") + integer.setResultsName("dimen"))
+    + Optional(Keyword("dimen") + integer.set_results_name("dimen"))
     + END
 )
-set_def_stmt.setParseAction(SetDefStmt)
+set_def_stmt.set_parse_action(SetDefStmt)
 
-set_member = LBRACKET + delimitedList(data) + RBRACKET
+set_member = LBRACKET + DelimitedList(data) + RBRACKET
 
 set_stmt = (
     KW_SET
     + symbol
-    + Optional(set_member).setResultsName("member")
+    + Optional(set_member).set_results_name("member")
     + Group(
         non_dimen_set_record + ZeroOrMore(Optional(Suppress(",")) + set_record)
-    ).setResultsName("records")
+    ).set_results_name("records")
     + END
 )
-set_stmt.setParseAction(SetStmt)
+set_stmt.set_parse_action(SetStmt)
 
 subscript = single
 
@@ -710,18 +710,18 @@ def mark_transposed(tokens):
 
 tabular_record = (
     ":"
-    + OneOrMore(single).setResultsName("columns")
+    + OneOrMore(single).set_results_name("columns")
     + ":="
-    + OneOrMore(single | ".").setResultsName("data")
+    + OneOrMore(single | ".").set_results_name("data")
 )
-tabular_record.setParseAction(TabularRecord)
+tabular_record.set_parse_action(TabularRecord)
 
 tr_tabular_record = Suppress("(tr)") + tabular_record
-tr_tabular_record.setParseAction(mark_transposed)
+tr_tabular_record.set_parse_action(mark_transposed)
 
 param_slice_component = number | symbol | "*"
-param_slice_record = LBRACKET + delimitedList(param_slice_component) + RBRACKET
-param_slice_record.setParseAction(SliceRecord)
+param_slice_record = LBRACKET + DelimitedList(param_slice_component) + RBRACKET
+param_slice_record.set_parse_action(SliceRecord)
 
 param_record = (
     param_slice_record
@@ -731,38 +731,38 @@ def mark_transposed(tokens):
     | Suppress(":=")
 )
 
-param_default = Optional(KW_DEFAULT + single.setResultsName("default"))
+param_default = Optional(KW_DEFAULT + single.set_results_name("default"))
 
 param_stmt = (
     KW_PARAM
     + ~KW_DEFAULT
-    + symbol.setResultsName("name")
+    + symbol.set_results_name("name")
     + param_default
-    + Group(OneOrMore(param_record)).setResultsName("records")
+    + Group(OneOrMore(param_record)).set_results_name("records")
     + END
 )
-param_stmt.setParseAction(ParamStmt)
+param_stmt.set_parse_action(ParamStmt)
 
 param_tabbing_stmt = (
     KW_PARAM
     + param_default
     + ":"
     + Optional(symbol + ": ")
-    + OneOrMore(data).setResultsName("params")
+    + OneOrMore(data).set_results_name("params")
     + ":="
-    + ZeroOrMore(single).setResultsName("data")
+    + ZeroOrMore(single).set_results_name("data")
     + END
 )
-param_tabbing_stmt.setParseAction(ParamTabbingStmt)
+param_tabbing_stmt.set_parse_action(ParamTabbingStmt)
 
 param_def_stmt = (
     KW_PARAM
-    + symbol.setResultsName("name")
+    + symbol.set_results_name("name")
     + Optional(subscript_domain)
     + param_default
     + END
 )
-param_def_stmt.setParseAction(ParamDefStmt)
+param_def_stmt.set_parse_action(ParamDefStmt)
 
 stmts = set_stmt | set_def_stmt | param_def_stmt | param_stmt | param_tabbing_stmt
 grammar = ZeroOrMore(stmts) + StringEnd()
@@ -820,7 +820,7 @@ def load_string(self, string):
         @param string string to parse
         """
         try:
-            for obj in grammar.parseString(string):
+            for obj in grammar.parse_string(string):
                 obj.eval(self)
         except ParseException as ex:
             print(string)

tests/test_amply.py

@@ -28,17 +28,17 @@ def test_subscript(self):
         {r in REGION, y in YEAR, g in GOLF}
 
         """
-        success, result = subscript_domain.runTests(fixture)
+        success, result = subscript_domain.run_tests(fixture)
         assert success
 
         assert result[0]
 
     def test_subscript_result(self):
-        result = subscript_domain.parseString("{a, b, c}")
+        result = subscript_domain.parse_string("{a, b, c}")
         assert result.asDict() == {"subscripts": ["a", "b", "c"]}
 
     def test_subscript_result_domain(self):
-        result = subscript_domain.parseString("{a in A, b in B, c in C}")
+        result = subscript_domain.parse_string("{a in A, b in B, c in C}")
         assert result.asDict() == {"subscripts": ["A", "B", "C"]}
 
 
@@ -55,7 +55,7 @@ def test_not_number(self):
         Jan_01
         01_Jan
         """
-        result = number.runTests(fixture, failureTests=True)
+        result = number.run_tests(fixture, failureTests=True)
         assert result[0]
 
     def test_number(self):
@@ -68,7 +68,7 @@ def test_number(self):
         00
         0.0
         """
-        result = number.runTests(fixture)
+        result = number.run_tests(fixture)
         assert result[0]
 
 
@@ -80,7 +80,7 @@ def test_not_symbol(self):
         +1e-049
         skj!adfk
         """
-        result = symbol.runTests(fixture, failureTests=True)
+        result = symbol.run_tests(fixture, failureTests=True)
         assert result[0]
 
     def test_symbol(self):
@@ -93,7 +93,7 @@ def test_symbol(self):
 
         01_Jan
         """
-        result = symbol.runTests(fixture)
+        result = symbol.run_tests(fixture)
         assert result[0]
 
 
@@ -105,11 +105,11 @@ def test_param_def(self):
         param Test;
         param Test default 1;
         """
-        success, results = param_def_stmt.runTests(fixture)
+        success, results = param_def_stmt.run_tests(fixture)
 
         assert success
 
-        success, _ = param_stmt.runTests(fixture, failureTests=True)
+        success, _ = param_stmt.run_tests(fixture, failureTests=True)
         assert success
 
     def test_param_stmt(self):
@@ -127,10 +127,10 @@ def test_param_stmt(self):
         param 01_Feb := -0.04;
 
         """
-        result = param_stmt.runTests(fixture)
+        result = param_stmt.run_tests(fixture)
         assert result[0]
 
-        result = param_def_stmt.runTests(fixture, failureTests=True)
+        result = param_def_stmt.run_tests(fixture, failureTests=True)
         assert result[0]
 
 
@@ -143,7 +143,7 @@ def test_set_stmt(self):
 
         set 1_2_month := 1 2 3 4;
         """
-        result = set_stmt.runTests(fixture)
+        result = set_stmt.run_tests(fixture)
         assert result[0]
 
     @pytest.fixture()
@@ -158,11 +158,11 @@ def setup(self):
         return fixture
 
     def test_set_record(self, setup):
-        result = set_record.runTests(setup)
+        result = set_record.run_tests(setup)
         assert result[0]
 
     def test_simple_data(self, setup):
-        result = simple_data.runTests(setup)
+        result = simple_data.run_tests(setup)
         assert result[0]
 
     def test_single(self):
@@ -173,7 +173,7 @@ def test_single(self):
         Jan_01
         01_Jan
         """
-        result = single.runTests(fixture)
+        result = single.run_tests(fixture)
         assert result[0]