opshin/type_inference.py:780:            ), "Keyword arguments can only be used with user defined functions"

   755→                assert (
   756→                    ts.slice.upper.typ == IntegerInstanceType
   757→                ), "upper slice indices for bytes must be integers"
   758→        elif isinstance(ts.value.typ.typ, DictType):
   759→            if not isinstance(ts.slice, Slice):
   760→                ts.slice = self.visit(node.slice)
   761→                assert (
   762→                    ts.slice.typ == ts.value.typ.typ.key_typ
   763→                ), f"Dict subscript must have dict key type {ts.value.typ.typ.key_typ} but has type {ts.slice.typ}"
   764→                ts.typ = ts.value.typ.typ.value_typ
   765→            else:
   766→                raise TypeInferenceError(
   767→                    f"Could not infer type of subscript of dict with a slice."
   768→                )
   769→        else:
   770→            raise TypeInferenceError(
   771→                f"Could not infer type of subscript of typ {ts.value.typ.__class__}"
   772→            )
   773→        return ts
   774→
   775→    def visit_Call(self, node: Call) -> TypedCall:
   776→        tc = copy(node)
   777→        if node.keywords:
   778→            assert (
   779→                node.func.id in self.FUNCTION_ARGUMENT_REGISTRY
   780→            ), "Keyword arguments can only be used with user defined functions"
   781→            keywords = copy(node.keywords)
   782→            reg_args = self.FUNCTION_ARGUMENT_REGISTRY[node.func.id]
   783→            args = []
   784→            for i, a in enumerate(reg_args):
   785→                if len(node.args) > i:
   786→                    args.append(self.visit(node.args[i]))
   787→                else:
   788→                    candidates = [
   789→                        (idx, keyword)
   790→                        for idx, keyword in enumerate(keywords)
   791→                        if keyword.arg == a.orig_arg
   792→                    ]
   793→                    assert (
   794→                        len(candidates) == 1
   795→                    ), f"There should be one keyword or positional argument for the arg {a.orig_arg} but found {len(candidates)}"
   796→                    args.append(self.visit(candidates[0][1].value))
   797→                    keywords.pop(candidates[0][0])
   798→            assert (
   799→                len(keywords) == 0
   800→            ), f"Could not match the keywords {[keyword.arg for keyword in keywords]} to any argument"
   801→            tc.args = args
   802→            tc.keywords = []
   803→        else:
   804→            tc.args = [self.visit(a) for a in node.args]
   805→
   806→        # might be isinstance
   807→        if isinstance(tc.func, Name) and tc.func.orig_id == "isinstance":
   808→            target_class = tc.args[1].typ
   809→            if (
   810→                isinstance(tc.args[0].typ, InstanceType)
   811→                and isinstance(tc.args[0].typ.typ, AnyType)
   812→                and not self.allow_isinstance_anything
   813→            ):
   814→                raise AssertionError(

opshin/type_inference.py:246:        self.FUNCTION_ARGUMENT_REGISTRY = {}
opshin/type_inference.py:364:        self.FUNCTION_ARGUMENT_REGISTRY[node.name] = [
opshin/type_inference.py:611:        self.FUNCTION_ARGUMENT_REGISTRY[node.name] = node.args.args
opshin/type_inference.py:779:                node.func.id in self.FUNCTION_ARGUMENT_REGISTRY
opshin/type_inference.py:782:            reg_args = self.FUNCTION_ARGUMENT_REGISTRY[node.func.id]

   350→            # if an assert is amng the statements apply the isinstance cast
   351→            if isinstance(stmt, Assert):
   352→                typchecks, _ = TypeCheckVisitor(self.allow_isinstance_anything).visit(
   353→                    stmt.test
   354→                )
   355→                # for the time after this assert, the variable has the specialized type
   356→                prevtyps.update(self.implement_typechecks(typchecks))
   357→        self.implement_typechecks(prevtyps)
   358→        return stmts
   359→
   360→    def visit_ClassDef(self, node: ClassDef) -> TypedClassDef:
   361→        class_record = RecordReader.extract(node, self)
   362→        typ = RecordType(class_record)
   363→        self.set_variable_type(node.name, typ)
   364→        self.FUNCTION_ARGUMENT_REGISTRY[node.name] = [
   365→            typedarg(arg=field, typ=field_typ, orig_arg=field)
   366→            for field, field_typ in class_record.fields
   367→        ]
   368→        typed_node = copy(node)
   369→        typed_node.class_typ = typ
   370→        return typed_node
   371→
   372→    def visit_Constant(self, node: Constant) -> TypedConstant:
   373→        tc = copy(node)
   374→        assert type(node.value) not in [
   375→            float,
   376→            complex,
   377→            type(...),
   378→        ], "Float, complex numbers and ellipsis currently not supported"
   379→        tc.typ = constant_type(node.value)

17:from pycardano import PlutusData
46:def record_from_plutusdata(c: PlutusData):
84:    if isinstance(c, PlutusData):
108:            ), f"Union must combine multiple PlutusData classes but found {e2.__class__.__name__}"
114:    ), "Union must combine PlutusData classes with unique constructors"
164:        assert isinstance(target_class, RecordType), "Can only cast to PlutusData"
177:            ), "Can only cast instances of Union types of PlutusData or cast the same class. If you know what you are doing, enable the flag '--allow-isinstance-anything'"
1040:            ), f"PlutusData attribute {node.target.id} may not have a default value"

779:                node.func.id in self.FUNCTION_ARGUMENT_REGISTRY
782:            reg_args = self.FUNCTION_ARGUMENT_REGISTRY[node.func.id]

1452acb Merge pull request #386 from SCMusson/feat_allow_keywords
daa5af6 Remove superfluous line in tests
c595159 fix test bug
66f2b7b Formatting
9ce7b5a AggressiveTypeInference class variables to instance variables
8fd3b53 Scope unit test
9cd6cc7 Merge branch 'feat_allow_keywords' of https://github.com/SCMusson/opshin into feat_allow_keywords
5ca65e3 Tests and bug fix
e3a12fc run black
f835522 Merge branch 'dev' into feat_allow_keywords

(Bash completed with no output)

Result: 1

8c9b34b Merge pull request #386 from SCMusson/feat_allow_keywords
daa5af6 Remove superfluous line in tests
c595159 fix test bug
66f2b7b Formatting
9ce7b5a AggressiveTypeInference class variables to instance variables

241:class AggressiveTypeInferencer(CompilingNodeTransformer):
1013:    _type_inferencer: AggressiveTypeInferencer
1015:    def __init__(self, type_inferencer: AggressiveTypeInferencer):
1021:    def extract(cls, c: ClassDef, type_inferencer: AggressiveTypeInferencer) -> Record:
1095:    return AggressiveTypeInferencer().visit(ast)

   241→class AggressiveTypeInferencer(CompilingNodeTransformer):
   242→    step = "Static Type Inference"
   243→
   244→    def __init__(self, allow_isinstance_anything=False):
   245→        self.allow_isinstance_anything = allow_isinstance_anything
   246→        self.FUNCTION_ARGUMENT_REGISTRY = {}
   247→
   248→        # A stack of dictionaries for storing scoped knowledge of variable types
   249→        self.scopes = [INITIAL_SCOPE]
   250→
   251→    # Obtain the type of a variable name in the current scope
   252→    def variable_type(self, name: str) -> Type:
   253→        name = name
   254→        for scope in reversed(self.scopes):
   255→            if name in scope:
   256→                return scope[name]
   257→        raise TypeInferenceError(
   258→            f"Variable {map_to_orig_name(name)} not initialized at access"
   259→        )
   260→
   261→    def enter_scope(self):
   262→        self.scopes.append({})
   263→
   264→    def exit_scope(self):
   265→        self.scopes.pop()
   266→
   267→    def set_variable_type(self, name: str, typ: Type, force=False):
   268→        if not force and name in self.scopes[-1] and self.scopes[-1][name] != typ:
   269→            if self.scopes[-1][name] >= typ:
   270→                # the specified type is broader, we pass on this

opshin/tests/test_keywords.py-13-class Keyword_tests(unittest.TestCase):
/testbed/opshin/tests/test_keywords.py-14-    @given(x=st.integers(), y=st.integers(), z=st.integers())
opshin/tests/test_keywords.py:15:    def test_all_keywords(self, x: int, y: int, z: int):
/testbed/opshin/tests/test_keywords.py-16-        source_code = """
opshin/tests/test_keywords.py-17-def simple_example(x: int, y: int, z: int) -> int:
--
/testbed/opshin/tests/test_keywords.py-25-
/testbed/opshin/tests/test_keywords.py-26-    @given(x=st.integers(), y=st.integers(), z=st.integers())
opshin/tests/test_keywords.py:27:    def test_mixture_args_and_keywords(self, x: int, y: int, z: int):
/testbed/opshin/tests/test_keywords.py-28-        source_code = """
opshin/tests/test_keywords.py-29-def simple_example(x: int, y: int, z: int) -> int:
--
/testbed/opshin/tests/test_keywords.py-37-
/testbed/opshin/tests/test_keywords.py-38-    @given(x=st.integers(), y=st.integers(), z=st.integers())
opshin/tests/test_keywords.py:39:    def test_keyword_position_independence(self, x: int, y: int, z: int):
/testbed/opshin/tests/test_keywords.py-40-        source_code = """
opshin/tests/test_keywords.py-41-def simple_example(x: int, y: int, z:int) -> int:
--
/testbed/opshin/tests/test_keywords.py-49-
/testbed/opshin/tests/test_keywords.py-50-    @given(x=st.integers(), y=st.integers(), z=st.integers())
opshin/tests/test_keywords.py:51:    def test_arg_after_keyword_failure(self, x: int, y: int, z: int):
/testbed/opshin/tests/test_keywords.py-52-        source_code = """
opshin/tests/test_keywords.py-53-def simple_example(x: int, y: int, z:int) -> int:
--
/testbed/opshin/tests/test_keywords.py-61-
/testbed/opshin/tests/test_keywords.py-62-    @given(x=st.integers(), y=st.integers(), z=st.integers())
opshin/tests/test_keywords.py:63:    def test_too_many_keywords_failure(self, x: int, y: int, z: int):
/testbed/opshin/tests/test_keywords.py-64-        source_code = """
opshin/tests/test_keywords.py-65-def simple_example(x: int, y: int) -> int:
--
/testbed/opshin/tests/test_keywords.py-73-
/testbed/opshin/tests/test_keywords.py-74-    @given(x=st.integers(), y=st.integers(), z=st.integers())
opshin/tests/test_keywords.py:75:    def test_incorrect_keywords_failure(self, x: int, y: int, z: int):
/testbed/opshin/tests/test_keywords.py-76-        source_code = """
opshin/tests/test_keywords.py-77-def simple_example(x: int, y: int, z: int) -> int:

     1→import unittest
     2→
     3→import hypothesis
     4→from hypothesis import given
     5→from hypothesis import strategies as st
     6→from .utils import eval_uplc_value
     7→from . import PLUTUS_VM_PROFILE
     8→
     9→
    10→hypothesis.settings.load_profile(PLUTUS_VM_PROFILE)
    11→
    12→
    13→class Keyword_tests(unittest.TestCase):
    14→    @given(x=st.integers(), y=st.integers(), z=st.integers())
    15→    def test_all_keywords(self, x: int, y: int, z: int):
    16→        source_code = """
    17→def simple_example(x: int, y: int, z: int) -> int:
    18→    return (x-y)*z
    19→
    20→def validator(a: int, b: int, c: int) -> int:
    21→    return simple_example(x=a, y=b, z=c)
    22→"""
    23→        ret = eval_uplc_value(source_code, x, y, z)
    24→        self.assertEqual(ret, (x - y) * z)
    25→
    26→    @given(x=st.integers(), y=st.integers(), z=st.integers())
    27→    def test_mixture_args_and_keywords(self, x: int, y: int, z: int):
    28→        source_code = """
    29→def simple_example(x: int, y: int, z: int) -> int:
    30→    return (x-y)*z
    31→
    32→def validator(a: int, b: int, c: int) -> int:
    33→    return simple_example(a, b, z=c)
    34→"""
    35→        ret = eval_uplc_value(source_code, x, y, z)
    36→        self.assertEqual(ret, (x - y) * z)
    37→
    38→    @given(x=st.integers(), y=st.integers(), z=st.integers())
    39→    def test_keyword_position_independence(self, x: int, y: int, z: int):
    40→        source_code = """
    41→def simple_example(x: int, y: int, z:int) -> int:
    42→    return (x-y)*z
    43→
    44→def validator(a: int, b: int, c: int) -> int:
    45→    return simple_example(z=c, x=a, y=b)
    46→"""
    47→        ret = eval_uplc_value(source_code, x, y, z)
    48→        self.assertEqual(ret, (x - y) * z)
    49→
    50→    @given(x=st.integers(), y=st.integers(), z=st.integers())
    51→    def test_arg_after_keyword_failure(self, x: int, y: int, z: int):
    52→        source_code = """
    53→def simple_example(x: int, y: int, z:int) -> int:
    54→    return (x-y)*z
    55→
    56→def validator(a: int, b: int, c: int) -> int:
    57→    return simple_example(x=a, y=b, c)
    58→"""
    59→        with self.assertRaises(Exception):
    60→            ret = eval_uplc_value(source_code, x, y, z)
    61→
    62→    @given(x=st.integers(), y=st.integers(), z=st.integers())
    63→    def test_too_many_keywords_failure(self, x: int, y: int, z: int):
    64→        source_code = """
    65→def simple_example(x: int, y: int) -> int:
    66→    return x-y
    67→
    68→def validator(a: int, b: int, c: int) -> int:
    69→    return simple_example(x=a, y=b, z=c)
    70→"""
    71→        with self.assertRaises(Exception):
    72→            ret = eval_uplc_value(source_code, x, y, z)
    73→
    74→    @given(x=st.integers(), y=st.integers(), z=st.integers())
    75→    def test_incorrect_keywords_failure(self, x: int, y: int, z: int):
    76→        source_code = """
    77→def simple_example(x: int, y: int, z: int) -> int:
    78→    return (x-y)*z
    79→
    80→def validator(a: int, b: int, c: int) -> int:
    81→    return simple_example(x=a, y=b, k=c)
    82→"""
    83→        with self.assertRaises(Exception):
    84→            ret = eval_uplc_value(source_code, x, y, z)
    85→
    86→    @given(x=st.integers(), y=st.integers(), z=st.integers())
    87→    def test_correct_scope(self, x: int, y: int, z: int):
    88→        source_code = """
    89→def simple_example(x: int, y: int, z: int) -> int:
    90→    def simple_example(new_x: int, new_z: int) -> int:
    91→        return new_x-new_z
    92→    return simple_example(new_x = x, new_z = z) * y
    93→
    94→def validator(a: int, b: int, c: int) -> int:
    95→    return simple_example(x=a, y=b, z=c)
    96→"""
    97→        ret = eval_uplc_value(source_code, x, y, z)
    98→        self.assertEqual(ret, (x - z) * y)
    99→

  1013→    _type_inferencer: AggressiveTypeInferencer
  1014→
  1015→    def __init__(self, type_inferencer: AggressiveTypeInferencer):
  1016→        self.constructor = None
  1017→        self.attributes = []
  1018→        self._type_inferencer = type_inferencer
  1019→
  1020→    @classmethod
  1021→    def extract(cls, c: ClassDef, type_inferencer: AggressiveTypeInferencer) -> Record:
  1022→        f = cls(type_inferencer)
  1023→        f.visit(c)
  1024→        if f.constructor is None:
  1025→            det_string = RecordType(
  1026→                Record(f.name, f.orig_name, 0, frozenlist(f.attributes))
  1027→            ).id_map(skip_constructor=True)
  1028→            det_hash = sha256(str(det_string).encode("utf8")).hexdigest()
  1029→            f.constructor = int(det_hash, 16) % 2**32
  1030→        return Record(f.name, f.orig_name, f.constructor, frozenlist(f.attributes))
  1031→
  1032→    def visit_AnnAssign(self, node: AnnAssign) -> None:
  1033→        assert isinstance(
  1034→            node.target, Name
  1035→        ), "Record elements must have named attributes"
  1036→        typ = self._type_inferencer.type_from_annotation(node.annotation)
  1037→        if node.target.id != "CONSTR_ID":
  1038→            assert (
  1039→                node.value is None
  1040→            ), f"PlutusData attribute {node.target.id} may not have a default value"
  1041→            assert not isinstance(
  1042→                typ, TupleType
  1043→            ), "Records can currently not hold tuples"
  1044→            self.attributes.append(
  1045→                (
  1046→                    node.target.id,
  1047→                    InstanceType(typ),
  1048→                )
  1049→            )
  1050→            return
  1051→        assert typ == IntegerType, "CONSTR_ID must be assigned an integer"
  1052→        assert isinstance(
  1053→            node.value, Constant
  1054→        ), "CONSTR_ID must be assigned a constant integer"
  1055→        assert isinstance(
  1056→            node.value.value, int
  1057→        ), "CONSTR_ID must be assigned an integer"
  1058→        self.constructor = node.value.value
  1059→
  1060→    def visit_ClassDef(self, node: ClassDef) -> None:
  1061→        self.name = node.name
  1062→        self.orig_name = node.orig_name
  1063→        for s in node.body:
  1064→            self.visit(s)
  1065→
  1066→    def visit_Pass(self, node: Pass) -> None:
  1067→        pass
  1068→
  1069→    def visit_Assign(self, node: Assign) -> None:
  1070→        assert len(node.targets) == 1, "Record elements must be assigned one by one"
  1071→        target = node.targets[0]
  1072→        assert isinstance(target, Name), "Record elements must have named attributes"
  1073→        assert (
  1074→            target.id == "CONSTR_ID"
  1075→        ), "Type annotations may only be omitted for CONSTR_ID"
  1076→        assert isinstance(
  1077→            node.value, Constant
  1078→        ), "CONSTR_ID must be assigned a constant integer"
  1079→        assert isinstance(
  1080→            node.value.value, int
  1081→        ), "CONSTR_ID must be assigned an integer"
  1082→        self.constructor = node.value.value
  1083→
  1084→    def visit_Expr(self, node: Expr) -> None:
  1085→        assert isinstance(
  1086→            node.value, Constant
  1087→        ), "Only comments are allowed inside classes"
  1088→        return None
  1089→
  1090→    def generic_visit(self, node: AST) -> None:
  1091→        raise NotImplementedError(f"Can not compile {ast.dump(node)} inside of a class")
  1092→
  1093→
  1094→def typed_ast(ast: AST):
  1095→    return AggressiveTypeInferencer().visit(ast)
  1096→
  1097→
  1098→def map_to_orig_name(name: str):
  1099→    return re.sub(r"_\d+$", "", name)
  1100→
  1101→
  1102→class ReturnExtractor(TypedNodeVisitor):
  1103→    """
  1104→    Utility to check that all paths end in Return statements with the proper type
  1105→
  1106→    Returns whether there is no remaining path
  1107→    """
  1108→
  1109→    def __init__(self, func_rettyp: Type):
  1110→        self.func_rettyp = func_rettyp
  1111→
  1112→    def visit_sequence(self, nodes: typing.List[TypedAST]) -> bool:

8c9b34b Merge pull request #386 from SCMusson/feat_allow_keywords
1452acb Merge pull request #386 from SCMusson/feat_allow_keywords

diff --git a/opshin/type_inference.py b/opshin/type_inference.py
index 5a10d06..51b5cc7 100644
--- a/opshin/type_inference.py
+++ b/opshin/type_inference.py
@@ -361,6 +361,10 @@ class AggressiveTypeInferencer(CompilingNodeTransformer):
         class_record = RecordReader.extract(node, self)
         typ = RecordType(class_record)
         self.set_variable_type(node.name, typ)
+        self.FUNCTION_ARGUMENT_REGISTRY[node.name] = [
+            typedarg(arg=field, typ=field_typ, orig_arg=field)
+            for field, field_typ in class_record.fields
+        ]
         typed_node = copy(node)
         typed_node.class_typ = typ
         return typed_node

363-        self.set_variable_type(node.name, typ)
364-        self.FUNCTION_ARGUMENT_REGISTRY[node.name] = [
365:            typedarg(arg=field, typ=field_typ, orig_arg=field)
366-            for field, field_typ in class_record.fields
367-        ]
--
559-        return typed_cmp
560-
561:    def visit_arg(self, node: arg) -> typedarg:
562-        ta = copy(node)
563-        ta.typ = InstanceType(self.type_from_annotation(node.annotation))
--
565-        return ta
566-
567:    def visit_arguments(self, node: arguments) -> typedarguments:
568-        if node.kw_defaults or node.kwarg or node.kwonlyargs or node.defaults:
569-            raise NotImplementedError(

/testbed/opshin/type_inference.py-364-        self.FUNCTION_ARGUMENT_REGISTRY[node.name] = [
opshin/type_inference.py:365:            typedarg(arg=field, typ=field_typ, orig_arg=field)
/testbed/opshin/type_inference.py-366-            for field, field_typ in class_record.fields
--
/testbed/opshin/type_inference.py-560-
opshin/type_inference.py:561:    def visit_arg(self, node: arg) -> typedarg:
/testbed/opshin/type_inference.py-562-        ta = copy(node)
--
/testbed/opshin/typed_ast.py-18-
opshin/typed_ast.py:19:class typedarg(TypedAST, arg):
/testbed/opshin/typed_ast.py-20-    pass
--
/testbed/opshin/typed_ast.py-22-
opshin/typed_ast.py:23:class typedarguments(TypedAST, arguments):
opshin/typed_ast.py:24:    args: typing.List[typedarg]
opshin/typed_ast.py:25:    vararg: typing.Union[typedarg, None]
opshin/typed_ast.py:26:    kwonlyargs: typing.List[typedarg]
opshin/typed_ast.py-27-    kw_defaults: typing.List[typing.Union[typedexpr, None]]
opshin/typed_ast.py:28:    kwarg: typing.Union[typedarg, None]
opshin/typed_ast.py-29-    defaults: typing.List[typedexpr]

     1→from .type_impls import *
     2→
     3→
     4→class TypedAST(AST):
     5→    typ: Type
     6→
     7→
     8→class typedexpr(TypedAST, expr):
     9→    def typechecks(self) -> typing.Dict[str, Type]:
    10→        """Successful typechecks if this expression evaluates to True"""
    11→        return {}
    12→
    13→
    14→class typedstmt(TypedAST, stmt):
    15→    # Statements always have type None
    16→    typ = NoneInstanceType
    17→
    18→
    19→class typedarg(TypedAST, arg):
    20→    pass
    21→
    22→
    23→class typedarguments(TypedAST, arguments):
    24→    args: typing.List[typedarg]
    25→    vararg: typing.Union[typedarg, None]
    26→    kwonlyargs: typing.List[typedarg]
    27→    kw_defaults: typing.List[typing.Union[typedexpr, None]]
    28→    kwarg: typing.Union[typedarg, None]
    29→    defaults: typing.List[typedexpr]
    30→

opshin/type_inference.py:365:            typedarg(arg=field, typ=field_typ, orig_arg=field)
opshin/type_inference.py:791:                        if keyword.arg == a.orig_arg
opshin/type_inference.py:795:                    ), f"There should be one keyword or positional argument for the arg {a.orig_arg} but found {len(candidates)}"
opshin/rewrite/rewrite_orig_name.py:34:            a_cp.orig_arg = a.arg

     1→from ast import *
     2→from copy import copy
     3→from ..util import CompilingNodeTransformer
     4→
     5→"""
     6→Rewrites all occurrences of names to contain a pointer to the original name for good
     7→"""
     8→
     9→
    10→class RewriteOrigName(CompilingNodeTransformer):
    11→    step = "Assigning the orig_id/orig_name field with the variable name"
    12→
    13→    def visit_Name(self, node: Name) -> Name:
    14→        nc = copy(node)
    15→        nc.orig_id = node.id
    16→        return nc
    17→
    18→    def visit_ClassDef(self, node: ClassDef) -> ClassDef:
    19→        node_cp = copy(node)
    20→        node_cp.orig_name = node.name
    21→        node_cp.body = [self.visit(n) for n in node.body]
    22→        return node_cp
    23→
    24→    def visit_NoneType(self, node: None) -> None:
    25→        return None
    26→
    27→    def visit_FunctionDef(self, node: FunctionDef) -> FunctionDef:
    28→        node_cp = copy(node)
    29→        node_cp.orig_name = node.name
    30→        node_cp.args = copy(node.args)
    31→        node_cp.args.args = []
    32→        for a in node.args.args:
    33→            a_cp = self.visit(a)
    34→            a_cp.orig_arg = a.arg
    35→            node_cp.args.args.append(a_cp)
    36→        node_cp.returns = self.visit(node.returns)
    37→        node_cp.decorator_list = [self.visit(l) for l in node.decorator_list]
    38→        node_cp.body = [self.visit(s) for s in node.body]
    39→        return node_cp
    40→

No matches found

No matches found

/testbed/opshin/type_inference.py:        if isinstance(node.func, Name) and node.func.orig_id == SPECIAL_BOOL:
/testbed/opshin/type_inference.py:        if not (isinstance(node.func, Name) and node.func.orig_id == "isinstance"):
/testbed/opshin/type_inference.py:            f"Variable {map_to_orig_name(name)} not initialized at access"
/testbed/opshin/type_inference.py:                f"Type {self.scopes[-1][name]} of variable {map_to_orig_name(name)} in local scope does not match inferred type {typ}"
/testbed/opshin/type_inference.py:                f"Class name {ann.orig_id} not initialized before annotating variable"
/testbed/opshin/type_inference.py:            if ann.value.orig_id == "Union":
/testbed/opshin/type_inference.py:            if ann.value.orig_id == "List":
/testbed/opshin/type_inference.py:            if ann.value.orig_id == "Dict":
/testbed/opshin/type_inference.py:            if ann.value.orig_id == "Tuple":
/testbed/opshin/type_inference.py:                isinstance(o, Name) and o.orig_id == "wraps_builtin"
/testbed/opshin/type_inference.py:        if isinstance(ts.value, Name) and ts.value.orig_id in [
/testbed/opshin/type_inference.py:                    ts.slice.upper.func.orig_id = "len"
/testbed/opshin/type_inference.py:                    ts.slice.upper.func.orig_id = "len"
/testbed/opshin/type_inference.py:        if isinstance(tc.func, Name) and tc.func.orig_id == "isinstance":
/testbed/opshin/type_inference.py:def map_to_orig_name(name: str):
/testbed/opshin/rewrite/rewrite_orig_name.py:    step = "Assigning the orig_id/orig_name field with the variable name"
/testbed/opshin/rewrite/rewrite_orig_name.py:        nc.orig_id = node.id
/testbed/opshin/compiler.py:                                plt.TraceError(f"NameError: {map_to_orig_name(x)}")
/testbed/opshin/compiler.py:                        plt.Delay(plt.TraceError(f"NameError: {map_to_orig_name(x)}")),

No matches found

/testbed/opshin/type_inference.py:19:from .typed_ast import *
/testbed/opshin/type_inference.py:241:class AggressiveTypeInferencer(CompilingNodeTransformer):
/testbed/opshin/type_inference.py:1013:    _type_inferencer: AggressiveTypeInferencer
/testbed/opshin/type_inference.py:1015:    def __init__(self, type_inferencer: AggressiveTypeInferencer):
/testbed/opshin/type_inference.py:1021:    def extract(cls, c: ClassDef, type_inferencer: AggressiveTypeInferencer) -> Record:
/testbed/opshin/type_inference.py:1094:def typed_ast(ast: AST):
/testbed/opshin/type_inference.py:1095:    return AggressiveTypeInferencer().visit(ast)
/testbed/opshin/rewrite/rewrite_import_hashlib.py:5:from ..typed_ast import *
/testbed/opshin/rewrite/rewrite_import_integrity_check.py:8:from ..typed_ast import *
/testbed/opshin/rewrite/rewrite_remove_type_stuff.py:3:from ..typed_ast import (
/testbed/opshin/rewrite/rewrite_orig_name.py:10:class RewriteOrigName(CompilingNodeTransformer):
/testbed/opshin/rewrite/rewrite_inject_builtins.py:3:from ..typed_ast import *
/testbed/opshin/rewrite/rewrite_import_uplc_builtins.py:7:from ..typed_ast import *
/testbed/opshin/rewrite/rewrite_empty_dicts.py:7:from ..typed_ast import *
/testbed/opshin/rewrite/rewrite_empty_lists.py:7:from ..typed_ast import *
/testbed/opshin/rewrite/rewrite_inject_builtin_constr.py:3:from ..typed_ast import *
/testbed/opshin/fun_impls.py:3:from .typed_ast import *
/testbed/opshin/optimize/optimize_remove_deadvars.py:9:from ..typed_ast import TypedAnnAssign, TypedFunctionDef, TypedClassDef, TypedName
/testbed/opshin/compiler.py:24:from .rewrite.rewrite_orig_name import RewriteOrigName
/testbed/opshin/compiler.py:36:from .typed_ast import (
/testbed/opshin/compiler.py:1052:        RewriteOrigName(),
/testbed/opshin/compiler.py:1055:        AggressiveTypeInferencer(config.allow_isinstance_anything),

1045→        RewriteImportHashlib(),
  1046→        RewriteImportTyping(),
  1047→        RewriteForbiddenOverwrites(),
  1048→        RewriteImportDataclasses(),
  1049→        RewriteInjectBuiltins(),
  1050→        RewriteConditions(),
  1051→        # Save the original names of variables
  1052→        RewriteOrigName(),
  1053→        RewriteScoping(),
  1054→        # The type inference needs to be run after complex python operations were rewritten
  1055→        AggressiveTypeInferencer(config.allow_isinstance_anything),
  1056→        # Rewrites that circumvent the type inference or use its results
  1057→        RewriteEmptyLists(),
  1058→        RewriteEmptyDicts(),
  1059→        RewriteImportUPLCBuiltins(),
  1060→        RewriteInjectBuiltinsConstr(),
  1061→        RewriteRemoveTypeStuff(),
  1062→        # Apply optimizations
  1063→        OptimizeRemoveDeadvars() if config.remove_dead_code else NoOp(),
  1064→        OptimizeRemoveDeadconstants() if config.remove_dead_code else NoOp(),
  1065→        OptimizeRemovePass(),
  1066→    ]
  1067→    for s in compile_pipeline:
  1068→        prog = s.visit(prog)
  1069→        prog = custom_fix_missing_locations(prog)
  1070→
  1071→    # the compiler runs last
  1072→    s = PlutoCompiler(
  1073→        force_three_params=config.force_three_params,
  1074→        validator_function_name=validator_function_name,
  1075→    )
  1076→    prog = s.visit(prog)
  1077→
  1078→    return prog
  1079→

Found 2 files
opshin/rewrite/rewrite_scoping.py
opshin/compiler.py

     1→import typing
     2→from ast import *
     3→from copy import copy
     4→
     5→from ordered_set import OrderedSet
     6→
     7→from .rewrite_forbidden_overwrites import FORBIDDEN_NAMES
     8→from ..type_inference import INITIAL_SCOPE
     9→from ..util import CompilingNodeTransformer, CompilingNodeVisitor
    10→
    11→"""
    12→Rewrites all variable names to point to the definition in the nearest enclosing scope
    13→"""
    14→
    15→
    16→class ShallowNameDefCollector(CompilingNodeVisitor):
    17→    step = "Collecting defined variable names"
    18→
    19→    def __init__(self):
    20→        self.vars = OrderedSet()
    21→
    22→    def visit_Name(self, node: Name) -> None:
    23→        if isinstance(node.ctx, Store):
    24→            self.vars.add(node.id)
    25→
    26→    def visit_ClassDef(self, node: ClassDef):
    27→        self.vars.add(node.name)
    28→        # ignore the content (i.e. attribute names) of class definitions
    29→
    30→    def visit_FunctionDef(self, node: FunctionDef):
    31→        self.vars.add(node.name)
    32→        # ignore the recursive stuff
    33→
    34→
    35→class RewriteScoping(CompilingNodeTransformer):
    36→    step = "Rewrite all variables to inambiguously point to the definition in the nearest enclosing scope"
    37→    latest_scope_id: int
    38→    scopes: typing.List[typing.Tuple[OrderedSet, int]]
    39→
    40→    def variable_scope_id(self, name: str) -> int:
    41→        """find the id of the scope in which this variable is defined (closest to its usage)"""
    42→        name = name
    43→        for scope, scope_id in reversed(self.scopes):
    44→            if name in scope:
    45→                return scope_id
    46→        raise NameError(
    47→            f"free variable '{name}' referenced before assignment in enclosing scope"
    48→        )
    49→
    50→    def enter_scope(self):
    51→        self.scopes.append((OrderedSet(), self.latest_scope_id))
    52→        self.latest_scope_id += 1
    53→
    54→    def exit_scope(self):
    55→        self.scopes.pop()
    56→
    57→    def set_variable_scope(self, name: str):
    58→        self.scopes[-1][0].add(name)
    59→
    60→    def map_name(self, name: str):
    61→        scope_id = self.variable_scope_id(name)
    62→        if scope_id == -1:
    63→            # do not rewrite Dict, Union, etc
    64→            return name
    65→        return f"{name}_{scope_id}"
    66→
    67→    def visit_Module(self, node: Module) -> Module:
    68→        self.latest_scope_id = 0
    69→        self.scopes = [(OrderedSet(INITIAL_SCOPE.keys() | FORBIDDEN_NAMES), -1)]
    70→        node_cp = copy(node)
    71→        self.enter_scope()
    72→        # vars defined in this scope
    73→        shallow_node_def_collector = ShallowNameDefCollector()
    74→        for s in node.body:
    75→            shallow_node_def_collector.visit(s)
    76→        vars_def = shallow_node_def_collector.vars
    77→        for var_name in vars_def:
    78→            self.set_variable_scope(var_name)
    79→        node_cp.body = [self.visit(s) for s in node.body]
    80→        return node_cp
    81→
    82→    def visit_Name(self, node: Name) -> Name:
    83→        nc = copy(node)
    84→        # setting is handled in either enclosing module or function
    85→        nc.id = self.map_name(node.id)
    86→        return nc
    87→
    88→    def visit_ClassDef(self, node: ClassDef) -> ClassDef:
    89→        return RecordScoper.scope(node, self)
    90→
    91→    def visit_FunctionDef(self, node: FunctionDef) -> FunctionDef:
    92→        node_cp = copy(node)
    93→        # setting is handled in either enclosing module or function
    94→        node_cp.name = self.map_name(node.name)
    95→        self.enter_scope()
    96→        node_cp.args = copy(node.args)
    97→        node_cp.args.args = []
    98→        # args are defined in this scope
    99→        for a in node.args.args:
   100→            a_cp = copy(a)
   101→            self.set_variable_scope(a.arg)
   102→            a_cp.arg = self.map_name(a.arg)
   103→            a_cp.annotation = self.visit(a.annotation)
   104→            node_cp.args.args.append(a_cp)
   105→        node_cp.returns = self.visit(node.returns)
   106→        # vars defined in this scope
   107→        shallow_node_def_collector = ShallowNameDefCollector()
   108→        for s in node.body:
   109→            shallow_node_def_collector.visit(s)
   110→        vars_def = shallow_node_def_collector.vars
   111→        for var_name in vars_def:
   112→            self.set_variable_scope(var_name)
   113→        # map all vars and recurse
   114→        node_cp.body = [self.visit(s) for s in node.body]
   115→        self.exit_scope()
   116→        return node_cp
   117→
   118→    def visit_NoneType(self, node: None) -> None:
   119→        return node
   120→
   121→
   122→class RecordScoper(NodeTransformer):
   123→    _scoper: RewriteScoping
   124→
   125→    def __init__(self, scoper: RewriteScoping):
   126→        self._scoper = scoper
   127→
   128→    @classmethod
   129→    def scope(cls, c: ClassDef, scoper: RewriteScoping) -> ClassDef:
   130→        f = cls(scoper)
   131→        return f.visit(c)
   132→
   133→    def visit_ClassDef(self, c: ClassDef) -> ClassDef:
   134→        node_cp = copy(c)
   135→        node_cp.name = self._scoper.map_name(node_cp.name)
   136→        return self.generic_visit(node_cp)
   137→
   138→    def visit_AnnAssign(self, node: AnnAssign) -> AnnAssign:
   139→        assert isinstance(
   140→            node.target, Name
   141→        ), "Record elements must have named attributes"
   142→        node_cp = copy(node)
   143→        node_cp.annotation = self._scoper.visit(node_cp.annotation)
   144→        return node_cp
   145→

   775→    def visit_Call(self, node: Call) -> TypedCall:
   776→        tc = copy(node)
   777→        if node.keywords:
   778→            assert (
   779→                node.func.id in self.FUNCTION_ARGUMENT_REGISTRY
   780→            ), "Keyword arguments can only be used with user defined functions"
   781→            keywords = copy(node.keywords)
   782→            reg_args = self.FUNCTION_ARGUMENT_REGISTRY[node.func.id]
   783→            args = []
   784→            for i, a in enumerate(reg_args):
   785→                if len(node.args) > i:
   786→                    args.append(self.visit(node.args[i]))
   787→                else:
   788→                    candidates = [
   789→                        (idx, keyword)
   790→                        for idx, keyword in enumerate(keywords)
   791→                        if keyword.arg == a.orig_arg
   792→                    ]
   793→                    assert (
   794→                        len(candidates) == 1
   795→                    ), f"There should be one keyword or positional argument for the arg {a.orig_arg} but found {len(candidates)}"
   796→                    args.append(self.visit(candidates[0][1].value))
   797→                    keywords.pop(candidates[0][0])
   798→            assert (
   799→                len(keywords) == 0
   800→            ), f"Could not match the keywords {[keyword.arg for keyword in keywords]} to any argument"
   801→            tc.args = args
   802→            tc.keywords = []
   803→        else:
   804→            tc.args = [self.visit(a) for a in node.args]
   805→
   806→        # might be isinstance
   807→        if isinstance(tc.func, Name) and tc.func.orig_id == "isinstance":
   808→            target_class = tc.args[1].typ
   809→            if (
   810→                isinstance(tc.args[0].typ, InstanceType)
   811→                and isinstance(tc.args[0].typ.typ, AnyType)
   812→                and not self.allow_isinstance_anything
   813→            ):
   814→                raise AssertionError(
   815→                    "OpShin does not permit checking the instance of raw Anything/Datum objects as this only checks the equality of the constructor id and nothing more. "
   816→                    "If you are certain of what you are doing, please use the flag '--allow-isinstance-anything'."
   817→                )
   818→            ntc = Compare(
   819→                left=Attribute(tc.args[0], "CONSTR_ID"),
   820→                ops=[Eq()],
   821→                comparators=[Constant(target_class.record.constructor)],
   822→            )
   823→            custom_fix_missing_locations(ntc, node)
   824→            ntc = self.visit(ntc)
   825→            ntc.typ = BoolInstanceType
   826→            ntc.typechecks = TypeCheckVisitor(self.allow_isinstance_anything).visit(tc)
   827→            return ntc
   828→        tc.func = self.visit(node.func)
   829→        # might be a class
   830→        if isinstance(tc.func.typ, ClassType):
   831→            tc.func.typ = tc.func.typ.constr_type()
   832→        # type might only turn out after the initialization (note the constr could be polymorphic)
   833→        if isinstance(tc.func.typ, InstanceType) and isinstance(
   834→            tc.func.typ.typ, PolymorphicFunctionType
   835→        ):
   836→            tc.func.typ = PolymorphicFunctionInstanceType(
   837→                tc.func.typ.typ.polymorphic_function.type_from_args(
   838→                    [a.typ for a in tc.args]
   839→                ),
   840→                tc.func.typ.typ.polymorphic_function,
   841→            )
   842→        if isinstance(tc.func.typ, InstanceType) and isinstance(
   843→            tc.func.typ.typ, FunctionType
   844→        ):
   845→            functyp = tc.func.typ.typ
   846→            assert len(tc.args) == len(
   847→                functyp.argtyps
   848→            ), f"Signature of function does not match number of arguments. Expected {len(functyp.argtyps)} arguments with these types: {functyp.argtyps} but got {len(tc.args)} arguments."
   849→            # all arguments need to be subtypes of the parameter type
   850→            for i, (a, ap) in enumerate(zip(tc.args, functyp.argtyps)):
   851→                assert (
   852→                    ap >= a.typ
   853→                ), f"Signature of function does not match arguments in argument {i}. Expected this type: {ap} but got {a.typ}."
   854→            tc.typ = functyp.rettyp
   855→            return tc
   856→        raise TypeInferenceError("Could not infer type of call")
   857→
   858→    def visit_Pass(self, node: Pass) -> TypedPass:
   859→        tp = copy(node)
   860→        return tp
   861→
   862→    def visit_Return(self, node: Return) -> TypedReturn:
   863→        tp = copy(node)
   864→        tp.value = self.visit(node.value)
   865→        tp.typ = tp.value.typ
   866→        return tp
   867→
   868→    def visit_Attribute(self, node: Attribute) -> TypedAttribute:
   869→        tp = copy(node)
   870→        tp.value = self.visit(node.value)
   871→        owner = tp.value.typ
   872→        # accesses to field
   873→        tp.typ = owner.attribute_type(node.attr)
   874→        return tp

1452acb931a6e494a315099697115945f504e3cf
1452acb Merge pull request #386 from SCMusson/feat_allow_keywords
daa5af6 Remove superfluous line in tests
c595159 fix test bug

246:        self.FUNCTION_ARGUMENT_REGISTRY = {}
360:    def visit_ClassDef(self, node: ClassDef) -> TypedClassDef:
607:        self.FUNCTION_ARGUMENT_REGISTRY[node.name] = node.args.args
775:                node.func.id in self.FUNCTION_ARGUMENT_REGISTRY
778:            reg_args = self.FUNCTION_ARGUMENT_REGISTRY[node.func.id]
1056:    def visit_ClassDef(self, node: ClassDef) -> None:

rootdir: /testbed
configfile: pyproject.toml
plugins: hypothesis-6.151.9, typeguard-4.5.1
collecting ... collected 7 items

opshin/tests/test_keywords.py::Keyword_tests::test_all_keywords PASSED   [ 14%]
opshin/tests/test_keywords.py::Keyword_tests::test_arg_after_keyword_failure PASSED [ 28%]
opshin/tests/test_keywords.py::Keyword_tests::test_correct_scope PASSED  [ 42%]
opshin/tests/test_keywords.py::Keyword_tests::test_incorrect_keywords_failure PASSED [ 57%]
opshin/tests/test_keywords.py::Keyword_tests::test_keyword_position_independence PASSED [ 71%]
opshin/tests/test_keywords.py::Keyword_tests::test_mixture_args_and_keywords PASSED [ 85%]
opshin/tests/test_keywords.py::Keyword_tests::test_too_many_keywords_failure PASSED [100%]

=============================== warnings summary ===============================
../usr/local/lib/python3.11/site-packages/blockfrost/config.py:2
  /usr/local/lib/python3.11/site-packages/blockfrost/config.py:2: DeprecationWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html
    import pkg_resources

-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
========================= 7 passed, 1 warning in 3.31s =========================

360→    def visit_ClassDef(self, node: ClassDef) -> TypedClassDef:
   361→        class_record = RecordReader.extract(node, self)
   362→        typ = RecordType(class_record)
   363→        self.set_variable_type(node.name, typ)
   364→        self.FUNCTION_ARGUMENT_REGISTRY[node.name] = [
   365→            typedarg(arg=field, typ=field_typ, orig_arg=field)
   366→            for field, field_typ in class_record.fields
   367→        ]
   368→        typed_node = copy(node)
   369→        typed_node.class_typ = typ
   370→        return typed_node
   371→
   372→    def visit_Constant(self, node: Constant) -> TypedConstant:
   373→        tc = copy(node)
   374→        assert type(node.value) not in [

Result: 1

Reordered result: 3
Wrong keyword correctly fails: CompilerError (AssertionError('There should be one keyword or positional argument for the arg z but found 0'), <as

     1→import unittest
     2→
     3→import hypothesis
     4→from hypothesis import given
     5→from hypothesis import strategies as st
     6→from .utils import eval_uplc_value
     7→from . import PLUTUS_VM_PROFILE
     8→
     9→
    10→hypothesis.settings.load_profile(PLUTUS_VM_PROFILE)
    11→
    12→
    13→class Keyword_tests(unittest.TestCase):
    14→    @given(x=st.integers(), y=st.integers(), z=st.integers())
    15→    def test_all_keywords(self, x: int, y: int, z: int):
    16→        source_code = """
    17→def simple_example(x: int, y: int, z: int) -> int:
    18→    return (x-y)*z
    19→
    20→def validator(a: int, b: int, c: int) -> int:
    21→    return simple_example(x=a, y=b, z=c)
    22→"""
    23→        ret = eval_uplc_value(source_code, x, y, z)
    24→        self.assertEqual(ret, (x - y) * z)
    25→
    26→    @given(x=st.integers(), y=st.integers(), z=st.integers())
    27→    def test_mixture_args_and_keywords(self, x: int, y: int, z: int):
    28→        source_code = """
    29→def simple_example(x: int, y: int, z: int) -> int:
    30→    return (x-y)*z
    31→
    32→def validator(a: int, b: int, c: int) -> int:
    33→    return simple_example(a, b, z=c)
    34→"""
    35→        ret = eval_uplc_value(source_code, x, y, z)
    36→        self.assertEqual(ret, (x - y) * z)
    37→
    38→    @given(x=st.integers(), y=st.integers(), z=st.integers())
    39→    def test_keyword_position_independence(self, x: int, y: int, z: int):
    40→        source_code = """
    41→def simple_example(x: int, y: int, z:int) -> int:
    42→    return (x-y)*z
    43→
    44→def validator(a: int, b: int, c: int) -> int:
    45→    return simple_example(z=c, x=a, y=b)
    46→"""
    47→        ret = eval_uplc_value(source_code, x, y, z)
    48→        self.assertEqual(ret, (x - y) * z)
    49→
    50→    @given(x=st.integers(), y=st.integers(), z=st.integers())
    51→    def test_arg_after_keyword_failure(self, x: int, y: int, z: int):
    52→        source_code = """
    53→def simple_example(x: int, y: int, z:int) -> int:
    54→    return (x-y)*z
    55→
    56→def validator(a: int, b: int, c: int) -> int:
    57→    return simple_example(x=a, y=b, c)
    58→"""
    59→        with self.assertRaises(Exception):
    60→            ret = eval_uplc_value(source_code, x, y, z)
    61→
    62→    @given(x=st.integers(), y=st.integers(), z=st.integers())
    63→    def test_too_many_keywords_failure(self, x: int, y: int, z: int):
    64→        source_code = """
    65→def simple_example(x: int, y: int) -> int:
    66→    return x-y
    67→
    68→def validator(a: int, b: int, c: int) -> int:
    69→    return simple_example(x=a, y=b, z=c)
    70→"""
    71→        with self.assertRaises(Exception):
    72→            ret = eval_uplc_value(source_code, x, y, z)
    73→
    74→    @given(x=st.integers(), y=st.integers(), z=st.integers())
    75→    def test_incorrect_keywords_failure(self, x: int, y: int, z: int):
    76→        source_code = """
    77→def simple_example(x: int, y: int, z: int) -> int:
    78→    return (x-y)*z
    79→
    80→def validator(a: int, b: int, c: int) -> int:
    81→    return simple_example(x=a, y=b, k=c)
    82→"""
    83→        with self.assertRaises(Exception):
    84→            ret = eval_uplc_value(source_code, x, y, z)
    85→
    86→    @given(x=st.integers(), y=st.integers(), z=st.integers())
    87→    def test_correct_scope(self, x: int, y: int, z: int):
    88→        source_code = """
    89→def simple_example(x: int, y: int, z: int) -> int:
    90→    def simple_example(new_x: int, new_z: int) -> int:
    91→        return new_x-new_z
    92→    return simple_example(new_x = x, new_z = z) * y
    93→
    94→def validator(a: int, b: int, c: int) -> int:
    95→    return simple_example(x=a, y=b, z=c)
    96→"""
    97→        ret = eval_uplc_value(source_code, x, y, z)
    98→        self.assertEqual(ret, (x - z) * y)
    99→

The file /testbed/opshin/tests/test_keywords.py has been updated successfully.

cachedir: .pytest_cache
hypothesis profile 'default'
rootdir: /testbed
configfile: pyproject.toml
plugins: hypothesis-6.151.9, typeguard-4.5.1
collecting ... collected 10 items

opshin/tests/test_keywords.py::Keyword_tests::test_all_keywords PASSED   [ 10%]
opshin/tests/test_keywords.py::Keyword_tests::test_arg_after_keyword_failure PASSED [ 20%]
opshin/tests/test_keywords.py::Keyword_tests::test_correct_scope PASSED  [ 30%]
opshin/tests/test_keywords.py::Keyword_tests::test_incorrect_keywords_failure PASSED [ 40%]
opshin/tests/test_keywords.py::Keyword_tests::test_keyword_position_independence PASSED [ 50%]
opshin/tests/test_keywords.py::Keyword_tests::test_mixture_args_and_keywords PASSED [ 60%]
opshin/tests/test_keywords.py::Keyword_tests::test_plutusdata_all_keywords PASSED [ 70%]
opshin/tests/test_keywords.py::Keyword_tests::test_plutusdata_incorrect_keywords_failure PASSED [ 80%]
opshin/tests/test_keywords.py::Keyword_tests::test_plutusdata_keyword_position_independence PASSED [ 90%]
opshin/tests/test_keywords.py::Keyword_tests::test_too_many_keywords_failure PASSED [100%]

=============================== warnings summary ===============================
../usr/local/lib/python3.11/site-packages/blockfrost/config.py:2
  /usr/local/lib/python3.11/site-packages/blockfrost/config.py:2: DeprecationWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html
    import pkg_resources

-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
======================== 10 passed, 1 warning in 10.52s ========================