xobjects 0.6.10__tar.gz → 0.7.1__tar.gz

{xobjects-0.6.10/xobjects.egg-info → xobjects-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xobjects
-Version: 0.6.10
+Version: 0.7.1
 Summary: In-memory serialization and code generator for CPU and GPU
 Home-page: https://xsuite.readthedocs.io/
 Download-URL: https://pypi.python.org/pypi/xobjects

{xobjects-0.6.10 → xobjects-0.7.1}/tests/test_capi.py

@@ -21,6 +21,15 @@ class Struct1(xo.Struct):
     field2 = xo.Float64
 
 
+class RawValue(xo.RawUnion):
+    scalar = xo.Float64
+    bits = xo.UInt64
+
+
+class StructRawUnion(xo.Struct):
+    value = RawValue
+
+
 class Struct2(xo.Struct):
     field1 = xo.Int32
     field2 = xo.Float64[:]
@@ -243,6 +252,36 @@ def test_struct1():
     assert p2[0] == s1.field2
 
 
+def test_raw_union_member_getters():
+    kernels = StructRawUnion._gen_kernels()
+    ctx = xo.ContextCpu()
+    ctx.add_kernels(kernels=kernels)
+
+    source = StructRawUnion._gen_c_api().source
+    assert "StructRawUnion_get_value_scalar" in source
+    assert "StructRawUnion_get_value_bits" in source
+    assert "StructRawUnion_get_value(" not in source
+
+    value = 3.5
+    value_bits = np.array([value], dtype=np.float64).view(np.uint64)[0]
+    s1 = StructRawUnion(value=value)
+    s2 = StructRawUnion(value=("bits", value_bits))
+    raw_value = RawValue(value)
+
+    assert isinstance(s1.value, RawValue)
+    assert s1.value.scalar == value
+    assert s1.value.bits == value_bits
+    assert s2.value.scalar == value
+    assert s2.value.bits == value_bits
+    assert raw_value.scalar == value
+    assert raw_value.bits == value_bits
+
+    assert ctx.kernels.StructRawUnion_get_value_scalar(obj=s1) == value
+    assert ctx.kernels.StructRawUnion_get_value_bits(obj=s1) == value_bits
+    assert ctx.kernels.StructRawUnion_get_value_scalar(obj=s2) == value
+    assert ctx.kernels.StructRawUnion_get_value_bits(obj=s2) == value_bits
+
+
 def test_struct2():
     s2 = Struct2(field1=2, field2=5)
 

{xobjects-0.6.10 → xobjects-0.7.1}/tests/test_general.py

@@ -12,44 +12,44 @@ from xobjects.test_helpers import allow_kernel_compilation
 def test_print_mode_default(capsys):
     printer = Print()
 
-    printer('visible')
+    printer("visible")
 
-    assert capsys.readouterr().out == 'visible\n'
+    assert capsys.readouterr().out == "visible\n"
 
 
 def test_print_mode_suppressed(capsys):
     printer = Print()
-    with xo.settings.override(print_mode='suppress'):
-        printer('hidden')
+    with xo.settings.override(print_mode="suppress"):
+        printer("hidden")
 
-    assert capsys.readouterr().out == ''
+    assert capsys.readouterr().out == ""
 
 
 def test_settings_control_xsuite_printer(capsys):
-    with xo.settings.override(print_mode='suppress'):
-        xo._print('hidden')
+    with xo.settings.override(print_mode="suppress"):
+        xo._print("hidden")
 
-    assert capsys.readouterr().out == ''
+    assert capsys.readouterr().out == ""
 
 
 def test_python_setting_overrides_environment_default(capsys):
-    with xo.settings.override(print_mode='print'):
-        xo._print('visible')
+    with xo.settings.override(print_mode="print"):
+        xo._print("visible")
 
-    assert capsys.readouterr().out == 'visible\n'
+    assert capsys.readouterr().out == "visible\n"
 
 
 def test_invalid_print_mode_setting():
-    with pytest.raises(ValueError, match='XSUITE_PRINT_MODE.*print.*suppress'):
-        xo.settings.print_mode = 'invalid'
+    with pytest.raises(ValueError, match="XSUITE_PRINT_MODE.*print.*suppress"):
+        xo.settings.print_mode = "invalid"
 
 
 def test_settings_override_restores_value_after_error():
     original = xo.settings.print_mode
 
     with pytest.raises(RuntimeError):
-        with xo.settings.override(print_mode='suppress'):
-            assert xo.settings.print_mode == 'suppress'
+        with xo.settings.override(print_mode="suppress"):
+            assert xo.settings.print_mode == "suppress"
             raise RuntimeError
 
     assert xo.settings.print_mode == original
@@ -57,84 +57,88 @@ def test_settings_override_restores_value_after_error():
 
 def test_settings_are_discoverable():
     expected_settings = {
-        'print_mode',
-        'progress_indicator',
-        'allow_kernel_compilation',
-        'force_kernel_compilation',
-        'show_kernel_diagnostics',
-        'cffi_forbid_compile',
-        'cffi_keep_build_files',
-        'cuda_backend',
-        'cuda_fast_compile',
-        'cuda_compiler',
+        "print_mode",
+        "progress_indicator",
+        "allow_kernel_compilation",
+        "force_kernel_compilation",
+        "show_kernel_diagnostics",
+        "cffi_forbid_compile",
+        "cffi_keep_build_files",
+        "cuda_backend",
+        "cuda_fast_compile",
+        "cuda_compiler",
     }
 
     assert expected_settings <= set(dir(xo.settings))
     for name in expected_settings:
-        assert f'{name}=' in repr(xo.settings)
+        assert f"{name}=" in repr(xo.settings)
         assert name in type(xo.settings).__doc__
 
 
 def test_print_mode_environment_variable_is_startup_default():
     environment = os.environ.copy()
-    environment['XSUITE_PRINT_MODE'] = 'suppress'
+    environment["XSUITE_PRINT_MODE"] = "suppress"
     code = (
-        'import xobjects as xo; '
+        "import xobjects as xo; "
         'assert xo.settings.print_mode == "suppress"; '
-        'xo._print("hidden")')
+        'xo._print("hidden")'
+    )
 
     completed = subprocess.run(
-        [sys.executable, '-c', code],
+        [sys.executable, "-c", code],
         env=environment,
         capture_output=True,
         text=True,
         check=True,
     )
 
-    assert completed.stdout == ''
+    assert completed.stdout == ""
 
 
 def test_print_mode_environment_variable_can_be_overridden_in_python():
     environment = os.environ.copy()
-    environment['XSUITE_PRINT_MODE'] = 'suppress'
+    environment["XSUITE_PRINT_MODE"] = "suppress"
     code = (
-        'import xobjects as xo; '
+        "import xobjects as xo; "
         'xo.settings.print_mode = "print"; '
         'assert xo.settings.print_mode == "print"; '
-        'xo._print("visible")')
+        'xo._print("visible")'
+    )
 
     completed = subprocess.run(
-        [sys.executable, '-c', code],
+        [sys.executable, "-c", code],
         env=environment,
         capture_output=True,
         text=True,
         check=True,
     )
 
-    assert completed.stdout == 'visible\n'
+    assert completed.stdout == "visible\n"
 
 
 def test_environment_change_after_import_does_not_override_python_setting(
-        capsys, monkeypatch):
-    with xo.settings.override(print_mode='print'):
-        monkeypatch.setenv('XSUITE_PRINT_MODE', 'suppress')
-        xo._print('visible')
+    capsys, monkeypatch
+):
+    with xo.settings.override(print_mode="print"):
+        monkeypatch.setenv("XSUITE_PRINT_MODE", "suppress")
+        xo._print("visible")
 
-    assert capsys.readouterr().out == 'visible\n'
+    assert capsys.readouterr().out == "visible\n"
 
 
-@pytest.mark.parametrize('value', ['1', 'true', 'YES', 'on'])
+@pytest.mark.parametrize("value", ["1", "true", "YES", "on"])
 def test_boolean_environment_true_values(value):
     environment = os.environ.copy()
-    environment['XSUITE_ALLOW_KERNEL_COMPILATION'] = value
+    environment["XSUITE_ALLOW_KERNEL_COMPILATION"] = value
     code = (
-        'import xobjects as xo; '
-        'assert xo.settings.allow_kernel_compilation is True; '
-        'xo.settings.allow_kernel_compilation = False; '
-        'assert xo.settings.allow_kernel_compilation is False')
+        "import xobjects as xo; "
+        "assert xo.settings.allow_kernel_compilation is True; "
+        "xo.settings.allow_kernel_compilation = False; "
+        "assert xo.settings.allow_kernel_compilation is False"
+    )
 
     subprocess.run(
-        [sys.executable, '-c', code],
+        [sys.executable, "-c", code],
         env=environment,
         capture_output=True,
         text=True,
@@ -142,16 +146,17 @@ def test_boolean_environment_true_values(value):
     )
 
 
-@pytest.mark.parametrize('value', ['0', 'false', 'NO', 'off'])
+@pytest.mark.parametrize("value", ["0", "false", "NO", "off"])
 def test_boolean_environment_false_values(value):
     environment = os.environ.copy()
-    environment['XSUITE_FORCE_KERNEL_COMPILATION'] = value
+    environment["XSUITE_FORCE_KERNEL_COMPILATION"] = value
     code = (
-        'import xobjects as xo; '
-        'assert xo.settings.force_kernel_compilation is False')
+        "import xobjects as xo; "
+        "assert xo.settings.force_kernel_compilation is False"
+    )
 
     subprocess.run(
-        [sys.executable, '-c', code],
+        [sys.executable, "-c", code],
         env=environment,
         capture_output=True,
         text=True,
@@ -161,46 +166,49 @@ def test_boolean_environment_false_values(value):
 
 def test_invalid_boolean_environment_value():
     environment = os.environ.copy()
-    environment['XSUITE_CFFI_FORBID_COMPILE'] = 'sometimes'
+    environment["XSUITE_CFFI_FORBID_COMPILE"] = "sometimes"
 
     completed = subprocess.run(
-        [sys.executable, '-c', 'import xobjects'],
+        [sys.executable, "-c", "import xobjects"],
         env=environment,
         capture_output=True,
         text=True,
     )
 
     assert completed.returncode != 0
-    assert 'Invalid boolean value' in completed.stderr
-    assert 'xobjects.settings.cffi_forbid_compile' in completed.stderr
-    assert 'XSUITE_CFFI_FORBID_COMPILE' in completed.stderr
+    assert "Invalid boolean value" in completed.stderr
+    assert "xobjects.settings.cffi_forbid_compile" in completed.stderr
+    assert "XSUITE_CFFI_FORBID_COMPILE" in completed.stderr
 
 
 def test_runtime_settings_environment_defaults():
     environment = os.environ.copy()
-    environment.update({
-        'XSUITE_PROGRESS_INDICATOR': 'text',
-        'XSUITE_FORCE_KERNEL_COMPILATION': 'yes',
-        'XSUITE_SHOW_KERNEL_DIAGNOSTICS': 'on',
-        'XSUITE_CFFI_FORBID_COMPILE': 'true',
-        'XSUITE_CFFI_KEEP_BUILD_FILES': '1',
-        'XSUITE_CUDA_BACKEND': 'clang',
-        'XSUITE_CUDA_FAST_COMPILE': 'false',
-        'XSUITE_CUDA_COMPILER': '/path/to/clang++',
-    })
+    environment.update(
+        {
+            "XSUITE_PROGRESS_INDICATOR": "text",
+            "XSUITE_FORCE_KERNEL_COMPILATION": "yes",
+            "XSUITE_SHOW_KERNEL_DIAGNOSTICS": "on",
+            "XSUITE_CFFI_FORBID_COMPILE": "true",
+            "XSUITE_CFFI_KEEP_BUILD_FILES": "1",
+            "XSUITE_CUDA_BACKEND": "clang",
+            "XSUITE_CUDA_FAST_COMPILE": "false",
+            "XSUITE_CUDA_COMPILER": "/path/to/clang++",
+        }
+    )
     code = (
-        'import xobjects as xo; '
+        "import xobjects as xo; "
         'assert xo.settings.progress_indicator == "text"; '
-        'assert xo.settings.force_kernel_compilation is True; '
-        'assert xo.settings.show_kernel_diagnostics is True; '
-        'assert xo.settings.cffi_forbid_compile is True; '
-        'assert xo.settings.cffi_keep_build_files is True; '
+        "assert xo.settings.force_kernel_compilation is True; "
+        "assert xo.settings.show_kernel_diagnostics is True; "
+        "assert xo.settings.cffi_forbid_compile is True; "
+        "assert xo.settings.cffi_keep_build_files is True; "
         'assert xo.settings.cuda_backend == "clang"; '
-        'assert xo.settings.cuda_fast_compile is False; '
-        'assert xo.settings.cuda_compiler == "/path/to/clang++"')
+        "assert xo.settings.cuda_fast_compile is False; "
+        'assert xo.settings.cuda_compiler == "/path/to/clang++"'
+    )
 
     subprocess.run(
-        [sys.executable, '-c', code],
+        [sys.executable, "-c", code],
         env=environment,
         capture_output=True,
         text=True,
@@ -209,7 +217,7 @@ def test_runtime_settings_environment_defaults():
 
 
 @pytest.mark.parametrize(
-    'allow, force, compilation_allowed',
+    "allow, force, compilation_allowed",
     [
         (False, False, False),
         (True, False, True),
@@ -222,12 +230,14 @@ def test_kernel_compilation_settings(allow, force, compilation_allowed):
         allow_kernel_compilation=allow,
         force_kernel_compilation=force,
     ):
-        assert xo.context_cpu.kernel_compilation_allowed(
-            xo.ContextCpu()) is compilation_allowed
+        assert (
+            xo.context_cpu.kernel_compilation_allowed(xo.ContextCpu())
+            is compilation_allowed
+        )
 
 
 def test_user_context_environment_variable(monkeypatch):
-    monkeypatch.setenv('XOBJECTS_USER_CONTEXT', 'ContextCpu:auto')
+    monkeypatch.setenv("XOBJECTS_USER_CONTEXT", "ContextCpu:auto")
     context = xo.get_user_context()
 
     assert context.openmp_enabled
@@ -235,8 +245,8 @@ def test_user_context_environment_variable(monkeypatch):
 
 def test_test_contexts_environment_variable(monkeypatch):
     monkeypatch.setenv(
-        'XOBJECTS_TEST_CONTEXTS',
-        'ContextCpu;ContextCpu:auto',
+        "XOBJECTS_TEST_CONTEXTS",
+        "ContextCpu;ContextCpu:auto",
     )
 
     contexts = list(xo.context.get_test_contexts())
@@ -252,8 +262,8 @@ def test_cffi_forbid_compile_setting():
             xo.ContextCpu().build_kernels({})
 
     message = str(err.value)
-    assert 'xobjects.settings.cffi_forbid_compile' in message
-    assert 'XSUITE_CFFI_FORBID_COMPILE' in message
+    assert "xobjects.settings.cffi_forbid_compile" in message
+    assert "XSUITE_CFFI_FORBID_COMPILE" in message
 
 
 def test_allow_kernel_compilation_decorator_restores_state():

{xobjects-0.6.10 → xobjects-0.7.1}/tests/test_hybrid_class.py

@@ -332,6 +332,28 @@ def test_to_json_defaults():
     assert b_dict == {}
 
 
+def test_to_dict_scalar_raw_union_defaults():
+    class ScalarUnion(xo.RawUnion):
+        scalar = xo.Float64
+        bits = xo.UInt64
+
+        @classmethod
+        def _from_buffer(cls, buffer, offset=0, container=None):
+            return xo.Float64._from_buffer(buffer, offset)
+
+    class A(xo.HybridClass):
+        _xofields = {
+            "a": ScalarUnion,
+            "b": xo.Field(ScalarUnion, default=2.5),
+            "c": xo.Field(ScalarUnion, default_factory=lambda: 3.5),
+        }
+
+    assert A().to_dict() == {"__class__": "A"}
+    values = {"__class__": "A", "a": 1.5, "b": 0.0, "c": 0.0}
+    for copy_to_cpu in (True, False):
+        assert A.from_dict(values).to_dict(copy_to_cpu=copy_to_cpu) == values
+
+
 def test_to_dict_python_vars():
     class TD(xo.HybridClass):
         _xofields = {

xobjects-0.7.1/tests/test_raw_union.py

@@ -0,0 +1,78 @@
+# copyright ################################# #
+# This file is part of the Xobjects Package.  #
+# Copyright (c) CERN, 2026.                   #
+# ########################################### #
+
+import numpy as np
+import pytest
+
+import xobjects as xo
+
+
+class RawValue(xo.RawUnion):
+    scalar = xo.Float64
+    bits = xo.UInt64
+
+
+class Holder(xo.Struct):
+    value = RawValue
+
+
+def _float_bits(value):
+    return np.array([value], dtype=np.float64).view(np.uint64)[0]
+
+
+def test_raw_union_declaration_consumes_member_attributes():
+    assert RawValue._members == {"scalar": xo.Float64, "bits": xo.UInt64}
+    assert RawValue._size == 8
+
+    assert not hasattr(RawValue, "scalar")
+    assert not hasattr(RawValue, "bits")
+
+
+def test_raw_union_standalone_instance_reads_explicit_members():
+    value = 3.5
+    raw_value = RawValue(value)
+
+    assert isinstance(raw_value, RawValue)
+    assert raw_value.scalar == value
+    assert raw_value.bits == _float_bits(value)
+    assert "scalar" in dir(raw_value)
+    assert "bits" in dir(raw_value)
+
+    with pytest.raises(AttributeError, match="missing"):
+        raw_value.missing
+
+
+def test_raw_union_struct_field_reads_explicit_members():
+    value = 3.5
+    holder = Holder(value=value)
+
+    assert isinstance(holder.value, RawValue)
+    assert holder.value.scalar == value
+    assert holder.value.bits == _float_bits(value)
+
+    with pytest.raises(TypeError):
+        float(holder.value)
+
+
+def test_raw_union_constructor_accepts_explicit_member():
+    value = 3.5
+    value_bits = _float_bits(value)
+    holder = Holder(value=("bits", value_bits))
+
+    assert holder.value.scalar == value
+    assert holder.value.bits == value_bits
+
+
+def test_raw_union_copy_from_same_type():
+    source = RawValue(3.5)
+    holder = Holder(value=0.0)
+
+    holder.value = source
+    assert holder.value.scalar == source.scalar
+    assert holder.value.bits == source.bits
+
+    copied = RawValue(source)
+    assert copied.scalar == source.scalar
+    assert copied.bits == source.bits

{xobjects-0.6.10 → xobjects-0.7.1}/xobjects/__init__.py

@@ -16,6 +16,7 @@ from .scalar import (
     UInt8,
 )
 from .array import Array
+from .raw_union import RawUnion
 from .string import String
 from .struct import Struct, Field, ThisClass
 from .ref import Ref, UnionRef

xobjects-0.7.1/xobjects/_version.py

@@ -0,0 +1 @@
+__version__ = "0.7.1"

{xobjects-0.6.10 → xobjects-0.7.1}/xobjects/array.py

@@ -414,7 +414,7 @@ class Array(metaclass=MetaArray):
         return info
 
     @classmethod
-    def _from_buffer(cls, buffer, offset=0):
+    def _from_buffer(cls, buffer, offset=0, container=None):
         self = object.__new__(cls)
         self._buffer = buffer
         self._offset = offset
@@ -451,7 +451,7 @@ class Array(metaclass=MetaArray):
         return self
 
     @classmethod
-    def _to_buffer(cls, buffer, offset, value, info=None):
+    def _to_buffer(cls, buffer, offset, value, info=None, container=None):
         if info is None:
             info = cls._inspect_args(value)
         value = info.value  # can be None if value contained shape info