pyscript-programming-language 1.12.0__py3-none-any.whl

pyscript/core/utils/generic.py

@@ -0,0 +1,46 @@
+from inspect import currentframe
+from types import UnionType
+
+getattribute = object.__getattribute__
+setimuattr = object.__setattr__
+delimuattr = object.__delattr__
+dinit = dict.__init__
+drepr = dict.__repr__
+dor = dict.__or__
+dcontains = dict.__contains__
+dgetitem = dict.__getitem__
+dsetitem = dict.__setitem__
+ddelitem = dict.__delitem__
+dget = dict.get
+dkeys = dict.keys
+ditems = dict.items
+
+def get_frame(deep=0):
+    deep += 1
+    frame = currentframe()
+    while deep > 0 and frame:
+        frame = frame.f_back
+        deep -= 1
+    return frame
+
+def get_locals(deep=0):
+    if frame := get_frame(deep + 1):
+        locals = frame.f_locals
+        return locals if isinstance(locals, dict) else dict(locals)
+    return {}
+
+def get_subscript(object, key, default=None):
+    return object[key] if 0 <= key < len(object) else default
+
+def is_object_of(obj: object | type, class_or_tuple: type | UnionType | tuple[type | UnionType, ...]) -> bool:
+
+    """
+    Returns whether an object is derived from a parent class.
+    The object here can be an initialized object, which calls `isinstance(obj, class_or_type)`,
+    or a class type, which calls `issubclass(obj, class_or_tuple)`.
+    """
+
+    return (
+        isinstance(obj, class_or_tuple) or
+        (isinstance(obj, type) and issubclass(obj, class_or_tuple))
+    )

pyscript/core/utils/jsdict.py

@@ -0,0 +1,32 @@
+from .generic import dinit, drepr, dor, dsetitem, ddelitem, ditems
+
+from typing import Any
+
+class jsdict(dict):
+
+    def __init__(self, *args, **kwargs) -> None:
+        dinit(self, *args, **kwargs)
+        for key, value in ditems(self):
+            if value is None:
+                ddelitem(self, key)
+
+    def __repr__(self) -> str:
+        return f'jsdict({drepr(self)})'
+
+    def __or__(self, *args, **kwargs) -> 'jsdict':
+        return jsdict(dor(self, *args, **kwargs))
+
+    def __setattr__(self, key: Any, value: Any) -> None:
+        if value is None:
+            if key in self:
+                ddelitem(self, key)
+        else:
+            dsetitem(self, key, value)
+
+    def __delattr__(self, key: Any) -> None:
+        if key in self:
+            ddelitem(self, key)
+
+    __getitem__ = __getattribute__ = dict.get
+    __setitem__ = __setattr__
+    __delitem__ = __delattr__

pyscript/core/utils/module.py

@@ -0,0 +1,28 @@
+from .path import extension
+
+from os.path import isdir, isfile, join
+
+import sys
+
+def get_module_path(path):
+    # circular import problem solved
+    from ..checks import is_python_extensions
+
+    if isfile(path) and not is_python_extensions(extension(path)):
+        return path
+
+    candidate = path + '.pys'
+    if isfile(candidate):
+        return candidate
+
+    candidate = join(path, '__init__.pys')
+    if isdir(path) and isfile(candidate):
+        return candidate
+
+def set_python_path(path):
+    if path not in sys.path:
+        sys.path.insert(0, path)
+
+def remove_python_path(path):
+    if path in sys.path:
+        sys.path.remove(path)

pyscript/core/utils/path.py

@@ -0,0 +1,29 @@
+from os import getcwd as osgetcwd
+from os.path import sep, abspath as osabspath, normpath as osnormpath, splitext, basename
+
+from .string import normstr
+
+def getcwd():
+    try:
+        return osgetcwd()
+    except:
+        return '.'
+
+def abspath(path):
+    try:
+        return osabspath(path)
+    except:
+        return path
+
+def base(path):
+    return splitext(basename(path))[0]
+
+def extension(path):
+    return splitext(basename(path))[1]
+
+def normpath(*paths, absolute=True):
+    path = osnormpath(sep.join(map(normstr, paths)))
+    return abspath(path) if absolute else path
+
+def get_name_from_path(path):
+    return base(normpath(path, absolute=False))

pyscript/core/utils/similarity.py

@@ -0,0 +1,22 @@
+from itertools import pairwise
+from re import compile as re_compile
+
+replace = re_compile(r'\s+').sub
+
+def get_similarity_ratio(string1, string2):
+    bigram1 = set(s1 + s2 for s1, s2 in pairwise(replace('', string1).lower()))
+    bigram2 = set(s1 + s2 for s1, s2 in pairwise(replace('', string2).lower()))
+    max_bigrams_count = max(len(bigram1), len(bigram2))
+    return len(bigram1 & bigram2) / max_bigrams_count if max_bigrams_count else 0.0
+
+def get_closest(elements, target, cutoff=0.6):
+    best_match = None
+    best_score = 0.0
+
+    for element in elements:
+        score = get_similarity_ratio(target, element)
+        if score >= cutoff and score > best_score:
+            best_score = score
+            best_match = element
+
+    return best_match

pyscript/core/utils/string.py

@@ -0,0 +1,49 @@
+from collections.abc import Iterable
+from io import IOBase, TextIOWrapper
+from json import detect_encoding
+from types import BuiltinMethodType
+
+def normstr(obj):
+    if isinstance(obj, str):
+        return obj.replace('\r\n', '\n').replace('\r', '\n').replace('\v', '\n')
+
+    elif isinstance(obj, (bytes, bytearray)):
+        return normstr(obj.decode(detect_encoding(obj), 'surrogatepass'))
+
+    elif isinstance(obj, IOBase):
+        if not obj.readable():
+            raise TypeError("unreadable IO")
+        return normstr(obj.read())
+
+    elif isinstance(obj, Iterable):
+        return '\n'.join(map(normstr, obj))
+
+    elif (
+        isinstance(obj, BuiltinMethodType) and
+        isinstance(self := getattr(obj, '__self__', None), TextIOWrapper) and
+        obj.__name__ == 'readline'
+    ):
+
+        if not self.readable():
+            raise TypeError("unreadable IO, provides readline function")
+
+        lines = []
+        while True:
+            if not (line := obj()):
+                break
+            lines.append(normstr(line))
+        return '\n'.join(lines)
+
+    raise TypeError('not a string')
+
+def join(sequence, conjunction='and'):
+    length = len(sequence)
+    if length == 1:
+        return sequence[0]
+    elif length == 2:
+        return f'{sequence[0]} {conjunction} {sequence[1]}'
+    return f'{", ".join(sequence[:-1])}, {conjunction} {sequence[-1]}'
+
+def indent(string, length):
+    prefix = ' ' * length
+    return '\n'.join(prefix + line for line in normstr(string).splitlines())

pyscript/core/version.py

@@ -0,0 +1,120 @@
+from .bases import Pys
+from .cache import pys_sys
+from .utils.decorators import immutable, inheritable, singleton
+
+from re import compile as re_compile
+from types import MappingProxyType
+
+version_match = re_compile(r'^(\d+)\.(\d+)\.(\d+)((?:a|b|rc)(\d+)|\.(dev|post)(\d+))?$').match
+
+__version__ = '1.12.0'
+__date__ = '18 February 2026, 17:52 UTC+7'
+
+version = pys_sys.version = f'{__version__} ({__date__})'
+
+TAG_VERSION_MAP = MappingProxyType({
+    'a': 'alpha',
+    'b': 'beta',
+    'rc': 'release candidate',
+    'dev': 'development',
+    'post': 'post'
+})
+
+@singleton
+@immutable
+@inheritable
+class PysVersionInfo(Pys, tuple):
+
+    __slots__ = ()
+
+    def __new_singleton__(cls) -> 'PysVersionInfo':
+        match = version_match(__version__)
+        if not match:
+            raise ValueError(f"invalid format version: {__version__!r}")
+
+        major, minor, micro, pre_full, pre_num1, pre_tag2, pre_num2 = match.groups()
+
+        if pre_full:
+
+            if pre_tag2:
+                pre_num = int(pre_num2)
+                pre_tag_full = TAG_VERSION_MAP[pre_tag2]
+            else:
+                pre_num = int(pre_num1)
+                pre_tag_full = (
+                    TAG_VERSION_MAP[pre_full[0]]
+                    if pre_full.startswith(('a', 'b')) else
+                    TAG_VERSION_MAP['rc']
+                )
+
+        else:
+            pre_tag_full = pre_num = None
+
+        global version_info
+        version_info = pys_sys.version_info = tuple.__new__(
+            cls,
+            (
+                int(major), int(minor), int(micro), pre_tag_full, pre_num
+            )
+        )
+        return version_info
+
+    @property
+    def major(self) -> int:
+        return self[0]
+
+    @property
+    def minor(self) -> int:
+        return self[1]
+
+    @property
+    def micro(self) -> int:
+        return self[2]
+
+    @property
+    def pre_tag(self) -> str | None:
+        return self[3]
+
+    @property
+    def pre_num(self) -> int | None:
+        return self[4]
+
+    @property
+    def release(self) -> tuple[int, int, int]:
+        return self[0:3]
+
+    def __lt__(self, other: tuple) -> bool:
+        return self.release < other
+
+    def __gt__(self, other: tuple) -> bool:
+        return self.release > other
+
+    def __le__(self, other: tuple) -> bool:
+        return self.release <= other
+
+    def __ge__(self, other: tuple) -> bool:
+        return self.release >= other
+
+    def __eq__(self, other: tuple) -> bool:
+        return self.release == other
+
+    def __ne__(self, other: tuple) -> bool:
+        return self.release != other
+
+    def __repr__(self) -> str:
+        return (
+            'VersionInfo('
+                f'major={self.major!r}, '
+                f'minor={self.minor!r}, '
+                f'micro={self.micro!r}' +
+                (
+                    ''
+                    if self.pre_tag is None else
+                    ', '
+                    f'pre_tag={self.pre_tag!r}, '
+                    f'pre_num={self.pre_num!r}'
+                ) +
+            ')'
+        )
+
+PysVersionInfo()

pyscript/lib/__hello__.pys

@@ -0,0 +1,7 @@
+func main() {
+    print("Hello World!")
+}
+
+if (__name__ == '__main__') {
+    main()
+}

pyscript/lib/ansi.pys

@@ -0,0 +1,14 @@
+from '_pyscript>utils>ansi' import (
+    DEFAULT,
+    BACKGROUND,
+    BOLD,
+    FAINT,
+    ITALIC,
+    UNDERLINE,
+    BLINK,
+    RAPIDBLINK,
+    STRIKETHROUGH,
+    DOUBLEUNDERLINE,
+    acolor,
+    ahtml
+)

pyscript/lib/ast/__init__.pys

@@ -0,0 +1,36 @@
+from parser import DEFAULT, ast as parse
+from ast_dump import dump
+from ast_literal_eval import visit as _visit_literal_eval
+from ast_unparse import unparse
+from ast_walk import walk
+from _pyscript import nodes
+
+func literal_eval(node_or_string, flags=DEFAULT)
+    return _visit_literal_eval(parse(node_or_string, mode='eval', flags=flags))
+
+Node = nodes.PysNode
+
+allNodes = []
+
+locals().update(
+    comprehension(
+        Node.__subclasses__(),
+        func(cls) {
+            name = cls.__name__
+            nodeName = name.removeprefix('Pys')
+            allNodes.append(nodeName)
+            return nodeName, getattr(nodes, name)
+        }
+    )
+)
+
+__all__ = (
+    'parse',
+    'dump',
+    'literal_eval',
+    'unparse',
+    'walk',
+    'Node'
+) + tuple(allNodes)
+
+del allNodes, nodes