pyscript-programming-language 1.10.0__tar.gz → 1.10.1__tar.gz

{pyscript_programming_language-1.10.0/pyscript_programming_language.egg-info → pyscript_programming_language-1.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyscript-programming-language
-Version: 1.10.0
+Version: 1.10.1
 Summary: PyScript Programming Language
 Home-page: https://azzammuhyala.github.io/pyscript
 Author: azzammuhyala
@@ -17,9 +17,9 @@ Classifier: Topic :: Software Development :: Interpreters
 Classifier: Topic :: Software Development :: Compilers
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Provides-Extra: extras
-Requires-Dist: beartype; extra == "extras"
-Requires-Dist: pygments; extra == "extras"
+Provides-Extra: other
+Requires-Dist: beartype; extra == "other"
+Requires-Dist: pygments; extra == "other"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{pyscript_programming_language-1.10.0 → pyscript_programming_language-1.10.1}/pyscript/__main__.py

@@ -1,5 +1,5 @@
 from .core.buffer import PysFileBuffer
-from .core.cache import path, undefined
+from .core.cache import path, undefined, hook
 from .core.constants import DEFAULT, DEBUG, DONT_SHOW_BANNER_ON_SHELL, NO_COLOR
 from .core.highlight import (
     HLFMT_HTML, HLFMT_ANSI, HLFMT_BBCODE, pys_highlight, PygmentsPyScriptStyle, PygmentsPyScriptLexer
@@ -28,6 +28,22 @@ from os import environ
 
 import sys
 
+def split_argv():
+    need_value_arguments = {'-c', '--command', '-l', '--highlight', '-r', '--py-recursion'}
+    argv = sys.argv
+    i = 1
+
+    while i < len(argv):
+        argument = argv[i]
+        if argument in need_value_arguments:
+            i += 1
+        elif not argument.startswith('-'):
+            break
+        i += 1
+
+    hook.argv = argv[i:]
+    return argv[1:i + 1]
+
 FORMAT_HIGHLIGHT_MAP = {
     'html': HLFMT_HTML,
     'ansi': HLFMT_ANSI,
@@ -102,7 +118,7 @@ def argument_error(argument, message):
     parser.print_usage(sys.stderr)
     parser.exit(2, f"{parser.prog}: error: argument {argument}: {message}\n")
 
-args = parser.parse_args()
+args = parser.parse_args(split_argv())
 
 if args.highlight and args.file is None:
     argument_error("-l/--highlight", "argument 'file' required")

{pyscript_programming_language-1.10.0 → pyscript_programming_language-1.10.1}/pyscript/core/analyzer.py

@@ -1,5 +1,5 @@
 from .bases import Pys
-from .checks import is_unpack_assignment, is_incremental
+from .checks import is_unpack_assignment
 from .constants import TOKENS, KEYWORDS, DEFAULT
 from .context import PysContext
 from .exceptions import PysTraceback
@@ -155,13 +155,12 @@ class PysAnalyzer(Pys):
         self.visit(node.right)
 
     def visit_UnaryOperatorNode(self, node):
-        if is_incremental(node.operand.type):
-            operator = 'increase' if node.operand.type == TOKENS['DOUBLE-PLUS'] else 'decrease'
-            self.visit_declaration_AssignNode(node.value, f"cannot {operator} literal", operator)
-            return
-
         self.visit(node.value)
 
+    def visit_IncrementalNode(self, node):
+        operator = 'increase' if node.operand.type == TOKENS['DOUBLE-PLUS'] else 'decrease'
+        self.visit_declaration_AssignNode(node.target, f"cannot {operator} literal", operator)
+
     def visit_StatementsNode(self, node):
         for element in node.body:
             self.visit(element)

{pyscript_programming_language-1.10.0 → pyscript_programming_language-1.10.1}/pyscript/core/cache.py

@@ -37,6 +37,7 @@ class PysHook(Pys):
     def __new_singleton__(cls) -> 'PysHook':
         global hook
         hook = super(cls, cls).__new__(cls)
+        hook.argv = []
         hook.running_shell = False
         hook.running_breakpoint = False
         hook.display = print_display
@@ -48,6 +49,16 @@ class PysHook(Pys):
     def __repr__(self) -> str:
         return f'<hook object at {id(self):016X}>'
 
+    @property
+    def argv(self) -> list[str]:
+        return singletons['hook.argv']
+
+    @argv.setter
+    def argv(self, value: list[str]) -> None:
+        if not isinstance(value, list) or not all(isinstance(arg, str) for arg in value):
+            raise TypeError("hook.argv: argv must be list of strings")
+        singletons['hook.argv'] = value
+
     @property
     def running_shell(self) -> bool:
         return singletons['hook.running_shell']

{pyscript_programming_language-1.10.0 → pyscript_programming_language-1.10.1}/pyscript/core/checks.py

@@ -5,7 +5,7 @@ from .nodes import *
 is_expression = frozenset([
     PysNumberNode, PysStringNode, PysKeywordNode, PysIdentifierNode, PysDictionaryNode, PysSetNode, PysListNode,
     PysTupleNode, PysAttributeNode, PysSubscriptNode, PysCallNode, PysChainOperatorNode, PysTernaryOperatorNode,
-    PysBinaryOperatorNode, PysUnaryOperatorNode, PysMatchNode, PysFunctionNode, PysEllipsisNode
+    PysBinaryOperatorNode, PysUnaryOperatorNode, PysIncrementalNode, PysMatchNode, PysFunctionNode, PysEllipsisNode
 ]).__contains__
 
 is_statement = frozenset([
@@ -28,10 +28,6 @@ is_equals = frozenset([
     TOKENS['EQUAL'], TOKENS['EQUAL-COLON']
 ]).__contains__
 
-is_incremental = frozenset([
-    TOKENS['DOUBLE-PLUS'], TOKENS['DOUBLE-MINUS']
-]).__contains__
-
 is_blacklist_python_builtins = frozenset([
     'IndentationError', 'TabError', 'breakpoint', 'compile', 'copyright', 'credits', 'dir', 'eval', 'exec', 'help',
     'globals', 'license', 'locals', 'vars'

{pyscript_programming_language-1.10.0 → pyscript_programming_language-1.10.1}/pyscript/core/constants.py

@@ -106,7 +106,9 @@ KEYWORDS = MappingProxyType({
     'class': 'class',
     'constructor': 'constructor',
     'continue': 'continue',
+    'def': 'def',
     'default': 'default',
+    'define': 'define',
     'del': 'del',
     'delete': 'delete',
     'do': 'do',
@@ -146,9 +148,9 @@ KEYWORDS = MappingProxyType({
 
 CONSTANT_KEYWORDS = (
     KEYWORDS['__debug__'], KEYWORDS['False'], KEYWORDS['None'], KEYWORDS['True'], KEYWORDS['and'], KEYWORDS['class'],
-    KEYWORDS['constructor'], 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']
+    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']
 )
 
 # flags

{pyscript_programming_language-1.10.0 → pyscript_programming_language-1.10.1}/pyscript/core/highlight.py

@@ -51,7 +51,10 @@ try:
 
     _set_keywords = frozenset(KEYWORDS.values())
     _set_constant_keywords = frozenset(CONSTANT_KEYWORDS)
-    _set_keyword_definitions = frozenset([KEYWORDS['class'], KEYWORDS['func'], KEYWORDS['function']])
+    _set_keyword_definitions = frozenset([
+        KEYWORDS['class'],
+        KEYWORDS['def'], KEYWORDS['define'], KEYWORDS['func'], KEYWORDS['function']
+    ])
 
     _keywords = '|'.join(_set_keywords)
     _unicode_name = f'[{xid_start}][{xid_continue}]'
@@ -107,17 +110,6 @@ try:
         tokens = {
 
             'root': [
-                # Whitespaces
-                (r'\s+', Whitespace),
-
-                # Punctuation and operators
-                (rf'[\(\),;\[\]{{}}]|\\(?:{_newlines})', Punctuation),
-                (r'\.\.\.', Keyword.Constant),
-                (
-                    r'[!%&\*\+\-\./:<=>\?@^\|~]|&&|\*\*|\+\+|--|//|<<|==|>>|\?\?|\|\||!=|%=|&=|\*=|\+=|-=|/=|:=|<=|>=|'
-                    r'@=|^=|\|=|~=|\*\*=|//=|<<=|>>=|->|=>|!>|~!', Operator
-                ),
-
                 # Keywords
                 (rf'\b({"|".join(_set_keywords ^ _set_constant_keywords)})\b', Keyword),
                 (rf'\b({"|".join(_set_constant_keywords ^ _set_keyword_definitions)})\b', Keyword.Constant),
@@ -198,7 +190,7 @@ try:
 
                 # Function definition
                 (
-                    rf'\b({KEYWORDS["func"]}|{KEYWORDS["function"]})\b(\s*)'
+                    rf'\b({KEYWORDS["def"]}|{KEYWORDS["define"]}|{KEYWORDS["func"]}|{KEYWORDS["function"]})\b(\s*)'
                     rf'(?!{_keywords})({_dollar_prefix}\b{_unicode_name}*)\b',
                     bygroups(Keyword.Constant, Whitespace, Name.Function)
                 ),
@@ -224,9 +216,20 @@ try:
                 # Variables
                 (rf'{_dollar_prefix}\b{_unicode_name}*\b', Name.Variable),
 
+                # Whitespaces
+                (r'\s+', Whitespace),
+
+                # Punctuation and operators
+                (rf'[\(\),;\[\]{{}}]|\\(?:{_newlines})', Punctuation),
+                (r'\.\.\.', Keyword.Constant),
+                (
+                    r'[!%&\*\+\-\./:<=>\?@^\|~]|&&|\*\*|\+\+|--|//|<<|==|>>|\?\?|\|\||!=|%=|&=|\*=|\+=|-=|/=|:=|<=|>=|'
+                    r'@=|^=|\|=|~=|\*\*=|//=|<<=|>>=|->|=>|!>|~!', Operator
+                ),
+
                 # Invalid tokens
                 (r'\\.', Error),
-                (rf'{_dollar_prefix}.', Error)
+                (rf'{_dollar_prefix[:-1]}.', Error)
             ],
 
             'code-tags': [

{pyscript_programming_language-1.10.0 → pyscript_programming_language-1.10.1}/pyscript/core/interpreter.py

@@ -1,10 +1,10 @@
 from .constants import TOKENS, KEYWORDS, DEBUG
 from .cache import undefined
-from .checks import is_unpack_assignment, is_equals, is_incremental, is_public_attribute
+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, KEYWORDS_TO_VALUES_MAP
+from .mapping import UNARY_FUNCTIONS_MAP
 from .nodes import PysNode, PysIdentifierNode, PysAttributeNode, PysSubscriptNode
 from .objects import PysFunction
 from .pysbuiltins import ce, nce, increment, decrement
@@ -24,7 +24,6 @@ KW_OR = KEYWORDS['or']
 
 T_KEYWORD = TOKENS['KEYWORD']
 T_STRING = TOKENS['STRING']
-T_INCREMENT = TOKENS['DOUBLE-PLUS']
 T_AND = TOKENS['DOUBLE-AMPERSAND']
 T_OR = TOKENS['DOUBLE-PIPE']
 T_NOT = TOKENS['EXCLAMATION']
@@ -33,7 +32,20 @@ T_NCE = TOKENS['EXCLAMATION-TILDE']
 T_NULLISH = TOKENS['DOUBLE-QUESTION']
 
 get_unary_function = UNARY_FUNCTIONS_MAP.__getitem__
-get_value_from_keyword = KEYWORDS_TO_VALUES_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
+}.__getitem__
 
 def visit(node, context):
     return get_visitors(node.__class__)(node, context)
@@ -216,7 +228,7 @@ def visit_CallNode(node, context):
 
     for nargument in node.arguments:
 
-        if isinstance(nargument, tuple):
+        if nargument.__class__ is tuple:
             keyword, nvalue = nargument
             setitem(keyword.value, register(visit(nvalue, context)))
             if should_return():
@@ -344,34 +356,47 @@ def visit_UnaryOperatorNode(node, context):
 
     register = result.register
     should_return = result.should_return
-    nposition = node.position
     otype = node.operand.type
-    nvalue = node.value
 
-    value = register(visit(nvalue, context))
+    value = register(visit(node.value, context))
     if should_return():
         return result
 
-    with result(context, nposition):
+    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 node.operand.match(T_KEYWORD, KW_NOT) or otype == T_NOT:
-            return result.success(not value)
+    if should_return():
+        return result
 
-        elif is_incremental(otype):
-            func = increment if otype == T_INCREMENT else decrement
+def visit_IncrementalNode(node, context):
+    result = PysRunTimeResult()
 
-            handle_call(func, context, nposition)
-            increast_value = func(value)
-            if node.operand_position == 'left':
-                value = increast_value
+    register = result.register
+    should_return = result.should_return
+    nposition = node.position
+    ntarget = node.target
 
-            register(visit_declaration_AssignNode(nvalue, context, increast_value))
-            if should_return():
-                return result
+    value = register(visit(ntarget, context))
+    if should_return():
+        return result
 
-            return result.success(value)
+    with result(context, nposition):
+        func = get_incremental_function(node.operand.type)
+
+        handle_call(func, context, nposition)
+        increast_value = func(value)
+        if node.operand_position == 'left':
+            value = increast_value
 
-        return result.success(get_unary_function(otype)(value))
+        register(visit_declaration_AssignNode(ntarget, context, increast_value))
+        if should_return():
+            return result
+
+        return result.success(value)
 
     if should_return():
         return result
@@ -685,7 +710,7 @@ def visit_TryNode(node, context):
 
                 if tparameter:
                     with result(context, tparameter.position):
-                        context.symbol_table.set(tparameter.value, error.exception)
+                        context.symbol_table.set(parameter := tparameter.value, error.exception)
                     if should_return():
                         return
 
@@ -693,6 +718,12 @@ def visit_TryNode(node, context):
                 if result.error:
                     setimuattr(result.error, 'cause', error)
 
+                if tparameter:
+                    with result(context, tparameter.position):
+                        context.symbol_table.remove(parameter)
+                    if should_return():
+                        return
+
                 break
 
         else:
@@ -1084,7 +1115,7 @@ def visit_FunctionNode(node, context):
 
     for nparameter in node.parameters:
 
-        if isinstance(nparameter, tuple):
+        if nparameter.__class__ is tuple:
             keyword, nvalue = nparameter
 
             value = register(visit(nvalue, context))

{pyscript_programming_language-1.10.0 → pyscript_programming_language-1.10.1}/pyscript/core/mapping.py

@@ -10,7 +10,7 @@ from types import MappingProxyType
 contains = lambda a, b: a in b
 not_in = lambda a, b : a not in b
 
-BINARY_FUNCTIONS_MAP = MappingProxyType({
+BINARY_FUNCTIONS_MAP = {
     TOKENS['NOT-IN']: not_in,
     TOKENS['IS-NOT']: is_not,
     TOKENS['PLUS']: add,
@@ -47,24 +47,13 @@ BINARY_FUNCTIONS_MAP = MappingProxyType({
     TOKENS['EQUAL-DOUBLE-GREATER-THAN']: irshift,
     TOKENS['MINUS-GREATER-THAN']: contains,
     TOKENS['EXCLAMATION-GREATER-THAN']: not_in
-})
+}
 
-UNARY_FUNCTIONS_MAP = MappingProxyType({
+UNARY_FUNCTIONS_MAP = {
     TOKENS['PLUS']: pos,
     TOKENS['MINUS']: neg,
     TOKENS['TILDE']: inv
-})
-
-KEYWORDS_TO_VALUES_MAP = MappingProxyType({
-    KEYWORDS['True']: True,
-    KEYWORDS['False']: False,
-    KEYWORDS['None']: None,
-    KEYWORDS['true']: True,
-    KEYWORDS['false']: False,
-    KEYWORDS['nil']: None,
-    KEYWORDS['none']: None,
-    KEYWORDS['null']: None
-})
+}
 
 BRACKETS_MAP = MappingProxyType({
     TOKENS['LEFT-PARENTHESIS']: TOKENS['RIGHT-PARENTHESIS'],

{pyscript_programming_language-1.10.0 → pyscript_programming_language-1.10.1}/pyscript/core/nodes.py

@@ -246,25 +246,38 @@ class PysBinaryOperatorNode(PysNode):
 
 class PysUnaryOperatorNode(PysNode):
 
-    __slots__ = ('operand', 'value', 'operand_position')
+    __slots__ = ('operand', 'value')
 
     @typechecked
-    def __init__(self, operand: PysToken, value: PysNode, operand_position: Literal['left', 'right']) -> None:
+    def __init__(self, operand: PysToken, value: PysNode) -> None:
+        super().__init__(PysPosition(operand.position.file, operand.position.start, value.position.end))
+        setimuattr(self, 'operand',  operand)
+        setimuattr(self, 'value', value)
+
+    def __repr__(self) -> str:
+        return f'UnaryOperator(operand={self.operand!r}, value={self.value!r})'
+
+class PysIncrementalNode(PysNode):
+
+    __slots__ = ('operand', 'target', 'operand_position')
+
+    @typechecked
+    def __init__(self, operand: PysToken, target: PysNode, operand_position: Literal['left', 'right']) -> None:
         super().__init__(
-            PysPosition(operand.position.file, operand.position.start, value.position.end)
+            PysPosition(operand.position.file, operand.position.start, target.position.end)
             if operand_position == 'left' else
-            PysPosition(operand.position.file, value.position.start, operand.position.end)
+            PysPosition(operand.position.file, target.position.start, operand.position.end)
         )
 
         setimuattr(self, 'operand',  operand)
-        setimuattr(self, 'value', value)
+        setimuattr(self, 'target', target)
         setimuattr(self, 'operand_position', operand_position)
 
     def __repr__(self) -> str:
         return (
-            'UnaryOperator('
+            'Incremental('
                 f'operand={self.operand!r}, '
-                f'value={self.value!r}, '
+                f'target={self.target!r}, '
                 f'operand_position={self.operand_position!r}'
             ')'
         )

{pyscript_programming_language-1.10.0 → pyscript_programming_language-1.10.1}/pyscript/core/objects.py

@@ -24,6 +24,26 @@ class PysFunction(PysObject):
 
         context = context.parent if isinstance(context, PysClassContext) else context
 
+        argument_names = []
+        keyword_argument_names = []
+        parameter_names = []
+        keyword_arguments = {}
+
+        append_argnames = argument_names.append
+        append_keynames = keyword_argument_names.append
+        append_paramnames = parameter_names.append
+        set_keywordarg = keyword_arguments.__setitem__
+
+        for parameter in parameters:
+            if parameter.__class__ is tuple:
+                arg, value = parameter
+                append_paramnames(arg)
+                append_keynames(arg)
+                set_keywordarg(arg, value)
+            else:
+                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.__code__ = PysCode(
@@ -35,10 +55,10 @@ class PysFunction(PysObject):
             closure_symbol_table=context.symbol_table,
             visit=visit,
             parameters_length=len(parameters),
-            argument_names=tuple(item for item in parameters if not isinstance(item, tuple)),
-            keyword_argument_names=tuple(item[0] for item in parameters if isinstance(item, tuple)),
-            parameter_names=tuple(item[0] if isinstance(item, tuple) else item for item in parameters),
-            keyword_arguments={item[0]: item[1] for item in parameters if isinstance(item, tuple)}
+            argument_names=tuple(argument_names),
+            keyword_argument_names=tuple(keyword_argument_names),
+            parameter_names=tuple(parameter_names),
+            keyword_arguments=keyword_arguments
         )
 
     def __repr__(self):