pyscript-programming-language 1.4.0__tar.gz → 1.5.0__tar.gz

{pyscript_programming_language-1.4.0 → pyscript_programming_language-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyscript-programming-language
-Version: 1.4.0
+Version: 1.5.0
 Summary: PyScript Programming Language
 Home-page: https://github.com/azzammuhyala/pyscript
 Author: azzammuhyala
@@ -15,8 +15,10 @@ Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Interpreters
 Classifier: Topic :: Software Development :: Compilers
-Requires-Python: >=3.5
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+Provides-Extra: typecheck
+Requires-Dist: beartype; extra == "typecheck"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -26,6 +28,7 @@ Dynamic: home-page
 Dynamic: keywords
 Dynamic: license
 Dynamic: project-url
+Dynamic: provides-extra
 Dynamic: requires-python
 Dynamic: summary
 

pyscript_programming_language-1.5.0/pyscript/__init__.py

@@ -0,0 +1,34 @@
+"""
+PyScript is a programming language written in Python. \
+This language is not isolated and is directly integrated with the Python's library and namespace levels.
+"""
+
+if __import__('sys').version_info < (3, 10):
+    raise ImportError("Python version 3.10 and above is required to run PyScript")
+
+from . import core
+
+from .core.constants import DEFAULT, DEBUG, SILENT, RETRES, COMMENT, NO_COLOR, REVERSE_POW_XOR
+from .core.cache import undefined
+from .core.highlight import HLFMT_HTML, HLFMT_ANSI, pys_highlight
+from .core.runner import pys_exec, pys_eval, pys_shell
+from .core.version import version_info, __version__, __date__
+
+__all__ = (
+    'core',
+    'DEFAULT',
+    'DEBUG',
+    'SILENT',
+    'RETRES',
+    'COMMENT',
+    'NO_COLOR',
+    'REVERSE_POW_XOR',
+    'HLFMT_HTML',
+    'HLFMT_ANSI',
+    'undefined',
+    'version_info',
+    'pys_highlight',
+    'pys_exec',
+    'pys_eval',
+    'pys_shell'
+)

pyscript_programming_language-1.5.0/pyscript/__init__.pyi

@@ -0,0 +1,73 @@
+from typing import TYPE_CHECKING, Any, Callable, Iterator, Literal, Optional
+
+if TYPE_CHECKING:
+    from .core.buffer import PysFileBuffer
+    from .core.cache import PysUndefined
+    from .core.highlight import _HighlightFormatter
+    from .core.position import PysPosition
+    from .core.results import PysExecuteResult
+    from .core.symtab import PysSymbolTable
+    from .core.version import PysVersionInfo
+
+    from io import IOBase
+
+from . import core as core
+
+DEFAULT: int
+DEBUG: int
+SILENT: int
+RETRES: int
+COMMENT: int
+NO_COLOR: int
+REVERSE_POW_XOR: int
+
+HLFMT_HTML: _HighlightFormatter
+HLFMT_ANSI: _HighlightFormatter
+
+undefined: PysUndefined
+version_info: PysVersionInfo
+
+def pys_highlight(
+    source: str | bytes | bytearray | Iterator | Callable | IOBase | PysFileBuffer,
+    format: Optional[
+        Callable[
+            [
+                str | Literal[
+                    'start',
+                    'bracket-unmatch',
+                    'identifier', 'identifier-const', 'identifier-call', 'identifier-class',
+                    'keyword', 'keyword-identifier',
+                    'number', 'string', 'comment', 'newline',
+                    'default',
+                    'end'
+                ],
+                PysPosition,
+                str
+            ],
+            str
+        ]
+    ] = None,
+    max_parenthesis_level: int = 3,
+    flags: int = DEFAULT
+) -> str: ...
+
+def pys_exec(
+    source: str | bytes | bytearray | Iterator | Callable | IOBase | PysFileBuffer,
+    globals: Optional[dict[str, Any] | PysSymbolTable | PysUndefined] = None,
+    flags: int = DEFAULT
+) -> None | PysExecuteResult: ...
+
+def pys_eval(
+    source: str | bytes | bytearray | Iterator | Callable | IOBase | PysFileBuffer,
+    globals: Optional[dict[str, Any] | PysSymbolTable | PysUndefined] = None,
+    flags: int = DEFAULT
+) -> Any | PysExecuteResult: ...
+
+def pys_shell(
+    globals: Optional[dict[str, Any] | PysSymbolTable | PysUndefined] = None,
+    flags: int = DEFAULT
+) -> int | Any: ...
+
+__version__: str
+__date__: str
+__all__: tuple[str]

pyscript_programming_language-1.5.0/pyscript/__main__.py

@@ -0,0 +1,172 @@
+from .core.buffer import PysFileBuffer
+from .core.cache import undefined
+from .core.constants import DEFAULT, DEBUG, NO_COLOR
+from .core.handlers import handle_execute
+from .core.highlight import HLFMT_HTML, HLFMT_ANSI, pys_highlight
+from .core.runner import pys_runner, pys_shell
+from .core.symtab import build_symbol_table
+from .core.utils.general import normalize_path
+from .core.version import __version__
+
+from argparse import ArgumentParser
+
+from sys import executable, version_info, exit, setrecursionlimit
+from os.path import basename, splitext
+
+parser = ArgumentParser(
+    prog=splitext(basename(executable))[0] + ' -m pyscript',
+    description='PyScript Launcher for Python Version ' + '.'.join(map(str, version_info))
+)
+
+parser.add_argument(
+    'file',
+    type=str,
+    nargs='?',
+    default=None,
+    help="file path"
+)
+
+parser.add_argument(
+    '-v', '--version',
+    action='version',
+    version=f"PyScript {__version__}",
+)
+
+parser.add_argument(
+    '-c', '--command',
+    type=str,
+    default=None,
+    help="execute PyScript from argument",
+)
+
+parser.add_argument(
+    '-d', '--debug',
+    action='store_true',
+    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",
+)
+
+parser.add_argument(
+    '-l', '--highlight',
+    choices=('html', 'ansi'),
+    default=None,
+    help='generate PyScript highlight code from a file'
+)
+
+parser.add_argument(
+    '-n', '--no-color',
+    action='store_true',
+    help="no colorful traceback"
+)
+
+parser.add_argument(
+    '-r', '--py-recursion',
+    type=int,
+    default=None,
+    help="set a python recursion limit"
+)
+
+args = parser.parse_args()
+
+if args.highlight and args.file is None:
+    parser.error("-l, --highlight: file path require")
+
+if args.py_recursion is not None:
+    try:
+        setrecursionlimit(args.py_recursion)
+    except BaseException as e:
+        parser.error(f"-r, --py-recursion: {e}")
+
+code = 0
+flags = DEFAULT
+
+if args.debug:
+    flags |= DEBUG
+if args.no_color:
+    flags |= NO_COLOR
+
+if args.file is not None:
+    path = normalize_path(args.file)
+
+    try:
+        with open(path, 'r') as file:
+            file = PysFileBuffer(file, path)
+
+    except FileNotFoundError:
+        parser.error(f"can't open file {path!r}: No such file or directory")
+
+    except PermissionError:
+        parser.error(f"can't open file {path!r}: Permission denied.")
+
+    except IsADirectoryError:
+        parser.error(f"can't open file {path!r}: Path is not a file.")
+
+    except NotADirectoryError:
+        parser.error(f"can't open file {path!r}: Attempting to access directory from file.")
+
+    except (OSError, IOError):
+        parser.error(f"can't open file {path!r}: Attempting to access a system directory or file.")
+
+    except UnicodeDecodeError:
+        parser.error(f"can't read file {path!r}: Bad file.")
+
+    except BaseException as e:
+        parser.error(f"file {path!r}: Unexpected error: {e}")
+
+    if args.highlight:
+        try:
+            print(
+                pys_highlight(
+                    file,
+                    HLFMT_HTML if args.highlight == 'html' else HLFMT_ANSI
+                )
+            )
+        except BaseException as e:
+            parser.error(f"file {path!r}: Tokenize error: {e}")
+
+    else:
+        symtab = build_symbol_table(file)
+        symtab.set('__name__', '__main__')
+
+        result = pys_runner(
+            file=file,
+            mode='exec',
+            symbol_table=symtab,
+            flags=flags
+        )
+
+        code = handle_execute(result)
+
+        if args.inspect:
+            code = pys_shell(
+                globals=result.context.symbol_table,
+                flags=result.context.flags
+            )
+
+elif args.command is not None:
+    file = PysFileBuffer(args.command)
+
+    symtab = build_symbol_table(file)
+    symtab.set('__name__', '__main__')
+
+    code = handle_execute(
+        pys_runner(
+            file=file,
+            mode='exec',
+            symbol_table=symtab,
+            flags=flags
+        )
+    )
+
+else:
+    code = pys_shell(
+        globals=undefined,
+        flags=flags
+    )
+
+exit(code)

{pyscript_programming_language-1.4.0 → pyscript_programming_language-1.5.0}/pyscript/core/__init__.py

@@ -21,7 +21,6 @@ from . import (
     pysbuiltins,
     results,
     runner,
-    singletons,
     symtab,
     token,
     utils,
@@ -38,6 +37,7 @@ __all__ = (
     'exceptions',
     'handlers',
     'highlight',
+    'immutables',
     'interpreter',
     'lexer',
     'nodes',

{pyscript_programming_language-1.4.0 → pyscript_programming_language-1.5.0}/pyscript/core/analyzer.py

@@ -1,13 +1,25 @@
 from .bases import Pys
-from .constants import TOKENS, DEFAULT
+from .constants import TOKENS, DEFAULT, NSEQ_GLOBAL, NSEQ_DEL, NSEQ_DICT, NTER_GENERAL
 from .context import PysContext
 from .exceptions import PysException
-from .nodes import PysSequenceNode, PysIdentifierNode, PysKeywordNode, PysAttributeNode, PysSubscriptNode
+from .nodes import PysNode, PysKeywordNode, PysIdentifierNode, PysSequenceNode, PysAttributeNode, PysSubscriptNode
+from .position import PysPosition
+from .utils.decorators import typechecked
+
+from typing import Optional
 
 class PysAnalyzer(Pys):
 
-    def __init__(self, file, flags=DEFAULT, context_parent=None, context_parent_entry_position=None):
-        self.file = file
+    @typechecked
+    def __init__(
+        self,
+        node: PysNode,
+        flags: int = DEFAULT,
+        context_parent: Optional[PysContext] = None,
+        context_parent_entry_position: Optional[PysPosition] = None
+    ) -> None:
+
+        self.node = node
         self.flags = flags
         self.context = context_parent
         self.context_parent_entry_position = context_parent_entry_position
@@ -17,7 +29,7 @@ class PysAnalyzer(Pys):
             self.error = PysException(
                 SyntaxError(message),
                 PysContext(
-                    file=self.file,
+                    file=self.node.position.file,
                     flags=self.flags,
                     parent=self.context,
                     parent_entry_position=self.context_parent_entry_position
@@ -25,15 +37,14 @@ class PysAnalyzer(Pys):
                 position
             )
 
-    def analyze(self, node):
+    @typechecked
+    def analyze(self) -> PysException | None:
         self.in_loop = 0
         self.in_function = 0
         self.in_switch = 0
-
         self.error = None
 
-        self.visit(node)
-
+        self.visit(self.node)
         return self.error
 
     def visit(self, node):
@@ -43,37 +54,38 @@ class PysAnalyzer(Pys):
 
     def visit_SequenceNode(self, node):
 
-        if node.type == 'del':
+        if node.type == NSEQ_DEL:
 
             for element in node.elements:
 
                 if isinstance(element, PysSubscriptNode):
-                    self.visit(element.object)
+                    self.visit(element.target)
                     if self.error:
                         return
 
-                    self.check_valid_slice_from_SubscriptNode(element.slice)
+                    self.visit_slice_SubscriptNode(element.slice)
                     if self.error:
                         return
 
                 elif isinstance(element, PysAttributeNode):
-                    self.visit(element.object)
+                    self.visit(element.target)
                     if self.error:
                         return
 
                 elif isinstance(element, PysKeywordNode):
-                    self.throw("cannot delete {}".format(element.token.value), element.position)
+                    self.throw(f"cannot delete {element.token.value}", element.position)
                     return
 
                 elif not isinstance(element, PysIdentifierNode):
                     self.throw("cannot delete literal", element.position)
                     return
 
-        elif node.type == 'global':
+        elif node.type == NSEQ_GLOBAL:
+
             if self.in_function == 0:
                 self.throw("global outside of function", node.position)
 
-        elif node.type == 'dict':
+        elif node.type == NSEQ_DICT:
 
             for key, value in node.elements:
 
@@ -86,20 +98,21 @@ class PysAnalyzer(Pys):
                     return
 
         else:
+
             for element in node.elements:
                 self.visit(element)
                 if self.error:
                     return
 
     def visit_AttributeNode(self, node):
-        self.visit(node.object)
+        self.visit(node.target)
 
     def visit_SubscriptNode(self, node):
-        self.visit(node.object)
+        self.visit(node.target)
         if self.error:
             return
 
-        self.check_valid_slice_from_SubscriptNode(node.slice)
+        self.visit_slice_SubscriptNode(node.slice)
 
     def visit_ChainOperatorNode(self, node):
         for expression in node.expressions:
@@ -108,7 +121,7 @@ class PysAnalyzer(Pys):
                 return
 
     def visit_TernaryOperatorNode(self, node):
-        if node.style == 'general':
+        if node.style == NTER_GENERAL:
             self.visit(node.condition)
             if self.error:
                 return
@@ -140,17 +153,17 @@ class PysAnalyzer(Pys):
             operator = 'increase' if node.operand.type == TOKENS['INCREMENT'] else 'decrease'
 
             if isinstance(node.value, PysKeywordNode):
-                self.throw("cannot {} {}".format(operator, node.value.token.value), node.value.position)
+                self.throw(f"cannot {operator} {node.value.token.value}", node.value.position)
                 return
 
             elif not isinstance(node.value, (PysIdentifierNode, PysAttributeNode, PysSubscriptNode)):
-                self.throw("cannot {} literal".format(operator), node.value.position)
+                self.throw(f"cannot {operator} literal", node.value.position)
                 return
 
         self.visit(node.value)
 
     def visit_AssignNode(self, node):
-        self.check_valid_AssignNode(
+        self.visit_declaration_AssignNode(
             node.target,
             "cannot assign to expression here. Maybe you meant '==' instead of '='?"
         )
@@ -225,7 +238,7 @@ class PysAnalyzer(Pys):
         if len(node.header) == 2:
             declaration, iterable = node.header
 
-            self.check_valid_AssignNode(declaration, "cannot assign to expression")
+            self.visit_declaration_AssignNode(declaration, "cannot assign to expression")
             if self.error:
                 return
 
@@ -323,7 +336,7 @@ class PysAnalyzer(Pys):
             name = token.value
 
             if name in parameter_names:
-                return self.throw("duplicate argument {!r} in function definition".format(name), token.position)
+                return self.throw(f"duplicate argument {name!r} in function definition", token.position)
 
             parameter_names.add(name)
 
@@ -356,18 +369,20 @@ class PysAnalyzer(Pys):
         keyword_argument_names = set()
 
         for element in node.arguments:
-            value = element
 
             if isinstance(element, tuple):
                 token, value = element
                 name = token.value
 
                 if name in keyword_argument_names:
-                    self.throw("duplicate argument {!r} in call definition".format(name), token.position)
+                    self.throw(f"duplicate argument {name!r} in call definition", token.position)
                     return
 
                 keyword_argument_names.add(name)
 
+            else:
+                value = element
+
             self.visit(value)
             if self.error:
                 return
@@ -399,41 +414,51 @@ class PysAnalyzer(Pys):
         if self.in_loop == 0 and self.in_switch == 0:
             self.throw("break outside of loop or switch case", node.position)
 
-    def check_valid_slice_from_SubscriptNode(self, slice):
-        if isinstance(slice, list):
-            for element in slice:
-                self.check_valid_slice_from_SubscriptNode(element)
+    def visit_slice_SubscriptNode(self, nslice):
+        if isinstance(nslice, tuple):
+            for element in nslice:
+                self.visit_slice_SubscriptNode(element)
                 if self.error:
                     return
 
-        elif isinstance(slice, tuple):
-            for element in slice:
-                self.visit(element)
+        elif isinstance(nslice, slice):
+            if nslice.start is not None:
+                self.visit(nslice.start)
+                if self.error:
+                    return
+
+            if nslice.stop is not None:
+                self.visit(nslice.stop)
+                if self.error:
+                    return
+
+            if nslice.step is not None:
+                self.visit(nslice.step)
                 if self.error:
                     return
 
         else:
-            self.visit(slice)
+            self.visit(nslice)
 
-    def check_valid_AssignNode(self, node, message):
+    def visit_declaration_AssignNode(self, node, message):
         if isinstance(node, PysSequenceNode):
             for element in node.elements:
-                self.check_valid_AssignNode(element, message)
+                self.visit_declaration_AssignNode(element, message)
                 if self.error:
                     return
 
         elif isinstance(node, PysSubscriptNode):
-            self.visit(node.object)
+            self.visit(node.target)
             if self.error:
                 return
 
-            self.check_valid_slice_from_SubscriptNode(node.slice)
+            self.visit_slice_SubscriptNode(node.slice)
 
         elif isinstance(node, PysAttributeNode):
-            self.visit(node.object)
+            self.visit(node.target)
 
         elif isinstance(node, PysKeywordNode):
-            self.throw("cannot assign to {}".format(node.token.value), node.position)
+            self.throw(f"cannot assign to {node.token.value}", node.position)
 
         elif not isinstance(node, PysIdentifierNode):
             self.throw(message, node.position)

pyscript_programming_language-1.5.0/pyscript/core/bases.py

@@ -0,0 +1,2 @@
+class Pys:
+    __slots__ = ()

pyscript_programming_language-1.5.0/pyscript/core/buffer.py

@@ -0,0 +1,33 @@
+from .bases import Pys
+from .utils.decorators import immutable
+from .utils.general import setimuattr, tostr
+
+from io import IOBase
+
+@immutable
+class PysBuffer(Pys):
+    __slots__ = ()
+
+class PysFileBuffer(PysBuffer):
+
+    __slots__ = ('text', 'name')
+
+    def __init__(self, text, name=None):
+
+        if isinstance(text, PysFileBuffer):
+            name = tostr(text.name if name is None else name)
+            text = tostr(text.text)
+
+        elif isinstance(text, IOBase):
+            name = tostr(text.name if name is None else name)
+            text = tostr(text)
+
+        else:
+            name = '<string>' if name is None else tostr(name)
+            text = tostr(text)
+
+        setimuattr(self, 'text', text)
+        setimuattr(self, 'name', name)
+
+    def __repr__(self):
+        return f'<FileBuffer from {self.name!r}>'