pyscript-programming-language 1.7.2__tar.gz → 1.8.0__tar.gz

{pyscript_programming_language-1.7.2 → pyscript_programming_language-1.8.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: pyscript-programming-language
-Version: 1.7.2
+Version: 1.8.0
 Summary: PyScript Programming Language
-Home-page: https://github.com/azzammuhyala/pyscript
+Home-page: https://azzammuhyala.github.io/pyscript
 Author: azzammuhyala
 Author-email: azzammuhyala@gmail.com
 License: MIT

{pyscript_programming_language-1.7.2 → pyscript_programming_language-1.8.0}/pyscript/__main__.py

@@ -9,7 +9,8 @@ from .core.version import __version__
 
 from argparse import ArgumentParser
 from os import environ
-from sys import executable, stderr, version_info, exit, setrecursionlimit
+
+import sys
 
 FORMAT_HIGHLIGHT_MAP = {
     'html': HLFMT_HTML,
@@ -18,8 +19,8 @@ FORMAT_HIGHLIGHT_MAP = {
 }
 
 parser = ArgumentParser(
-    prog=f'{get_module_name_from_path(executable)} -m pyscript',
-    description=f'PyScript Launcher for Python Version {".".join(map(str, version_info))}'
+    prog=f'{get_module_name_from_path(sys.executable)} -m pyscript',
+    description=f'PyScript Launcher for Python Version {".".join(map(str, sys.version_info))}'
 )
 
 parser.add_argument(
@@ -27,7 +28,7 @@ parser.add_argument(
     type=str,
     nargs='?',
     default=None,
-    help="file path"
+    help="File path to be executed"
 )
 
 parser.add_argument(
@@ -40,53 +41,53 @@ parser.add_argument(
     '-c', '--command',
     type=str,
     default=None,
-    help="execute PyScript from argument",
+    help="Execute program from a string argument",
 )
 
 parser.add_argument(
     '-d', '--debug',
     action='store_true',
-    help="set a debug flag, this will remove the assert statement"
+    help="Set a debug flag, this will remove the assert statement"
 )
 
 parser.add_argument(
     '-i', '--inspect',
     action='store_true',
-    help="inspect interactively after running a file",
+    help="Inspect interactively after running a 'file'",
 )
 
 parser.add_argument(
     '-l', '--highlight',
     choices=tuple(FORMAT_HIGHLIGHT_MAP.keys()),
     default=None,
-    help='generate PyScript highlight code from a file'
+    help="Generate highlight code from a 'file'"
 )
 
 parser.add_argument(
     '-n', '--no-color',
     action='store_true',
-    help="no colorful traceback"
+    help="Suppress colored output"
 )
 
 parser.add_argument(
     '-r', '--py-recursion',
     type=int,
     default=None,
-    help="set a python recursion limit"
+    help="Set a Python recursion limit"
 )
 
 def argument_error(argument, message):
-    parser.print_usage(stderr)
+    parser.print_usage(sys.stderr)
     parser.exit(2, f"{parser.prog}: error: argument {argument}: {message}\n")
 
 args = parser.parse_args()
 
 if args.highlight and args.file is None:
-    argument_error("-l/--highlight", "file path require")
+    argument_error("-l/--highlight", "argument 'file' required")
 
 if args.py_recursion is not None:
     try:
-        setrecursionlimit(args.py_recursion)
+        sys.setrecursionlimit(args.py_recursion)
     except BaseException as e:
         argument_error("-r/--py-recursion", e)
 
@@ -121,7 +122,7 @@ if args.file is not None:
 
     if args.highlight:
         try:
-            print(pys_highlight(file, FORMAT_HIGHLIGHT_MAP.get(args.highlight, None)))
+            print(pys_highlight(file, FORMAT_HIGHLIGHT_MAP.get(args.highlight)))
         except BaseException as e:
             parser.error(f"file {path!r}: Highlight error: {e}")
 
@@ -150,4 +151,4 @@ elif args.command is not None:
 else:
     code = pys_shell(undefined, flags)
 
-exit(code)
+sys.exit(code)

{pyscript_programming_language-1.7.2 → pyscript_programming_language-1.8.0}/pyscript/core/analyzer.py

@@ -157,23 +157,25 @@ class PysAnalyzer(Pys):
         self.visit(node.right)
 
     def visit_UnaryOperatorNode(self, node):
+        value = node.value
+
         if is_incremental(node.operand.type):
-            type = node.value.__class__
+            type = value.__class__
             operator = 'increase' if node.operand.type == TOKENS['DOUBLE-PLUS'] else 'decrease'
 
             if type is PysKeywordNode:
-                self.throw(f"cannot {operator} {node.value.token.value}", node.value.position)
+                self.throw(f"cannot {operator} {value.name.value}", value.position)
                 return
 
-            elif isinstance(node.value, PysNode):
+            elif isinstance(value, PysNode):
                 if type not in (PysIdentifierNode, PysAttributeNode, PysSubscriptNode):
-                    self.throw(f"cannot {operator} literal", node.value.position)
+                    self.throw(f"cannot {operator} literal", value.position)
                     return
 
             else:
                 raise TypeError("UnaryOperator: node.value is not PysNode")
 
-        self.visit(node.value)
+        self.visit(value)
 
     def visit_StatementsNode(self, node):
         for element in node.body:
@@ -228,6 +230,26 @@ class PysAnalyzer(Pys):
 
         self.in_switch -= 1
 
+    def visit_MatchNode(self, node):
+        if node.target:
+            self.visit(node.target)
+            if self.error:
+                return
+
+        for condition, value in node.cases:
+            self.visit(condition)
+            if self.error:
+                return
+
+            self.visit(value)
+            if self.error:
+                return
+
+        if node.default:
+            self.visit(node.default)
+            if self.error:
+                return
+
     def visit_TryNode(self, node):
         self.visit(node.body)
         if self.error:
@@ -435,7 +457,7 @@ class PysAnalyzer(Pys):
                     return
 
             elif type is PysKeywordNode:
-                self.throw(f"cannot delete {target.token.value}", target.position)
+                self.throw(f"cannot delete {target.name.value}", target.position)
                 return
 
             elif isinstance(target, PysNode):
@@ -502,7 +524,7 @@ class PysAnalyzer(Pys):
                     return
 
         elif type is PysKeywordNode:
-            self.throw(f"cannot assign to {node.token.value}", node.position)
+            self.throw(f"cannot assign to {node.name.value}", node.position)
 
         elif isinstance(node, PysNode):
             if type is not PysIdentifierNode:

{pyscript_programming_language-1.7.2 → pyscript_programming_language-1.8.0}/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, PysFunctionNode, PysEllipsisNode
+    PysBinaryOperatorNode, PysUnaryOperatorNode, PysMatchNode, PysFunctionNode, PysEllipsisNode
 ]).__contains__
 
 is_statement = frozenset([

{pyscript_programming_language-1.7.2 → pyscript_programming_language-1.8.0}/pyscript/core/constants.py

@@ -121,6 +121,7 @@ KEYWORDS = MappingProxyType({
     'import': 'import',
     'in': 'in',
     'is': 'is',
+    'match': 'match',
     'none': 'none',
     'not': 'not',
     'true': 'true',

{pyscript_programming_language-1.7.2 → pyscript_programming_language-1.8.0}/pyscript/core/exceptions.py

@@ -21,6 +21,8 @@ class PysTraceback(Pys):
         return f'<traceback of exception {self.exception!r}>'
 
     def string_traceback(self):
+        from .position import format_arrow  # circular import problem solved
+
         context = self.context
         position = self.position
 
@@ -44,7 +46,7 @@ class PysTraceback(Pys):
                 '{}{}{}'.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(position.format_arrow(colored), 4)}'
+                    '' if is_positionless else f'\n{indent(format_arrow(position, colored), 4)}'
                 )
             )
 

{pyscript_programming_language-1.7.2 → pyscript_programming_language-1.8.0}/pyscript/core/highlight.py

@@ -120,10 +120,25 @@ try:
 
                 # Numbers
                 (
-                    r'0[bB][01](_?[01])*[jJiI]?|0[oO][0-7](_?[0-7])*[jJiI]?|0[xX][0-9a-fA-F](_?[0-9a-fA-F])*[jJiI]?|((?'
-                    r':[0-9](_?[0-9])*)?\\.[0-9](_?[0-9])*|[0-9](_?[0-9])*\\.)([eE][+-]?[0-9](_?[0-9])*)?[jJiI]?|[0-9]('
-                    r'_?[0-9])*([eE][+-]?[0-9](_?[0-9])*)[jJiI]?|[0-9](_?[0-9])*[jJiI]?',
-                    Number
+                    r'0[bB][01](_?[01])*[jJiI]?',
+                    Number.Binary
+                ),
+                (
+                    r'0[oO][0-7](_?[0-7])*[jJiI]?',
+                    Number.Octal
+                ),
+                (
+                    r'0[xX][0-9a-fA-F](_?[0-9a-fA-F])*[jJiI]?',
+                    Number.Hex
+                ),
+                (
+                    r'((?:[0-9](_?[0-9])*)?\.[0-9](_?[0-9])*|[0-9](_?[0-9])*\.)([eE][+-]?[0-9](_?[0-9])*)?[jJiI]?|[0-9]'
+                    r'(_?[0-9])*([eE][+-]?[0-9](_?[0-9])*)[jJiI]?',
+                    Number.Float
+                ),
+                (
+                    r'[0-9](_?[0-9])*[jJiI]?',
+                    Number.Integer
                 ),
 
                 # Comments

{pyscript_programming_language-1.7.2 → pyscript_programming_language-1.8.0}/pyscript/core/interpreter.py

@@ -293,7 +293,11 @@ def visit_TernaryOperatorNode(node, context):
         return result
 
     with result(context, ncondition.position):
-        return result.success(register(visit(node.valid if condition else node.invalid, context)))
+        value = register(visit(node.valid if condition else node.invalid, context))
+        if should_return():
+            return result
+
+        return result.success(value)
 
     if should_return():
         return result
@@ -588,6 +592,51 @@ def visit_SwitchNode(node, context):
 
     return result.success(None)
 
+def visit_MatchNode(node, context):
+    result = PysRunTimeResult()
+
+    register = result.register
+    should_return = result.should_return
+    ntarget = node.target
+
+    compare = False
+
+    if ntarget:
+        target = register(visit(ntarget, context))
+        if should_return():
+            return result
+
+        compare = True
+
+    for ncondition, nvalue in node.cases:
+        condition = register(visit(ncondition, context))
+        if should_return():
+            return result
+
+        with result(context, ncondition.position):
+            valid = target == condition if compare else condition
+
+        if should_return():
+            return result
+
+        if valid:
+            value = register(visit(nvalue, context))
+            if should_return():
+                return result
+
+            return result.success(value)
+
+    ndefault = node.default
+
+    if ndefault:
+        default = register(visit(ndefault, context))
+        if should_return():
+            return result
+
+        return result.success(default)
+
+    return result.success(None)
+
 def visit_TryNode(node, context):
     result = PysRunTimeResult()
 

{pyscript_programming_language-1.7.2 → pyscript_programming_language-1.8.0}/pyscript/core/lexer.py

@@ -1,7 +1,7 @@
 from .bases import Pys
 from .buffer import PysFileBuffer
 from .checks import is_keyword
-from .constants import TOKENS, DEFAULT, HIGHLIGHT
+from .constants import TOKENS, DEFAULT, SILENT, HIGHLIGHT
 from .context import PysContext
 from .exceptions import PysTraceback
 from .position import PysPosition
@@ -86,6 +86,11 @@ class PysLexer(Pys):
                 )
             )
 
+    def warning(self, message):
+        if not (self.flags & SILENT or self.flags & HIGHLIGHT or message in self.warnings):
+            print(message, file=sys.stderr)
+            self.warnings.add(message)
+
     def throw(self, start, end, message, add_token=True):
         if self.error is None:
 
@@ -111,6 +116,7 @@ class PysLexer(Pys):
     def make_tokens(self) -> tuple[tuple[PysToken, ...] | tuple[PysToken], PysTraceback | None]:
         self.index = 0
         self.tokens = []
+        self.warnings = set()
         self.error = None
 
         self.update_current_character()
@@ -385,7 +391,6 @@ class PysLexer(Pys):
             return self.file.text[self.index:self.index + 3] == triple_prefix
 
         is_triple_quote = triple_quote()
-        warning_displayed = False
         decoded_error_message = None
 
         def decode_error(is_unicode_error, start, end, message):
@@ -516,14 +521,8 @@ class PysLexer(Pys):
                             string += '\\'
                             break
 
-                        if not (warning_displayed or self.flags & HIGHLIGHT):
-                            warning_displayed = True
-                            print(
-                                f"SyntaxWarning: invalid escape sequence '\\{self.current_character}'",
-                                file=sys.stderr
-                            )
-
                         string += '\\' + self.current_character
+                        self.warning(f"SyntaxWarning: invalid escape sequence '\\{self.current_character}'")
                         self.advance()
 
             else:

pyscript_programming_language-1.8.0/pyscript/core/mapping.py

@@ -0,0 +1,131 @@
+from .constants import TOKENS, KEYWORDS
+
+from operator import (
+    is_not, eq, ne, lt, gt, le, ge, add, sub, mul, truediv, floordiv, pow, matmul, mod, and_, or_, xor, lshift, rshift,
+    iadd, isub, imul, itruediv, ifloordiv, ipow, imatmul, imod, iand, ior, ixor, ilshift, irshift, pos, neg, inv
+)
+from types import MappingProxyType
+
+BINARY_FUNCTIONS_MAP = MappingProxyType({
+    TOKENS['NOT-IN']: lambda a, b : a not in b,
+    TOKENS['IS-NOT']: is_not,
+    TOKENS['PLUS']: add,
+    TOKENS['MINUS']: sub,
+    TOKENS['STAR']: mul,
+    TOKENS['SLASH']: truediv,
+    TOKENS['DOUBLE-SLASH']: floordiv,
+    TOKENS['DOUBLE-STAR']: pow,
+    TOKENS['AT']: matmul,
+    TOKENS['PERCENT']: mod,
+    TOKENS['AMPERSAND']: and_,
+    TOKENS['PIPE']: or_,
+    TOKENS['CIRCUMFLEX']: xor,
+    TOKENS['DOUBLE-LESS-THAN']: lshift,
+    TOKENS['DOUBLE-GREATER-THAN']: rshift,
+    TOKENS['DOUBLE-EQUAL']: eq,
+    TOKENS['EQUAL-EXCLAMATION']: ne,
+    TOKENS['LESS-THAN']: lt,
+    TOKENS['GREATER-THAN']: gt,
+    TOKENS['EQUAL-LESS-THAN']: le,
+    TOKENS['EQUAL-GREATER-THAN']: ge,
+    TOKENS['EQUAL-PLUS']: iadd,
+    TOKENS['EQUAL-MINUS']: isub,
+    TOKENS['EQUAL-STAR']: imul,
+    TOKENS['EQUAL-SLASH']: itruediv,
+    TOKENS['EQUAL-DOUBLE-SLASH']: ifloordiv,
+    TOKENS['EQUAL-DOUBLE-STAR']: ipow,
+    TOKENS['EQUAL-AT']: imatmul,
+    TOKENS['EQUAL-PERCENT']: imod,
+    TOKENS['EQUAL-AMPERSAND']: iand,
+    TOKENS['EQUAL-PIPE']: ior,
+    TOKENS['EQUAL-CIRCUMFLEX']: ixor,
+    TOKENS['EQUAL-DOUBLE-LESS-THAN']: ilshift,
+    TOKENS['EQUAL-DOUBLE-GREATER-THAN']: irshift,
+})
+
+UNARY_FUNCTIONS_MAP = MappingProxyType({
+    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['none']: None
+})
+
+BRACKETS_MAP = MappingProxyType({
+    TOKENS['LEFT-PARENTHESIS']: TOKENS['RIGHT-PARENTHESIS'],
+    TOKENS['LEFT-SQUARE']: TOKENS['RIGHT-SQUARE'],
+    TOKENS['LEFT-CURLY']: TOKENS['RIGHT-CURLY']
+})
+
+SYMBOLS_TOKEN_MAP = MappingProxyType({
+    TOKENS['NOT-IN']: KEYWORDS['not'] + ' ' + KEYWORDS['in'],
+    TOKENS['IS-NOT']: KEYWORDS['is'] + ' ' + KEYWORDS['not'],
+    TOKENS['NULL']: '\0',
+    TOKENS['NEWLINE']: '\n',
+    TOKENS['EXCLAMATION']: '!',
+    TOKENS['COMMENT']: '#',
+    TOKENS['PERCENT']: '%',
+    TOKENS['AMPERSAND']: '&',
+    TOKENS['RIGHT-PARENTHESIS']: ')',
+    TOKENS['LEFT-PARENTHESIS']: '(',
+    TOKENS['STAR']: '*',
+    TOKENS['PLUS']: '+',
+    TOKENS['COMMA']: ',',
+    TOKENS['MINUS']: '-',
+    TOKENS['DOT']: '.',
+    TOKENS['SLASH']: '/',
+    TOKENS['COLON']: ':',
+    TOKENS['SEMICOLON']: ';',
+    TOKENS['LESS-THAN']: '<',
+    TOKENS['EQUAL']: '=',
+    TOKENS['GREATER-THAN']: '>',
+    TOKENS['QUESTION']: '?',
+    TOKENS['AT']: '@',
+    TOKENS['LEFT-SQUARE']: '[',
+    TOKENS['RIGHT-SQUARE']: ']',
+    TOKENS['CIRCUMFLEX']: '^',
+    TOKENS['LEFT-CURLY']: '{',
+    TOKENS['PIPE']: '|',
+    TOKENS['RIGHT-CURLY']: '}',
+    TOKENS['TILDE']: '~',
+    TOKENS['DOUBLE-AMPERSAND']: '&&',
+    TOKENS['DOUBLE-STAR']: '**',
+    TOKENS['DOUBLE-PLUS']: '++',
+    TOKENS['DOUBLE-MINUS']: '--',
+    TOKENS['DOUBLE-SLASH']: '//',
+    TOKENS['DOUBLE-LESS-THAN']: '<<',
+    TOKENS['DOUBLE-EQUAL']: '==',
+    TOKENS['DOUBLE-GREATER-THAN']: '>>',
+    TOKENS['DOUBLE-QUESTION']: '??',
+    TOKENS['DOUBLE-PIPE']: '||',
+    TOKENS['TRIPLE-DOT']: '...',
+    TOKENS['EQUAL-EXCLAMATION']: '!=',
+    TOKENS['EQUAL-PERCENT']: '%=',
+    TOKENS['EQUAL-AMPERSAND']: '&=',
+    TOKENS['EQUAL-STAR']: '*=',
+    TOKENS['EQUAL-PLUS']: '+=',
+    TOKENS['EQUAL-MINUS']: '-=',
+    TOKENS['EQUAL-SLASH']: '/=',
+    TOKENS['EQUAL-COLON']: ':=',
+    TOKENS['EQUAL-LESS-THAN']: '<=',
+    TOKENS['EQUAL-GREATER-THAN']: '>=',
+    TOKENS['EQUAL-AT']: '@=',
+    TOKENS['EQUAL-CIRCUMFLEX']: '^=',
+    TOKENS['EQUAL-PIPE']: '|=',
+    TOKENS['EQUAL-TILDE']: '~=',
+    TOKENS['EQUAL-DOUBLE-STAR']: '**=',
+    TOKENS['EQUAL-DOUBLE-SLASH']: '//=',
+    TOKENS['EQUAL-DOUBLE-LESS-THAN']: '<<=',
+    TOKENS['EQUAL-DOUBLE-GREATER-THAN']: '>>=',
+    TOKENS['EQUAL-ARROW']: '=>',
+    TOKENS['EXCLAMATION-TILDE']: '~!'
+})
+
+EMPTY_MAP = MappingProxyType({})

{pyscript_programming_language-1.7.2 → pyscript_programming_language-1.8.0}/pyscript/core/nodes.py

@@ -1,7 +1,7 @@
 from .bases import Pys
 from .position import PysPosition
 from .token import PysToken
-from .utils.decorators import typechecked, immutable
+from .utils.decorators import typechecked, immutable, inheritable
 from .utils.generic import setimuattr
 
 from typing import Literal
@@ -15,6 +15,10 @@ class PysNode(Pys):
     def __init__(self, position: PysPosition) -> None:
         setimuattr(self, 'position', position)
 
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        inheritable(cls)
+
     def __repr__(self):
         return 'Node()'
 
@@ -342,6 +346,27 @@ class PysSwitchNode(PysNode):
     def __repr__(self):
         return f'Switch(target={self.target!r}, case_cases={self.case_cases!r}, default_body={self.default_body!r})'
 
+class PysMatchNode(PysNode):
+
+    __slots__ = ('target', 'cases', 'default')
+
+    @typechecked
+    def __init__(
+        self,
+        target: PysNode | None,
+        cases: list[tuple[PysNode, PysNode]],
+        default: PysNode | None,
+        position: PysPosition
+    ) -> None:
+
+        super().__init__(position)
+        setimuattr(self, 'target', target)
+        setimuattr(self, 'cases', tuple(cases))
+        setimuattr(self, 'default', default)
+
+    def __repr__(self):
+        return f'Match(target={self.target!r}, cases={self.cases!r}, default={self.default!r})'
+
 class PysTryNode(PysNode):
 
     __slots__ = ('body', 'catch_cases', 'else_body', 'finally_body')

{pyscript_programming_language-1.7.2 → pyscript_programming_language-1.8.0}/pyscript/core/objects.py

@@ -19,10 +19,11 @@ class PysCode(PysObject):
 class PysPythonFunction(PysObject):
 
     def __init__(self, func):
-        from .handlers import handle_call
+        from .handlers import handle_call  # circular import problem solved
 
-        self.__name__ = func.__name__
-        self.__qualname__ = func.__qualname__
+        self.__name__ = getattr(func, '__name__', '<function>')
+        self.__qualname__ = getattr(func, '__qualname__', '<function>')
+        self.__doc__ = getattr(func, '__doc__', None)
         self.__func__ = func
         self.__code__ = PysCode(
             position=None,
@@ -46,7 +47,7 @@ class PysPythonFunction(PysObject):
 class PysFunction(PysObject):
 
     def __init__(self, name, qualname, parameters, body, position, context):
-        from .interpreter import visit
+        from .interpreter import visit  # circular import problem solved
 
         context = context.parent if isinstance(context, PysClassContext) else context