koatl 0.3.12__tar.gz → 0.3.14__tar.gz

{koatl-0.3.12 → koatl-0.3.14}/Cargo.lock

@@ -190,7 +190,7 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "koatl"
-version = "0.3.12"
+version = "0.3.14"
 dependencies = [
  "ariadne",
  "koatl-core",

{koatl-0.3.12 → koatl-0.3.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: koatl
-Version: 0.3.12
+Version: 0.3.14
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{koatl-0.3.12 → koatl-0.3.14}/koatl/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "koatl"
-version = "0.3.12"
+version = "0.3.14"
 edition = "2021"
 
 [lib]

koatl-0.3.14/koatl/python/koatl/runtime/vattr.py

@@ -0,0 +1,66 @@
+from functools import partial
+from itertools import count
+from koatl._rs import fast_vget
+
+
+def vget(obj, name, ignore_traits=False):
+    try:
+        return getattr(obj, name)
+    except AttributeError as e:
+        # special case for iter - this could be implemented using types and trait vtbls
+        # but this is simpler and probably faster
+        if name == "iter":
+            if isinstance(obj, slice):
+                start = obj.start if obj.start is not None else 0
+                step = obj.step if obj.step is not None else 1
+                if obj.stop is None:
+                    return iter(count(start, step))
+                else:
+                    return iter(range(start, obj.stop, step))
+
+            try:
+                return iter(obj.items())
+            except AttributeError:
+                pass
+
+            try:
+                return iter(obj)
+            except TypeError:
+                pass
+
+        v = fast_vget(obj, name, ignore_traits)
+        if v is not None:
+            if hasattr(v, "_property"):
+                return v(obj)
+
+            return partial(v, obj)
+
+        e.__traceback__ = None
+        raise
+
+
+def vhas(obj, name, ignore_traits=False):
+    if hasattr(obj, name):
+        return True
+
+    if name == "iter":
+        if isinstance(obj, slice):
+            return True
+
+        try:
+            obj.items()
+            return True
+        except AttributeError:
+            pass
+
+        try:
+            iter(obj)
+            return True
+        except TypeError:
+            pass
+
+    v = fast_vget(obj, name, ignore_traits)
+    if v is not None:
+        return True
+
+    return False

{koatl-0.3.12 → koatl-0.3.14}/koatl/src/emit_py.rs

@@ -631,6 +631,12 @@ impl<'src> PyExprExt<'src> for SPyExpr<'src> {
                     PyBinaryOp::FloorDiv => Some("FloorDiv"),
                     PyBinaryOp::Mod => Some("Mod"),
                     PyBinaryOp::Pow => Some("Pow"),
+                    PyBinaryOp::BitAnd => Some("BitAnd"),
+                    PyBinaryOp::BitOr => Some("BitOr"),
+                    PyBinaryOp::BitXor => Some("BitXor"),
+                    PyBinaryOp::MatMult => Some("MatMult"),
+                    PyBinaryOp::LShift => Some("LShift"),
+                    PyBinaryOp::RShift => Some("RShift"),
                     _ => None,
                 };
 

koatl-0.3.14/koatl/tests/parse/operators.tl

@@ -0,0 +1 @@
+1 >> 2 << 3 ^^ 4 // 5 && 6 ** (1 || 2 @@ -3)

{koatl-0.3.12 → koatl-0.3.14}/koatl-core/src/transform.rs

@@ -956,8 +956,8 @@ fn make_arglist<'src, 'ast>(
     info: &FnInfo,
 ) -> TlResult<PyArgListWithPre<'src>> {
     // Validate Python argument syntax rules
+    let mut seen_posonly_marker: Option<Span> = None;
     {
-        let mut seen_posonly_marker: Option<Span> = None;
         let mut seen_kwonly_marker: Option<Span> = None;
         let mut seen_vararg: Option<Span> = None;
         let mut seen_kwarg = false;
@@ -1050,7 +1050,7 @@ fn make_arglist<'src, 'ast>(
 
     // Track state transitions: posonly -> normal -> kwonly
     // States: 0 = position-only, 1 = normal, 2 = keyword-only
-    let mut state = 0;
+    let mut state = if seen_posonly_marker.is_some() { 0 } else { 1 };
 
     for arg in args {
         match arg {

koatl-0.3.14/python/koatl/runtime/vattr.py

@@ -0,0 +1,66 @@
+from functools import partial
+from itertools import count
+from koatl._rs import fast_vget
+
+
+def vget(obj, name, ignore_traits=False):
+    try:
+        return getattr(obj, name)
+    except AttributeError as e:
+        # special case for iter - this could be implemented using types and trait vtbls
+        # but this is simpler and probably faster
+        if name == "iter":
+            if isinstance(obj, slice):
+                start = obj.start if obj.start is not None else 0
+                step = obj.step if obj.step is not None else 1
+                if obj.stop is None:
+                    return iter(count(start, step))
+                else:
+                    return iter(range(start, obj.stop, step))
+
+            try:
+                return iter(obj.items())
+            except AttributeError:
+                pass
+
+            try:
+                return iter(obj)
+            except TypeError:
+                pass
+
+        v = fast_vget(obj, name, ignore_traits)
+        if v is not None:
+            if hasattr(v, "_property"):
+                return v(obj)
+
+            return partial(v, obj)
+
+        e.__traceback__ = None
+        raise
+
+
+def vhas(obj, name, ignore_traits=False):
+    if hasattr(obj, name):
+        return True
+
+    if name == "iter":
+        if isinstance(obj, slice):
+            return True
+
+        try:
+            obj.items()
+            return True
+        except AttributeError:
+            pass
+
+        try:
+            iter(obj)
+            return True
+        except TypeError:
+            pass
+
+    v = fast_vget(obj, name, ignore_traits)
+    if v is not None:
+        return True
+
+    return False

koatl-0.3.12/koatl/python/koatl/runtime/vattr.py

@@ -1,67 +0,0 @@
-from functools import partial
-from itertools import count
-from koatl._rs import fast_vget
-
-
-def vget(obj, name, ignore_traits=False):
-    try:
-        return getattr(obj, name)
-    except AttributeError as e:
-        orig_err = e
-
-    # special case for iter - this could be implemented using types and trait vtbls
-    # but this is simpler and probably faster
-    if name == "iter":
-        if isinstance(obj, slice):
-            start = obj.start if obj.start is not None else 0
-            step = obj.step if obj.step is not None else 1
-            if obj.stop is None:
-                return iter(count(start, step))
-            else:
-                return iter(range(start, obj.stop, step))
-
-        try:
-            return iter(obj.items())
-        except AttributeError:
-            pass
-
-        try:
-            return iter(obj)
-        except TypeError:
-            pass
-
-    v = fast_vget(obj, name, ignore_traits)
-    if v is not None:
-        if hasattr(v, "_property"):
-            return v(obj)
-
-        return partial(v, obj)
-
-    raise orig_err
-
-
-def vhas(obj, name, ignore_traits=False):
-    if hasattr(obj, name):
-        return True
-
-    if name == "iter":
-        if isinstance(obj, slice):
-            return True
-
-        try:
-            obj.items()
-            return True
-        except AttributeError:
-            pass
-
-        try:
-            iter(obj)
-            return True
-        except TypeError:
-            pass
-
-    v = fast_vget(obj, name, ignore_traits)
-    if v is not None:
-        return True
-
-    return False

koatl-0.3.12/python/koatl/runtime/vattr.py

@@ -1,67 +0,0 @@
-from functools import partial
-from itertools import count
-from koatl._rs import fast_vget
-
-
-def vget(obj, name, ignore_traits=False):
-    try:
-        return getattr(obj, name)
-    except AttributeError as e:
-        orig_err = e
-
-    # special case for iter - this could be implemented using types and trait vtbls
-    # but this is simpler and probably faster
-    if name == "iter":
-        if isinstance(obj, slice):
-            start = obj.start if obj.start is not None else 0
-            step = obj.step if obj.step is not None else 1
-            if obj.stop is None:
-                return iter(count(start, step))
-            else:
-                return iter(range(start, obj.stop, step))
-
-        try:
-            return iter(obj.items())
-        except AttributeError:
-            pass
-
-        try:
-            return iter(obj)
-        except TypeError:
-            pass
-
-    v = fast_vget(obj, name, ignore_traits)
-    if v is not None:
-        if hasattr(v, "_property"):
-            return v(obj)
-
-        return partial(v, obj)
-
-    raise orig_err
-
-
-def vhas(obj, name, ignore_traits=False):
-    if hasattr(obj, name):
-        return True
-
-    if name == "iter":
-        if isinstance(obj, slice):
-            return True
-
-        try:
-            obj.items()
-            return True
-        except AttributeError:
-            pass
-
-        try:
-            iter(obj)
-            return True
-        except TypeError:
-            pass
-
-    v = fast_vget(obj, name, ignore_traits)
-    if v is not None:
-        return True
-
-    return False