pyscript-programming-language 1.10.3__tar.gz → 1.10.4__tar.gz

{pyscript_programming_language-1.10.3/pyscript_programming_language.egg-info → pyscript_programming_language-1.10.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyscript-programming-language
-Version: 1.10.3
+Version: 1.10.4
 Summary: PyScript Programming Language
 Home-page: https://azzammuhyala.github.io/pyscript
 Author: azzammuhyala
@@ -83,5 +83,6 @@ Familiar? There it is!
 
 ## Behind it
 This language created from based up on a
-[YouTube tutorial](https://www.youtube.com/playlist?list=PLZQftyCk7_SdoVexSmwy_tBgs7P0b97yD) (check more on GitHub [here](https://github.com/davidcallanan/py-myopl-code)). At least, it takes
-about 6 months to learn it, and also need to learn general things that exist in other programming languages.
+[YouTube tutorial](https://www.youtube.com/playlist?list=PLZQftyCk7_SdoVexSmwy_tBgs7P0b97yD) (check more on GitHub
+[here](https://github.com/davidcallanan/py-myopl-code)). At least, it takes about 6 months to learn it, and also need to
+learn general things that exist in other programming languages.

{pyscript_programming_language-1.10.3 → pyscript_programming_language-1.10.4}/README.md

@@ -48,5 +48,6 @@ Familiar? There it is!
 
 ## Behind it
 This language created from based up on a
-[YouTube tutorial](https://www.youtube.com/playlist?list=PLZQftyCk7_SdoVexSmwy_tBgs7P0b97yD) (check more on GitHub [here](https://github.com/davidcallanan/py-myopl-code)). At least, it takes
-about 6 months to learn it, and also need to learn general things that exist in other programming languages.
+[YouTube tutorial](https://www.youtube.com/playlist?list=PLZQftyCk7_SdoVexSmwy_tBgs7P0b97yD) (check more on GitHub
+[here](https://github.com/davidcallanan/py-myopl-code)). At least, it takes about 6 months to learn it, and also need to
+learn general things that exist in other programming languages.

{pyscript_programming_language-1.10.3 → pyscript_programming_language-1.10.4}/pyscript/__init__.py

@@ -15,7 +15,7 @@ from .core.cache import undefined, hook
 from .core.highlight import (
     HLFMT_HTML, HLFMT_ANSI, HLFMT_BBCODE, pys_highlight, PygmentsPyScriptStyle, PygmentsPyScriptLexer
 )
-from .core.runner import pys_exec, pys_eval, pys_require, pys_shell
+from .core.runner import pys_runner, pys_exec, pys_eval, pys_require, pys_shell
 from .core.version import version, version_info, __version__, __date__
 
 __all__ = (
@@ -36,6 +36,7 @@ __all__ = (
     'version',
     'version_info',
     'pys_highlight',
+    'pys_runner',
     'pys_exec',
     'pys_eval',
     'pys_require',

{pyscript_programming_language-1.10.3 → pyscript_programming_language-1.10.4}/pyscript/__init__.pyi

@@ -3,6 +3,7 @@ from typing import TYPE_CHECKING, Any, Callable, Iterable, Literal, Optional
 if TYPE_CHECKING:
     from .core.buffer import PysFileBuffer
     from .core.cache import PysUndefined, PysHook
+    from .core.context import PysContext
     from .core.highlight import _PysHighlightFormatter
     from .core.position import PysPosition
     from .core.results import PysExecuteResult
@@ -54,6 +55,16 @@ def pys_highlight(
     max_bracket_level: int = 3
 ) -> str: ...
 
+def pys_runner(
+    file: PysFileBuffer,
+    mode: Literal['exec', 'eval', 'single'],
+    symbol_table: PysSymbolTable,
+    flags: Optional[int] = None,
+    parser_flags: int = DEFAULT,
+    context_parent: Optional[PysContext] = None,
+    context_parent_entry_position: Optional[PysPosition] = None
+) -> PysExecuteResult: ...
+
 def pys_exec(
     source: str | bytes | bytearray | Iterable | BuiltinMethodType | IOBase | PysFileBuffer,
     globals: Optional[dict[str, Any] | PysSymbolTable | PysUndefined] = None,

{pyscript_programming_language-1.10.3 → pyscript_programming_language-1.10.4}/pyscript/core/analyzer.py

@@ -1,6 +1,6 @@
 from .bases import Pys
 from .checks import is_unpack_assignment
-from .constants import TOKENS, KEYWORDS, DEFAULT
+from .constants import TOKENS, DEFAULT
 from .context import PysContext
 from .exceptions import PysTraceback
 from .nodes import PysNode, PysKeywordNode, PysIdentifierNode, PysAttributeNode, PysSubscriptNode
@@ -363,7 +363,7 @@ class PysAnalyzer(Pys):
 
     def visit_FunctionNode(self, node):
         if node.constructor and self.in_class == 0:
-            self.throw(f"{KEYWORDS['constructor']} function outside of class", node.name.position)
+            self.throw("constructor function outside of class", node.name.position)
             return
 
         for decorator in node.decorators:
@@ -410,7 +410,7 @@ class PysAnalyzer(Pys):
 
     def visit_GlobalNode(self, node):
         if self.in_function == 0:
-            self.throw(f"{KEYWORDS['global']} outside of function", node.position)
+            self.throw("global outside of function", node.position)
 
         for identifier in node.identifiers:
             if identifier.value in self.parameters:
@@ -419,7 +419,7 @@ class PysAnalyzer(Pys):
 
     def visit_ReturnNode(self, node):
         if self.in_function == 0:
-            self.throw(f"{KEYWORDS['return']} outside of function", node.position)
+            self.throw("return outside of function", node.position)
             return
 
         if node.value:
@@ -460,20 +460,20 @@ class PysAnalyzer(Pys):
                     return
 
             elif type is PysKeywordNode:
-                self.throw(f"cannot {KEYWORDS['delete']} {target.name.value}", target.position)
+                self.throw(f"cannot delete {target.name.value}", target.position)
                 return
 
             elif type is not PysIdentifierNode:
-                self.throw(f"cannot {KEYWORDS['delete']} literal", target.position)
+                self.throw("cannot delete literal", target.position)
                 return
 
     def visit_ContinueNode(self, node):
         if self.in_loop == 0:
-            self.throw(f"{KEYWORDS['continue']} outside of loop", node.position)
+            self.throw("continue outside of loop", node.position)
 
     def visit_BreakNode(self, node):
         if self.in_loop == 0 and self.in_switch == 0:
-            self.throw(f"{KEYWORDS['break']} outside of loop or switch case", node.position)
+            self.throw("break outside of loop or switch case", node.position)
 
     def visit_slice_SubscriptNode(self, nslice):
         type = nslice.__class__

{pyscript_programming_language-1.10.3 → pyscript_programming_language-1.10.4}/pyscript/core/checks.py

@@ -18,7 +18,7 @@ is_unpack_assignment = frozenset([
     PysSetNode, PysListNode, PysTupleNode
 ]).__contains__
 
-is_keyword = frozenset(KEYWORDS.values()).__contains__
+is_keyword = frozenset(KEYWORDS).__contains__
 
 is_python_extensions = frozenset([
     '.py', '.ipy', '.pyc', '.pyd', '.pyi', '.pyo', '.pyp', '.pyw', '.pyz', '.rpy', '.xpy', '.pyproj'

{pyscript_programming_language-1.10.3 → pyscript_programming_language-1.10.4}/pyscript/core/constants.py

@@ -92,65 +92,16 @@ TOKENS = MappingProxyType({
 })
 
 # keywords
-KEYWORDS = MappingProxyType({
-    '__debug__': '__debug__',
-    'False': 'False',
-    'None': 'None',
-    'True': 'True',
-    'and': 'and',
-    'as': 'as',
-    'assert': 'assert',
-    'break': 'break',
-    'case': 'case',
-    'catch': 'catch',
-    'class': 'class',
-    'constructor': 'constructor',
-    'continue': 'continue',
-    'def': 'def',
-    'default': 'default',
-    'define': 'define',
-    'del': 'del',
-    'delete': 'delete',
-    'do': 'do',
-    'elif': 'elif',
-    'else': 'else',
-    'except': 'except',
-    'extends': 'extends',
-    'false': 'false',
-    'finally': 'finally',
-    'for': 'for',
-    'from': 'from',
-    'func': 'func',
-    'function': 'function',
-    'global': 'global',
-    'if': 'if',
-    'import': 'import',
-    'in': 'in',
-    'is': 'is',
-    'match': 'match',
-    'nil': 'nil',
-    'none': 'none',
-    'null': 'null',
-    'not': 'not',
-    'true': 'true',
-    'of': 'of',
-    'or': 'or',
-    'raise': 'raise',
-    'repeat': 'repeat',
-    'return': 'return',
-    'switch': 'switch',
-    'throw': 'throw',
-    'try': 'try',
-    'until': 'until',
-    'while': 'while',
-    'with': 'with'
-})
+KEYWORDS = (
+    '__debug__', 'False', 'None', 'True', 'and', 'as', 'assert', 'break', 'case', 'catch', 'class', 'constructor',
+    'continue', 'def', 'default', 'define', 'del', 'delete', 'do', 'elif', 'else', 'except', 'extends', 'false',
+    'finally', 'for', 'from', 'func', 'function', 'global', 'if', 'import', 'in', 'is', 'match', 'nil', 'none', 'null',
+    'not', 'true', 'typeof', 'of', 'or', 'raise', 'repeat', 'return', 'switch', 'throw', 'try', 'until', 'while', 'with'
+)
 
 CONSTANT_KEYWORDS = (
-    KEYWORDS['__debug__'], KEYWORDS['False'], KEYWORDS['None'], KEYWORDS['True'], KEYWORDS['and'], KEYWORDS['class'],
-    KEYWORDS['constructor'], KEYWORDS['def'], KEYWORDS['define'], KEYWORDS['extends'], KEYWORDS['func'],
-    KEYWORDS['function'], KEYWORDS['false'], KEYWORDS['global'], KEYWORDS['in'], KEYWORDS['is'], KEYWORDS['not'],
-    KEYWORDS['nil'], KEYWORDS['none'], KEYWORDS['null'], KEYWORDS['of'], KEYWORDS['or'], KEYWORDS['true']
+    '__debug__', 'False', 'None', 'True', 'and', 'class', 'constructor', 'def', 'define', 'extends', 'func', 'function',
+    'false', 'global', 'in', 'is', 'not', 'nil', 'none', 'null', 'of', 'or', 'true', 'typeof'
 )
 
 # flags

{pyscript_programming_language-1.10.3 → pyscript_programming_language-1.10.4}/pyscript/core/context.py

@@ -56,7 +56,7 @@ class PysClassContext(PysContext):
         super().__init__(
             file=parent.file,
             name=name,
-            qualname=('' if qualname is None else qualname + '.') + name,
+            qualname=name if qualname is None else f'{qualname}.{name}',
             symbol_table=symbol_table,
             parent=parent,
             parent_entry_position=parent_entry_position

{pyscript_programming_language-1.10.3 → pyscript_programming_language-1.10.4}/pyscript/core/exceptions.py

@@ -58,12 +58,10 @@ class PysTraceback(Pys):
             context_name = context.name
 
             frames.append(
-                f'  File {magenta}"{position.file.name}"{reset}'
-                '{}{}{}'.format(
-                    '' if is_positionless else f', line {magenta}{position.start_line}{reset}',
-                    '' if context_name is None else f', in {magenta}{context_name}{reset}',
-                    '' if is_positionless else f'\n{indent(format_arrow(position, colored), 4)}'
-                )
+                f'  File {magenta}"{position.file.name}"{reset}' +
+                ('' if is_positionless else f', line {magenta}{position.start_line}{reset}') + 
+                ('' if context_name is None else f', in {magenta}{context_name}{reset}') +
+                ('' if is_positionless else f'\n{indent(format_arrow(position, colored), 4)}')
             )
 
             position = context.parent_entry_position

{pyscript_programming_language-1.10.3 → pyscript_programming_language-1.10.4}/pyscript/core/highlight.py

@@ -49,12 +49,9 @@ try:
     from pygments.token import Comment, Error, Escape, Keyword, Name, Number, Operator, Punctuation, String, Whitespace
     from pygments.unistring import xid_start, xid_continue
 
-    _set_keywords = frozenset(KEYWORDS.values())
+    _set_keywords = frozenset(KEYWORDS)
     _set_constant_keywords = frozenset(CONSTANT_KEYWORDS)
-    _set_keyword_definitions = frozenset([
-        KEYWORDS['class'],
-        KEYWORDS['def'], KEYWORDS['define'], KEYWORDS['func'], KEYWORDS['function']
-    ])
+    _set_keyword_definitions = frozenset(['class', 'def', 'define', 'func', 'function'])
 
     _keywords = '|'.join(_set_keywords)
     _unicode_name = f'[{xid_start}][{xid_continue}]*'
@@ -184,14 +181,13 @@ try:
 
                 # Class definition
                 (
-                    rf'\b({KEYWORDS["class"]})\b(\s+)\b(?!{_keywords})({_dollar_prefix}{_unicode_name})\b',
+                    rf'\b(class)\b(\s+)(?!{_keywords})({_dollar_prefix}{_unicode_name})\b',
                     bygroups(Keyword.Constant, Whitespace, Name.Class)
                 ),
 
                 # Function definition
                 (
-                    rf'\b({KEYWORDS["def"]}|{KEYWORDS["define"]}|{KEYWORDS["func"]}|{KEYWORDS["function"]})\b(\s+)\b'
-                    rf'(?!{_keywords})({_dollar_prefix}{_unicode_name})\b',
+                    rf'\b(def|define|func|function)\b(\s+)(?!{_keywords})({_dollar_prefix}{_unicode_name})\b',
                     bygroups(Keyword.Constant, Whitespace, Name.Function)
                 ),
 
@@ -405,11 +401,11 @@ def pys_highlight(
 
     Parameters
     ----------
-    source: A PyScript source code (tolerant of syntax errors).
+    - source : A PyScript source code (tolerant of syntax errors).
 
-    format: A function to format the code form.
+    - format : A function to format the code form.
 
-    max_bracket_level: Maximum difference level of parentheses (with circular indexing).
+    - max_bracket_level : Maximum difference level of parentheses (with circular indexing).
     """
 
     file = PysFileBuffer(source)
@@ -461,12 +457,9 @@ def pys_highlight(
                 while j > 0 and tokens[j].type in (TOKENS['NEWLINE'], TOKENS['COMMENT']):
                     j -= 1
                 previous_token = tokens[j]
-                if previous_token.match(TOKENS['KEYWORD'], KEYWORDS['class']):
+                if previous_token.match(TOKENS['KEYWORD'], 'class'):
                     type_fmt = 'identifier-type'
-                elif previous_token.match(
-                    TOKENS['KEYWORD'],
-                    KEYWORDS['def'], KEYWORDS['define'], KEYWORDS['func'], KEYWORDS['function']
-                ):
+                elif previous_token.match(TOKENS['KEYWORD'], 'def', 'define', 'func', 'function'):
                     type_fmt = 'identifier-function'
                 else:
                     j = i + 1

{pyscript_programming_language-1.10.3 → pyscript_programming_language-1.10.4}/pyscript/core/interpreter.py

@@ -1,27 +1,20 @@
-from .constants import TOKENS, KEYWORDS, DEBUG
+from .constants import TOKENS, DEBUG
 from .cache import undefined
 from .checks import is_unpack_assignment, is_equals, is_public_attribute
 from .context import PysClassContext
 from .exceptions import PysTraceback
 from .handlers import handle_call
-from .mapping import UNARY_FUNCTIONS_MAP
+from .mapping import BINARY_FUNCTIONS_MAP, UNARY_FUNCTIONS_MAP
 from .nodes import PysNode, PysIdentifierNode, PysAttributeNode, PysSubscriptNode
 from .objects import PysFunction
 from .pysbuiltins import ce, nce, increment, decrement
 from .results import PysRunTimeResult
-from .symtab import get_binary_function, PysClassSymbolTable, find_closest
+from .symtab import PysClassSymbolTable, find_closest
 from .utils.generic import getattribute, setimuattr, is_object_of, get_error_args
 from .utils.similarity import get_closest
 
 from collections.abc import Iterable
 
-KW__DEBUG__ = KEYWORDS['__debug__']
-KW_AND = KEYWORDS['and']
-KW_IN = KEYWORDS['in']
-KW_IS = KEYWORDS['is']
-KW_NOT = KEYWORDS['not']
-KW_OR = KEYWORDS['or']
-
 T_KEYWORD = TOKENS['KEYWORD']
 T_STRING = TOKENS['STRING']
 T_AND = TOKENS['DOUBLE-AMPERSAND']
@@ -31,20 +24,20 @@ T_CE = TOKENS['EQUAL-TILDE']
 T_NCE = TOKENS['EXCLAMATION-TILDE']
 T_NULLISH = TOKENS['DOUBLE-QUESTION']
 
-get_unary_function = UNARY_FUNCTIONS_MAP.__getitem__
 get_incremental_function = {
     TOKENS['DOUBLE-PLUS']: increment,
     TOKENS['DOUBLE-MINUS']: decrement
 }.__getitem__
+
 get_value_from_keyword = {
-    KEYWORDS['True']: True,
-    KEYWORDS['False']: False,
-    KEYWORDS['None']: None,
-    KEYWORDS['true']: True,
-    KEYWORDS['false']: False,
-    KEYWORDS['nil']: None,
-    KEYWORDS['none']: None,
-    KEYWORDS['null']: None
+    'True': True,
+    'False': False,
+    'None': None,
+    'true': True,
+    'false': False,
+    'nil': None,
+    'none': None,
+    'null': None
 }.__getitem__
 
 def visit_NumberNode(node, context):
@@ -57,7 +50,7 @@ def visit_KeywordNode(node, context):
     name = node.name.value
     return PysRunTimeResult().success(
         (True if context.flags & DEBUG else False)
-        if name == KW__DEBUG__ else
+        if name == '__debug__' else
         get_value_from_keyword(name)
     )
 
@@ -270,9 +263,9 @@ def visit_ChainOperatorNode(node, context):
             if should_return():
                 return result
 
-            if omatch(T_KEYWORD, KW_IN):
+            if omatch(T_KEYWORD, 'in'):
                 value = left in right
-            elif omatch(T_KEYWORD, KW_IS):
+            elif omatch(T_KEYWORD, 'is'):
                 value = left is right
             elif otype == T_CE:
                 handle_call(ce, context, nposition)
@@ -281,7 +274,7 @@ def visit_ChainOperatorNode(node, context):
                 handle_call(nce, context, nposition)
                 value = nce(left, right)
             else:
-                value = get_binary_function(otype)(left, right)
+                value = BINARY_FUNCTIONS_MAP(otype)(left, right)
 
             if not value:
                 break
@@ -332,10 +325,10 @@ def visit_BinaryOperatorNode(node, context):
     with result(context, node.position):
         should_return_right = True
 
-        if omatch(T_KEYWORD, KW_AND) or otype == T_AND:
+        if omatch(T_KEYWORD, 'and') or otype == T_AND:
             if not left:
                 return result.success(left)
-        elif omatch(T_KEYWORD, KW_OR) or otype == T_OR:
+        elif omatch(T_KEYWORD, 'or') or otype == T_OR:
             if left:
                 return result.success(left)
         elif otype == T_NULLISH:
@@ -351,7 +344,7 @@ def visit_BinaryOperatorNode(node, context):
         return result.success(
             right
             if should_return_right else
-            get_binary_function(otype)(left, right)
+            BINARY_FUNCTIONS_MAP(otype)(left, right)
         )
 
     if should_return():
@@ -362,6 +355,7 @@ def visit_UnaryOperatorNode(node, context):
 
     register = result.register
     should_return = result.should_return
+    omatch = node.operand.match
     otype = node.operand.type
     nvalue = node.value
 
@@ -370,11 +364,11 @@ def visit_UnaryOperatorNode(node, context):
         return result
 
     with result(context, node.position):
-        return result.success(
-            (not value)
-            if node.operand.match(T_KEYWORD, KW_NOT) or otype == T_NOT else
-            get_unary_function(otype)(value)
-        )
+        if omatch(T_KEYWORD, 'not') or otype == T_NOT:
+            return result.success(not value)
+        elif omatch(T_KEYWORD, 'typeof'):
+            return result.success(type(value).__name__)
+        return result.success(UNARY_FUNCTIONS_MAP(otype)(value))
 
     if should_return():
         return result
@@ -1475,8 +1469,8 @@ def visit_declaration_AssignNode(node, context, value, operand=TOKENS['EQUAL']):
                 target,
                 attribute,
                 value
-                    if is_equals(operand) else
-                get_binary_function(operand)(getattr(target, attribute), value)
+                if is_equals(operand) else
+                BINARY_FUNCTIONS_MAP(operand)(getattr(target, attribute), value)
             )
 
         if should_return():
@@ -1493,7 +1487,7 @@ def visit_declaration_AssignNode(node, context, value, operand=TOKENS['EQUAL']):
             return result
 
         with result(context, node.position):
-            target[slice] = value if is_equals(operand) else get_binary_function(operand)(target[slice], value)
+            target[slice] = value if is_equals(operand) else BINARY_FUNCTIONS_MAP(operand)(target[slice], value)
 
         if should_return():
             return result

{pyscript_programming_language-1.10.3 → pyscript_programming_language-1.10.4}/pyscript/core/mapping.py

@@ -1,4 +1,4 @@
-from .constants import TOKENS, KEYWORDS
+from .constants import TOKENS
 from .utils.ansi import BOLD, acolor
 
 from operator import (
@@ -10,6 +10,8 @@ from types import MappingProxyType
 contains = lambda a, b: a in b
 not_in = lambda a, b : a not in b
 
+EMPTY_MAP = {}
+
 BINARY_FUNCTIONS_MAP = {
     TOKENS['NOT-IN']: not_in,
     TOKENS['IS-NOT']: is_not,
@@ -47,13 +49,22 @@ BINARY_FUNCTIONS_MAP = {
     TOKENS['EQUAL-DOUBLE-GREATER-THAN']: irshift,
     TOKENS['MINUS-GREATER-THAN']: contains,
     TOKENS['EXCLAMATION-GREATER-THAN']: not_in
-}
+}.__getitem__
 
 UNARY_FUNCTIONS_MAP = {
     TOKENS['PLUS']: pos,
     TOKENS['MINUS']: neg,
     TOKENS['TILDE']: inv
-}
+}.__getitem__
+
+ACOLORS = {
+    'reset': acolor('reset'),
+    'magenta': acolor('magenta'),
+    'bold-magenta': acolor('magenta', style=BOLD),
+    'bold-red': acolor('red', style=BOLD)
+}.__getitem__
+
+REVERSE_TOKENS = MappingProxyType({type: name for name, type in TOKENS.items()})
 
 BRACKETS_MAP = MappingProxyType({
     TOKENS['LEFT-PARENTHESIS']: TOKENS['RIGHT-PARENTHESIS'],
@@ -62,8 +73,8 @@ BRACKETS_MAP = MappingProxyType({
 })
 
 SYMBOLS_TOKEN_MAP = MappingProxyType({
-    TOKENS['NOT-IN']: KEYWORDS['not'] + ' ' + KEYWORDS['in'],
-    TOKENS['IS-NOT']: KEYWORDS['is'] + ' ' + KEYWORDS['not'],
+    TOKENS['NOT-IN']: 'not in',
+    TOKENS['IS-NOT']: 'is not',
     TOKENS['NULL']: '\0',
     TOKENS['NEWLINE']: '\n',
     TOKENS['EXCLAMATION']: '!',
@@ -125,15 +136,4 @@ SYMBOLS_TOKEN_MAP = MappingProxyType({
     TOKENS['EQUAL-ARROW']: '=>',
     TOKENS['EXCLAMATION-GREATER-THAN']: '!>',
     TOKENS['EXCLAMATION-TILDE']: '~!'
-})
-
-ACOLORS = {
-    'reset': acolor('reset'),
-    'magenta': acolor('magenta'),
-    'bold-magenta': acolor('magenta', style=BOLD),
-    'bold-red': acolor('red', style=BOLD)
-}.__getitem__
-
-EMPTY_MAP = {}
-
-REVERSE_TOKENS = MappingProxyType({type: name for name, type in TOKENS.items()})
+})

{pyscript_programming_language-1.10.3 → pyscript_programming_language-1.10.4}/pyscript/core/objects.py

@@ -44,8 +44,8 @@ class PysFunction(PysObject):
                 append_paramnames(parameter)
                 append_argnames(parameter)
 
-        self.__name__ = '<function>' if name is None else name
-        self.__qualname__ = ('' if qualname is None else qualname + '.') + self.__name__
+        self.__name__ = name = '<function>' if name is None else name
+        self.__qualname__ = name if qualname is None else f'{qualname}.{name}'
         self.__code__ = PysCode(
             parameters=parameters,
             body=body,