baisilisp 0.5.2.dev1__tar.gz → 0.5.2.dev11__tar.gz

{baisilisp-0.5.2.dev1 → baisilisp-0.5.2.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: baisilisp
-Version: 0.5.2.dev1
+Version: 0.5.2.dev11
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python

{baisilisp-0.5.2.dev1 → baisilisp-0.5.2.dev11}/pyproject.toml

@@ -3,7 +3,7 @@ name = "baisilisp"
 # The declared version is the next stable release. Successful main builds use
 # a CI-generated ``.devN`` version; a published GitHub release must use this
 # exact value without its leading ``v``.
-version = "0.5.2.dev1"
+version = "0.5.2.dev11"
 description = "BaisiLisp: a compatibility-focused Basilisp fork hosted on Python 3 with seamless Python interop."
 authors = [
     { name = "Christopher Rink", email = "chris@crink.dev" },
@@ -203,15 +203,21 @@ logging-format-style = "new"
 [tool.pylint."messages control"]
 disable = [
   "bad-inline-option",
+  "abstract-class-instantiated",
+  "broad-exception-caught",
+  "consider-merging-isinstance",
   "consider-using-assignment-expr",
   "deprecated-pragma",
   "docstring-first-line-empty",
   "duplicate-code",
+  "exec-used",
   "file-ignored",
   "fixme",
   "global-statement",
   "implicit-str-concat",
+  "import-private-name",
   "import-outside-toplevel",
+  "inconsistent-return-statements",
   "invalid-name",
   "len-as-condition",
   "line-too-long",
@@ -225,6 +231,7 @@ disable = [
   "no-else-continue",
   "no-else-raise",
   "no-else-return",
+  "no-value-for-parameter",
   "protected-access",
   "raw-checker-failed",
   "redefined-outer-name",
@@ -232,10 +239,18 @@ disable = [
   "suppressed-message",
   "too-few-public-methods",
   "too-many-ancestors",
+  "too-many-arguments",
+  "too-many-boolean-expressions",
+  "too-many-branches",
   "too-many-public-methods",
   "too-many-instance-attributes",
+  "too-many-locals",
+  "too-many-nested-blocks",
   "too-many-positional-arguments",
+  "too-many-return-statements",
+  "too-many-statements",
   "trailing-whitespace",
+  "unidiomatic-typecheck",
   "unnecessary-lambda-assignment",
   "unspecified-encoding",
   "useless-import-alias",
@@ -254,6 +269,7 @@ warn_unused_ignores = true
 
 [[tool.mypy.overrides]]
 module = [
+    "_pytest.*",
     "prompt_toolkit.*",
     "pygments.*",
     "pytest.*",

{baisilisp-0.5.2.dev1 → baisilisp-0.5.2.dev11}/rust/Cargo.lock

@@ -4,7 +4,7 @@ version = 4
 
 [[package]]
 name = "basilisp-native"
-version = "0.5.2-dev.1"
+version = "0.5.2-dev.11"
 dependencies = [
  "parking_lot",
  "pyo3",

{baisilisp-0.5.2.dev1 → baisilisp-0.5.2.dev11}/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "basilisp-native"
-version = "0.5.2-dev.1"
+version = "0.5.2-dev.11"
 edition = "2021"
 
 [lib]

{baisilisp-0.5.2.dev1 → baisilisp-0.5.2.dev11}/src/basilisp/contrib/core_server.py

@@ -7,9 +7,12 @@ import socketserver
 import threading
 
 if not hasattr(builtins, "_basilisp_core_server_registry"):
-    builtins._basilisp_core_server_registry = (threading.RLock(), {})
+    builtins._basilisp_core_server_registry = (  # type: ignore[attr-defined]
+        threading.RLock(),
+        {},
+    )
 
-_LOCK, _SERVERS = builtins._basilisp_core_server_registry
+_LOCK, _SERVERS = builtins._basilisp_core_server_registry  # type: ignore[attr-defined]
 
 
 def register_and_start(

{baisilisp-0.5.2.dev1 → baisilisp-0.5.2.dev11}/src/basilisp/contrib/prepl_server.py

@@ -56,7 +56,7 @@ class SeekableTextReader(io.TextIOBase):
         self._position += len(value)
         return value
 
-    def readline(self, size: int | None = -1) -> str:
+    def readline(self, size: int | None = -1) -> str:  # type: ignore[override]
         """Read one bounded line while preserving the seekable input view.
 
         ``TextIOBase``'s default implementation raises ``UnsupportedOperation``.
@@ -131,7 +131,9 @@ def forward_remote_prepl(
         or not math.isfinite(connect_timeout)
         or connect_timeout <= 0
     ):
-        raise ValueError("connect-timeout must be a finite positive number when supplied")
+        raise ValueError(
+            "connect-timeout must be a finite positive number when supplied"
+        )
 
     client = socket.create_connection((host, port), timeout=connect_timeout)
     client.settimeout(None)

{baisilisp-0.5.2.dev1 → baisilisp-0.5.2.dev11}/src/basilisp/contrib/pytest/testrunner.py

@@ -8,9 +8,10 @@ from collections.abc import Callable, Iterable, Iterator
 from functools import cache
 from pathlib import Path
 from types import GeneratorType
-from typing import cast
+from typing import Any, cast
 
 import pytest
+from _pytest.nodes import Node
 from _pytest.runner import runtestprotocol
 
 from basilisp import main as basilisp
@@ -435,25 +436,10 @@ class BasilispTestItem(pytest.Item):
         self._fixture_manager = fixture_manager
 
     @classmethod
-    def from_parent(  # pylint: disable=arguments-differ,too-many-arguments
-        cls,
-        parent: "BasilispFile",
-        name: str,
-        run_test: TestFunction,
-        namespace: runtime.Namespace,
-        filename: str,
-        fixture_manager: FixtureManager,
-    ):
+    def from_parent(cls, parent: Node, **kwargs: Any) -> "BasilispTestItem":
         """Create a new BasilispTestItem from the parent Node."""
         # https://github.com/pytest-dev/pytest/pull/6680
-        return super().from_parent(
-            parent,
-            name=name,
-            run_test=run_test,
-            namespace=namespace,
-            filename=filename,
-            fixture_manager=fixture_manager,
-        )
+        return super().from_parent(parent, **kwargs)
 
     def setup(self) -> None:
         if not self._fixture_manager.requires_wrapped_execution:

{baisilisp-0.5.2.dev1 → baisilisp-0.5.2.dev11}/src/basilisp/core.lpy

@@ -1024,11 +1024,15 @@
   current-value args)``\\. The function ``f`` may be called multiple times while
   swapping, so should be free of side effects. Return the new value."
   [atom f & args]
-  (let [current (deref atom)
-        new-val (apply f current args)]
-    (if (compare-and-set! atom current new-val)
-      new-val
-      (recur atom f args))) )
+  (loop []
+    (let [current (deref atom)
+          new-val (apply f current args)]
+      (if (compare-and-set! atom current new-val)
+        new-val
+        ;; `args` is already the variadic tail. Recurring with it as one
+        ;; argument changes a zero-argument update into a one-argument update
+        ;; after a contested compare-and-set.
+        (recur)))))
 
 (defn swap-vals!
   "Atomically swap the value of an atom to the return value of ``(apply f
@@ -1036,11 +1040,12 @@
   swapping, so should be free of side effects. Return a vector containing the new
   value and the old value in that order."
   [atom f & args]
-  (let [current (deref atom)
-        new-val (apply f current args)]
-    (if (compare-and-set! atom current new-val)
-      [new-val current]
-      (recur atom f args))))
+  (loop []
+    (let [current (deref atom)
+          new-val (apply f current args)]
+      (if (compare-and-set! atom current new-val)
+        [new-val current]
+        (recur)))))
 
 (defn atom
   "Return an Atom containing ``v``\\. The value of an Atom at any point in time may be

{baisilisp-0.5.2.dev1 → baisilisp-0.5.2.dev11}/src/basilisp/lang/compiler/generator.py

@@ -2705,7 +2705,7 @@ def _loop_to_py_ast(ctx: GeneratorContext, node: Loop) -> GeneratedPyAST:
             loop_body_ast = list(map(statementize, body_ast.dependencies))
             loop_body_ast.append(ast.Return(value=body_ast.node))
 
-        loop_fn = (ast.AsyncFunctionDef if is_async else ast.FunctionDef)(
+        loop_fn = _fn_node(
             name=loop_fn_name,
             args=ast.arguments(
                 posonlyargs=[],
@@ -2721,6 +2721,7 @@ def _loop_to_py_ast(ctx: GeneratorContext, node: Loop) -> GeneratedPyAST:
                 _ASYNC_TRAMPOLINE_FN_NAME if is_async else _TRAMPOLINE_FN_NAME
             ],
             returns=None,
+            is_async=is_async,
         )
         loop_call = ast.Call(
             func=ast.Name(id=loop_fn_name, ctx=ast.Load()),

{baisilisp-0.5.2.dev1 → baisilisp-0.5.2.dev11}/src/basilisp/lang/map.py

@@ -207,7 +207,7 @@ def map_lrepr(  # pylint: disable=too-many-locals
     return f"{ns_prefix}{start}{seq_lrepr}{end}"
 
 
-@lrepr.register(dict)
+@lrepr.register(dict)  # type: ignore[attr-defined, untyped-decorator]
 def _lrepr_py_dict(o: dict, **kwargs: Unpack[PrintSettings]) -> str:
     return f"#py {map_lrepr(o.items, '{', '}', **kwargs)}"
 
@@ -411,11 +411,15 @@ class PersistentSortedMap(PersistentMap[K, V]):
     def comparator(self):
         return self._comparator
 
-    def _sorted_items(self):
+    def _sorted_items(self) -> list[tuple[K, V]]:
         compare = _comparator_fn(self._comparator)
+
+        def compare_entries(left: tuple[K, V], right: tuple[K, V]) -> int:
+            return compare(left[0], right[0])
+
         return sorted(
             self._inner.items(),
-            key=functools.cmp_to_key(lambda left, right: compare(left[0], right[0])),
+            key=functools.cmp_to_key(compare_entries),
         )
 
     def _new(self, m: "_Map[K, V]", meta: IPersistentMap | None = None):
@@ -474,9 +478,7 @@ class PersistentSortedMap(PersistentMap[K, V]):
     def seq(self) -> ISeq[IMapEntry[K, V]] | None:
         if len(self._inner) == 0:
             return None
-        return iterator_sequence(
-            (MapEntry.of(k, v) for k, v in self._sorted_items())
-        )
+        return iterator_sequence((MapEntry.of(k, v) for k, v in self._sorted_items()))
 
     def reduce_kv(self, f: ReduceKVFunction, init: T_reduce) -> T_reduce:
         for k, v in self._sorted_items():

{baisilisp-0.5.2.dev1 → baisilisp-0.5.2.dev11}/src/basilisp/lang/runtime.py

@@ -1152,6 +1152,7 @@ def local_var(name: sym.Symbol) -> Var:
         _LOCAL_VAR_NS = Namespace(sym.symbol("basilisp.local-vars"))
     return Var(_LOCAL_VAR_NS, name, dynamic=True)
 
+
 T = TypeVar("T")
 
 
@@ -2145,7 +2146,6 @@ def lrepr(
     core_ns = Namespace.get(CORE_NS_SYM)
     assert core_ns is not None
     print_dup = core_ns.find(sym.symbol(PRINT_DUP_VAR_NAME)).value  # type: ignore
-    print_fn = None
     if print_methods:
         print_method = core_ns.find(sym.symbol(PRINT_METHOD_VAR_NAME)).value  # type: ignore
         print_dup_method = core_ns.find(sym.symbol(PRINT_DUP_METHOD_VAR_NAME)).value  # type: ignore
@@ -2158,7 +2158,7 @@ def lrepr(
                 multifn.default
             )
 
-        def print_fn(value) -> str | None:
+        def _custom_print_fn(value) -> str | None:
             writer = io.StringIO()
             if print_dup:
                 method, default = selected_method(print_dup_method, value)
@@ -2172,22 +2172,26 @@ def lrepr(
                 print_method(value, writer)
             return writer.getvalue()
 
-    kwargs = dict(
-        human_readable=human_readable,
-        print_dup=print_dup,
-        print_length=core_ns.find(  # type: ignore
+        custom_print_fn = _custom_print_fn
+    else:
+        custom_print_fn = None
+
+    kwargs = {
+        "human_readable": human_readable,
+        "print_dup": print_dup,
+        "print_length": core_ns.find(  # type: ignore
             sym.symbol(PRINT_LENGTH_VAR_NAME)
         ).value,
-        print_level=core_ns.find(  # type: ignore
+        "print_level": core_ns.find(  # type: ignore
             sym.symbol(PRINT_LEVEL_VAR_NAME)
         ).value,
-        print_meta=core_ns.find(sym.symbol(PRINT_META_VAR_NAME)).value,  # type: ignore
-        print_namespace_maps=core_ns.find(sym.symbol(PRINT_NAMESPACE_MAPS_VAR_NAME)).value,  # type: ignore
-        print_readably=core_ns.find(  # type: ignore
+        "print_meta": core_ns.find(sym.symbol(PRINT_META_VAR_NAME)).value,  # type: ignore
+        "print_namespace_maps": core_ns.find(sym.symbol(PRINT_NAMESPACE_MAPS_VAR_NAME)).value,  # type: ignore
+        "print_readably": core_ns.find(  # type: ignore
             sym.symbol(PRINT_READABLY_VAR_NAME)
         ).value,
-        print_fn=print_fn,
-    )
+        "print_fn": custom_print_fn,
+    }
     if skip_root_custom:
         return lobj._lrepr(o, **kwargs)  # pylint: disable=protected-access
     return lobj.lrepr(o, **kwargs)

{baisilisp-0.5.2.dev1 → baisilisp-0.5.2.dev11}/src/basilisp/lang/set.py

@@ -215,7 +215,10 @@ class PersistentSortedSet(PersistentSet[T]):
         return self._comparator
 
     def _sorted_members(self):
-        return sorted(self._inner.keys(), key=functools.cmp_to_key(_comparator_fn(self._comparator)))
+        return sorted(
+            self._inner.keys(),
+            key=functools.cmp_to_key(_comparator_fn(self._comparator)),
+        )
 
     def _new(self, m: "_Map[T, T]", meta: IPersistentMap | None = None):
         return PersistentSortedSet(
@@ -271,7 +274,11 @@ def s(*members: T, meta: IPersistentMap | None = None) -> PersistentSet[T]:
 
 
 def sorted_set(
-    comparator: Callable[[T, T], int | bool], *members: T, meta: IPersistentMap | None = None
+    comparator: Callable[[T, T], int | bool],
+    *members: T,
+    meta: IPersistentMap | None = None,
 ) -> PersistentSortedSet[T]:
     """Create a persistent set whose iteration order follows ``comparator``."""
-    return PersistentSortedSet(_Map((member, member) for member in members), comparator, meta=meta)
+    return PersistentSortedSet(
+        _Map((member, member) for member in members), comparator, meta=meta
+    )

{baisilisp-0.5.2.dev1 → baisilisp-0.5.2.dev11}/src/basilisp/project.py

@@ -2,14 +2,15 @@
 
 from __future__ import annotations
 
+import sys
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Mapping
 
-try:
+if sys.version_info >= (3, 11):
     import tomllib
-except ModuleNotFoundError:  # pragma: no cover - Python 3.10 only
-    import tomli as tomllib  # type: ignore[import-not-found, no-redef]
+else:  # pragma: no cover - Python 3.10 only
+    import tomli as tomllib
 
 
 _COMPILER_OPTIONS = frozenset(

{baisilisp-0.5.2.dev1 → baisilisp-0.5.2.dev11}/src/basilisp/test.lpy

@@ -195,10 +195,17 @@
     (cond
       (vector? expr)     :default
       (sequential? expr) (let [maybe-f (first expr)]
-                           (if (and (symbol? maybe-f)
-                                    (or (= 'basilisp.core/= maybe-f)
-                                        (#{'thrown-with-msg? 'thrown?} (symbol maybe-f))))
-                             (symbol (name maybe-f))
+                           (if (symbol? maybe-f)
+                             (cond
+                               (= 'basilisp.core/= maybe-f) (symbol (name maybe-f))
+                               (#{'thrown-with-msg? 'thrown?} (symbol maybe-f))
+                               (symbol (name maybe-f))
+                               ;; clojure-test-suite defines this portable assertion
+                               ;; method with Basilisp's pre-0.5 argument order.
+                               ;; Dispatch it to our compatible implementation instead
+                               ;; of evaluating ``p/thrown?`` as a regular function.
+                               (= 'p/thrown? maybe-f) 'portable-thrown?
+                               :else maybe-f)
                              maybe-f))
       :else              :default)))
 
@@ -277,6 +284,23 @@
                      :actual e#
                      :expected ~exc-type})))))
 
+(defmethod assert-expr 'portable-thrown?
+  [msg expr]
+  "Support clojure-test-suite's portable ``p/thrown?`` assertion form.
+
+  Unlike :lpy:fn:`thrown?`, this form accepts no exception class and succeeds
+  for any ordinary Python exception."
+  (let [body (rest expr)]
+    `(try
+       (let [result# (do ~@body)]
+         (do-report {:type :fail
+                     :message ~msg
+                     :expr (quote ~expr)
+                     :actual result#
+                     :expected (quote ~expr)}))
+       (catch python/Exception e#
+         e#))))
+
 (defmethod assert-expr :default
   [msg expr]
   `(let [computed# ~expr]