xsuite 0.43.1__cp311-cp311-macosx_11_0_arm64.whl

xsuite/lib/only_xtrack_with_synrad.json

@@ -0,0 +1,98 @@
+{
+    "config": {
+        "XFIELDS_BB3D_NO_BEAMSTR": true,
+        "XFIELDS_BB3D_NO_BHABHA": true,
+        "XTRACK_GLOBAL_XY_LIMIT": 1.0
+    },
+    "classes": [
+        "ACDipole",
+        "BeamPositionMonitor",
+        "BeamProfileMonitor",
+        "BeamSizeMonitor",
+        "Bend",
+        "Cavity",
+        "CrabCavity",
+        "DipoleEdge",
+        "Drift",
+        "DriftExact",
+        "DriftExactSlice",
+        "DriftSlice",
+        "DriftSliceBend",
+        "DriftSliceCavity",
+        "DriftSliceCrabCavity",
+        "DriftSliceMultipole",
+        "DriftSliceOctupole",
+        "DriftSliceQuadrupole",
+        "DriftSliceRBend",
+        "DriftSliceSextupole",
+        "Elens",
+        "FirstOrderTaylorMap",
+        "LastTurnsMonitor",
+        "LimitEllipse",
+        "LimitPolygon",
+        "LimitRacetrack",
+        "LimitRect",
+        "LimitRectEllipse",
+        "LineSegmentMap",
+        "LongitudinalLimitRect",
+        "Magnet",
+        "Marker",
+        "Multipole",
+        "MultipoleEdge",
+        "NonLinearLens",
+        "Octupole",
+        "ParticlesMonitor",
+        "Quadrupole",
+        "RBend",
+        "RFMultipole",
+        "ReferenceEnergyIncrease",
+        "SRotation",
+        "SecondOrderTaylorMap",
+        "Sextupole",
+        "SimpleThinBend",
+        "SimpleThinQuadrupole",
+        "Solenoid",
+        "ThickSliceBend",
+        "ThickSliceCavity",
+        "ThickSliceCrabCavity",
+        "ThickSliceMultipole",
+        "ThickSliceOctupole",
+        "ThickSliceQuadrupole",
+        "ThickSliceRBend",
+        "ThickSliceSextupole",
+        "ThickSliceUniformSolenoid",
+        "ThinSliceBend",
+        "ThinSliceBendEntry",
+        "ThinSliceBendExit",
+        "ThinSliceCavity",
+        "ThinSliceCrabCavity",
+        "ThinSliceMultipole",
+        "ThinSliceOctupole",
+        "ThinSliceOctupoleEntry",
+        "ThinSliceOctupoleExit",
+        "ThinSliceQuadrupole",
+        "ThinSliceQuadrupoleEntry",
+        "ThinSliceQuadrupoleExit",
+        "ThinSliceRBend",
+        "ThinSliceRBendEntry",
+        "ThinSliceRBendExit",
+        "ThinSliceSextupole",
+        "ThinSliceSextupoleEntry",
+        "ThinSliceSextupoleExit",
+        "ThinSliceUniformSolenoidEntry",
+        "ThinSliceUniformSolenoidExit",
+        "UniformSolenoid",
+        "VariableSolenoid",
+        "Wire",
+        "XRotation",
+        "XYShift",
+        "YRotation",
+        "ZetaShift"
+    ],
+    "versions": {
+        "xtrack": "0.96.1",
+        "xfields": "0.25.5",
+        "xcoll": "0.7.2",
+        "xobjects": "0.5.7"
+    }
+}

xsuite/prebuild_kernels.py

@@ -0,0 +1,291 @@
+# copyright ############################### #
+# This file is part of the Xsuite project.  #
+# Copyright (c) CERN, 2025.                 #
+# ######################################### #
+
+import json
+import os
+from multiprocessing import Pool
+from pathlib import Path
+from pprint import pformat
+from typing import Iterator, Optional, Tuple
+
+import xsuite as xs
+import xcoll as xc
+from xtrack.prebuilt_kernel_definitions import XTRACK_ELEMENTS_INIT_DEFAULTS
+from xfields.prebuilt_kernel_definitions import XFIELDS_ELEMENTS_INIT_DEFAULTS
+from xcoll.prebuilt_kernel_definitions import XCOLL_ELEMENTS_INIT_DEFAULTS
+import xfields as xf
+import xobjects as xo
+import xtrack as xt
+from xsuite.kernel_definitions import kernel_definitions
+from xtrack.general import _print
+
+XSK_PREBUILT_KERNELS_LOCATION = Path(xs.__file__).parent / 'lib'
+
+BEAM_ELEMENTS_INIT_DEFAULTS = XTRACK_ELEMENTS_INIT_DEFAULTS| XFIELDS_ELEMENTS_INIT_DEFAULTS \
+                            | XCOLL_ELEMENTS_INIT_DEFAULTS
+
+
+def get_element_class_by_name(name: str) -> type:
+    extra_classes = (xt.MultiSetter, )
+
+    element_classes = (xt.element_classes + xt.rng_classes + xt.monitor_classes
+                       + xf.element_classes + xc.element_classes
+                       + extra_classes)
+
+    for cls in element_classes:
+        if cls.__name__ == name:
+            return cls
+
+    raise ValueError(f'No element class with name {name} available.')
+
+
+def save_kernel_metadata(
+        module_name: str,
+        config: dict,
+        kernel_element_classes,
+        location,
+):
+    location = Path(location)
+    out_file = location / f'{module_name}.json'
+
+    kernel_metadata = {
+        'config': config.data,
+        'classes': [cls._DressingClass.__name__ for cls in kernel_element_classes],
+        'versions': {
+            'xtrack': xt.__version__,
+            'xfields': xf.__version__,
+            'xcoll': xc.__version__,
+            'xobjects': xo.__version__,
+        }
+    }
+
+    with out_file.open('w') as fd:
+        json.dump(kernel_metadata, fd, indent=4)
+
+
+def enumerate_kernels(verbose=False) -> Iterator[Tuple[str, dict]]:
+    """
+    Iterate over the prebuilt kernels compatible with the current version of
+    xsuite. The first element of the tuple is the name of the kernel module
+    and the second is a dictionary with the kernel metadata.
+    """
+    for kernel_name, _ in kernel_definitions:
+        metadata_file = XSK_PREBUILT_KERNELS_LOCATION / f'{kernel_name}.json'
+
+        if not metadata_file.exists():
+            continue
+
+        with metadata_file.open('r') as fd:
+            kernel_metadata = json.load(fd)
+
+        needed_versions = kernel_metadata['versions']
+        have_versions = {
+            'xtrack': xt.__version__,
+            'xfields': xf.__version__,
+            'xcoll': xc.__version__,
+            'xobjects': xo.__version__,
+        }
+
+        version_mismatch = False
+        for package in needed_versions.keys():
+            need = needed_versions[package]
+            have = have_versions[package]
+            if need == have:
+                continue
+
+            version_mismatch = True
+            if verbose:
+                _print(
+                    f'Version mismatch for kernel `{kernel_name}`: needs '
+                    f'{package}=={need}, but have {package}=={have}.'
+                )
+
+        if version_mismatch:
+            continue
+
+        yield metadata_file.stem, kernel_metadata
+
+
+def get_suitable_kernel(
+        config: dict,
+        line_element_classes,
+        verbose=False,
+) -> Optional[Tuple[str, list]]:
+    """
+    Given a configuration and a list of element classes, return a tuple with
+    the name of a suitable prebuilt kernel module together with the list of
+    element classes that were used to build it. Set `verbose` to True, to
+    obtain a justification of the choice (or lack thereof) on standard output.
+    """
+    env_var = os.environ.get("XSUITE_PREBUILT_KERNELS")
+    if env_var and env_var == '0':
+        if verbose:
+            _print('Skipping the search for a suitable kernel, as the '
+                   'environment variable XSUITE_PREBUILT_KERNELS == "0".')
+        return
+
+    if os.environ.get("XSUITE_VERBOSE", None) is not None:
+        verbose = True
+
+    requested_class_names = [
+        cls._DressingClass.__name__ for cls in line_element_classes
+    ]
+
+    for module_name, kernel_metadata in enumerate_kernels(verbose=verbose):
+        if verbose:
+            _print(f"==> Considering the precompiled kernel `{module_name}`...")
+
+        available_classes_names = kernel_metadata['classes']
+        if kernel_metadata['config'] != config:
+            if verbose:
+                lhs = kernel_metadata['config']
+                rhs = config
+                config_diff = {kk: (lhs.get(kk), rhs.get(kk))
+                               for kk in set(lhs.keys()) | set(rhs.keys())
+                               if lhs.get(kk) != rhs.get(kk)}
+                _print(f'The kernel `{module_name}` is unsuitable. Its config '
+                      f'(left) and the requested one (right) differ at the '
+                      f'following keys:\n'
+                      f'{pformat(config_diff)}')
+                _print(f'Skipping class compatibility check for `{module_name}`.')
+
+            continue
+
+        if verbose:
+            _print(f'The kernel `{module_name}` has the right config.')
+
+        if set(requested_class_names) <= set(available_classes_names):
+            available_classes = [
+                get_element_class_by_name(class_name)
+                for class_name in available_classes_names
+            ]
+            if verbose:
+                _print(f'Found suitable prebuilt kernel `{module_name}`.')
+            return module_name, available_classes
+        elif verbose:
+            class_diff = set(requested_class_names) - set(available_classes_names)
+            _print(f'The kernel `{module_name}` is unsuitable. It does not '
+                  f'provide the following requested classes: '
+                  f'{", ".join(class_diff)}.')
+
+    if verbose:
+        _print('==> No suitable precompiled kernel found.')
+
+
+def regenerate_kernels(
+        kernels=None,
+        location=XSK_PREBUILT_KERNELS_LOCATION,
+        n_threads=None,
+):
+    """
+    Use the kernel definitions in the `kernel_definitions.py` file to
+    regenerate kernel shared objects using the current version of xsuite.
+    """
+    if kernels is not None and (
+    isinstance(kernels, str) or not hasattr(kernels, '__iter__')):
+        kernels = [kernels]
+
+    location = Path(location)
+
+    # Delete existing kernels to avoid accidentally loading in existing C code
+    clear_kernels(kernels=kernels, location=location)
+
+    kernels_to_build = []
+    for module_name, metadata in kernel_definitions:
+        if kernels is not None and module_name not in kernels:
+            continue
+        kernels_to_build.append((module_name, metadata))
+
+    thread_pool = Pool(processes=n_threads)
+    results = []
+    for idx, (module_name, metadata) in enumerate(kernels_to_build):
+        args = (idx, len(kernels_to_build), location, metadata, module_name)
+        result = thread_pool.apply_async(build_single_kernel, args=args)
+        results.append(result)
+
+    thread_pool.close()
+    thread_pool.join()
+
+    # Ensure no errors
+    for result in results:
+        result.get()
+
+    _print(f'Built {len(kernels_to_build)} kernels.')
+
+
+def build_single_kernel(idx, total, location, metadata, module_name):
+    _print(f'[{idx + 1}/{total}] Building `{module_name}`...')
+
+    config = metadata['config']
+    element_classes = metadata['classes']
+    extra_classes = metadata.get('extra_classes', [])
+
+    elements = []
+    for cls in element_classes:
+        if cls.__name__ in BEAM_ELEMENTS_INIT_DEFAULTS:
+            element = cls(**BEAM_ELEMENTS_INIT_DEFAULTS[cls.__name__])
+        else:
+            element = cls()
+        elements.append(element)
+
+    line = xt.Line(elements=elements)
+    tracker = xt.Tracker(line=line, compile=False, _prebuilding_kernels=True)
+    tracker.config.clear()
+    tracker.config.update(config)
+    tracker_classes = tracker._tracker_data_base.kernel_element_classes
+    expected_classes = [getattr(el, '_XoStruct', el) for el in element_classes]
+    extra_classes.extend(ee for ee in expected_classes if ee not in tracker_classes)
+
+    # Get all kernels in the elements
+    extra_kernels = {}
+    extra_classes.append(xt.Particles)
+    extra_classes = [getattr(el, '_XoStruct', el) for el in extra_classes]
+
+    all_classes = tracker._tracker_data_base.kernel_element_classes + extra_classes
+
+    for el in all_classes:
+        extra_kernels.update(el._kernels)
+
+    tracker._build_kernel(
+        module_name=module_name,
+        containing_dir=location,
+        compile='force',
+        extra_classes=extra_classes,
+        extra_kernels=extra_kernels,
+    )
+
+    all_classes = [cls for cls in all_classes if cls.__name__ != 'ParticlesData']
+
+    save_kernel_metadata(
+        module_name=module_name,
+        config=tracker.config,
+        kernel_element_classes=all_classes,
+        location=location,
+    )
+
+
+def clear_kernels(kernels=None, verbose=False, location=XSK_PREBUILT_KERNELS_LOCATION):
+    if kernels is not None and (
+            isinstance(kernels, str) or not hasattr(kernels, '__iter__')):
+        kernels = [kernels]
+
+    location = Path(location)
+
+    for file in location.iterdir():
+        if file.name.startswith('_'):
+            continue
+        if file.suffix not in ('.c', '.so', '.json'):
+            continue
+        if kernels is not None and file.stem.split('.')[0] not in kernels:
+            continue
+        file.unlink()
+
+        if verbose:
+            print(f'Removed `{file}`.')
+
+
+if __name__ == '__main__':
+    regenerate_kernels()
+

xsuite-0.43.1.dist-info/METADATA

@@ -0,0 +1,230 @@
+Metadata-Version: 2.4
+Name: xsuite
+Version: 0.43.1
+Summary: Integrated suite for particle accelerator simulations.
+Author: Riccardo De Maria, Giovanni Iadarola, Szymon Łopaciuk, et al.
+License:                                  Apache License
+                                   Version 2.0, January 2004
+                                http://www.apache.org/licenses/
+        
+           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+           1. Definitions.
+        
+              "License" shall mean the terms and conditions for use, reproduction,
+              and distribution as defined by Sections 1 through 9 of this document.
+        
+              "Licensor" shall mean the copyright owner or entity authorized by
+              the copyright owner that is granting the License.
+        
+              "Legal Entity" shall mean the union of the acting entity and all
+              other entities that control, are controlled by, or are under common
+              control with that entity. For the purposes of this definition,
+              "control" means (i) the power, direct or indirect, to cause the
+              direction or management of such entity, whether by contract or
+              otherwise, or (ii) ownership of fifty percent (50%) or more of the
+              outstanding shares, or (iii) beneficial ownership of such entity.
+        
+              "You" (or "Your") shall mean an individual or Legal Entity
+              exercising permissions granted by this License.
+        
+              "Source" form shall mean the preferred form for making modifications,
+              including but not limited to software source code, documentation
+              source, and configuration files.
+        
+              "Object" form shall mean any form resulting from mechanical
+              transformation or translation of a Source form, including but
+              not limited to compiled object code, generated documentation,
+              and conversions to other media types.
+        
+              "Work" shall mean the work of authorship, whether in Source or
+              Object form, made available under the License, as indicated by a
+              copyright notice that is included in or attached to the work
+              (an example is provided in the Appendix below).
+        
+              "Derivative Works" shall mean any work, whether in Source or Object
+              form, that is based on (or derived from) the Work and for which the
+              editorial revisions, annotations, elaborations, or other modifications
+              represent, as a whole, an original work of authorship. For the purposes
+              of this License, Derivative Works shall not include works that remain
+              separable from, or merely link (or bind by name) to the interfaces of,
+              the Work and Derivative Works thereof.
+        
+              "Contribution" shall mean any work of authorship, including
+              the original version of the Work and any modifications or additions
+              to that Work or Derivative Works thereof, that is intentionally
+              submitted to Licensor for inclusion in the Work by the copyright owner
+              or by an individual or Legal Entity authorized to submit on behalf of
+              the copyright owner. For the purposes of this definition, "submitted"
+              means any form of electronic, verbal, or written communication sent
+              to the Licensor or its representatives, including but not limited to
+              communication on electronic mailing lists, source code control systems,
+              and issue tracking systems that are managed by, or on behalf of, the
+              Licensor for the purpose of discussing and improving the Work, but
+              excluding communication that is conspicuously marked or otherwise
+              designated in writing by the copyright owner as "Not a Contribution."
+        
+              "Contributor" shall mean Licensor and any individual or Legal Entity
+              on behalf of whom a Contribution has been received by Licensor and
+              subsequently incorporated within the Work.
+        
+           2. Grant of Copyright License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              copyright license to reproduce, prepare Derivative Works of,
+              publicly display, publicly perform, sublicense, and distribute the
+              Work and such Derivative Works in Source or Object form.
+        
+           3. Grant of Patent License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              (except as stated in this section) patent license to make, have made,
+              use, offer to sell, sell, import, and otherwise transfer the Work,
+              where such license applies only to those patent claims licensable
+              by such Contributor that are necessarily infringed by their
+              Contribution(s) alone or by combination of their Contribution(s)
+              with the Work to which such Contribution(s) was submitted. If You
+              institute patent litigation against any entity (including a
+              cross-claim or counterclaim in a lawsuit) alleging that the Work
+              or a Contribution incorporated within the Work constitutes direct
+              or contributory patent infringement, then any patent licenses
+              granted to You under this License for that Work shall terminate
+              as of the date such litigation is filed.
+        
+           4. Redistribution. You may reproduce and distribute copies of the
+              Work or Derivative Works thereof in any medium, with or without
+              modifications, and in Source or Object form, provided that You
+              meet the following conditions:
+        
+              (a) You must give any other recipients of the Work or
+                  Derivative Works a copy of this License; and
+        
+              (b) You must cause any modified files to carry prominent notices
+                  stating that You changed the files; and
+        
+              (c) You must retain, in the Source form of any Derivative Works
+                  that You distribute, all copyright, patent, trademark, and
+                  attribution notices from the Source form of the Work,
+                  excluding those notices that do not pertain to any part of
+                  the Derivative Works; and
+        
+              (d) If the Work includes a "NOTICE" text file as part of its
+                  distribution, then any Derivative Works that You distribute must
+                  include a readable copy of the attribution notices contained
+                  within such NOTICE file, excluding those notices that do not
+                  pertain to any part of the Derivative Works, in at least one
+                  of the following places: within a NOTICE text file distributed
+                  as part of the Derivative Works; within the Source form or
+                  documentation, if provided along with the Derivative Works; or,
+                  within a display generated by the Derivative Works, if and
+                  wherever such third-party notices normally appear. The contents
+                  of the NOTICE file are for informational purposes only and
+                  do not modify the License. You may add Your own attribution
+                  notices within Derivative Works that You distribute, alongside
+                  or as an addendum to the NOTICE text from the Work, provided
+                  that such additional attribution notices cannot be construed
+                  as modifying the License.
+        
+              You may add Your own copyright statement to Your modifications and
+              may provide additional or different license terms and conditions
+              for use, reproduction, or distribution of Your modifications, or
+              for any such Derivative Works as a whole, provided Your use,
+              reproduction, and distribution of the Work otherwise complies with
+              the conditions stated in this License.
+        
+           5. Submission of Contributions. Unless You explicitly state otherwise,
+              any Contribution intentionally submitted for inclusion in the Work
+              by You to the Licensor shall be under the terms and conditions of
+              this License, without any additional terms or conditions.
+              Notwithstanding the above, nothing herein shall supersede or modify
+              the terms of any separate license agreement you may have executed
+              with Licensor regarding such Contributions.
+        
+           6. Trademarks. This License does not grant permission to use the trade
+              names, trademarks, service marks, or product names of the Licensor,
+              except as required for reasonable and customary use in describing the
+              origin of the Work and reproducing the content of the NOTICE file.
+        
+           7. Disclaimer of Warranty. Unless required by applicable law or
+              agreed to in writing, Licensor provides the Work (and each
+              Contributor provides its Contributions) on an "AS IS" BASIS,
+              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+              implied, including, without limitation, any warranties or conditions
+              of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+              PARTICULAR PURPOSE. You are solely responsible for determining the
+              appropriateness of using or redistributing the Work and assume any
+              risks associated with Your exercise of permissions under this License.
+        
+           8. Limitation of Liability. In no event and under no legal theory,
+              whether in tort (including negligence), contract, or otherwise,
+              unless required by applicable law (such as deliberate and grossly
+              negligent acts) or agreed to in writing, shall any Contributor be
+              liable to You for damages, including any direct, indirect, special,
+              incidental, or consequential damages of any character arising as a
+              result of this License or out of the use or inability to use the
+              Work (including but not limited to damages for loss of goodwill,
+              work stoppage, computer failure or malfunction, or any and all
+              other commercial damages or losses), even if such Contributor
+              has been advised of the possibility of such damages.
+        
+           9. Accepting Warranty or Additional Liability. While redistributing
+              the Work or Derivative Works thereof, You may choose to offer,
+              and charge a fee for, acceptance of support, warranty, indemnity,
+              or other liability obligations and/or rights consistent with this
+              License. However, in accepting such obligations, You may act only
+              on Your own behalf and on Your sole responsibility, not on behalf
+              of any other Contributor, and only if You agree to indemnify,
+              defend, and hold each Contributor harmless for any liability
+              incurred by, or claims asserted against, such Contributor by reason
+              of your accepting any such warranty or additional liability.
+        
+           END OF TERMS AND CONDITIONS
+        
+           APPENDIX: How to apply the Apache License to your work.
+        
+              To apply the Apache License to your work, attach the following
+              boilerplate notice, with the fields enclosed by brackets "[]"
+              replaced with your own identifying information. (Don't include
+              the brackets!)  The text should be enclosed in the appropriate
+              comment syntax for the file format. We also recommend that a
+              file or class name and description of purpose be included on the
+              same "printed page" as the copyright notice for easier
+              identification within third-party archives.
+        
+           Copyright [yyyy] [name of copyright owner]
+        
+           Licensed under the Apache License, Version 2.0 (the "License");
+           you may not use this file except in compliance with the License.
+           You may obtain a copy of the License at
+        
+               http://www.apache.org/licenses/LICENSE-2.0
+        
+           Unless required by applicable law or agreed to in writing, software
+           distributed under the License is distributed on an "AS IS" BASIS,
+           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+           See the License for the specific language governing permissions and
+           limitations under the License.
+Project-URL: Download, https://pypi.python.org/pypi/xsuite
+Project-URL: Bug Tracker, https://github.com/xsuite/xsuite/issues
+Project-URL: Documentation, https://xsuite.readthedocs.io/
+Project-URL: Source Code, https://github.com/xsuite/xsuite
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: xtrack==0.96.1
+Requires-Dist: xfields==0.25.5
+Requires-Dist: xcoll==0.7.2
+Requires-Dist: xobjects==0.5.7
+Requires-Dist: xdeps==0.10.10
+Requires-Dist: xpart==0.23.2
+Dynamic: license-file
+
+# Xsuite
+
+[![Daily test (self-hosted, CUDA)](https://github.com/xsuite/xsuite/actions/workflows/cron_test_gpu_cuda.yaml/badge.svg)](https://github.com/xsuite/xsuite/actions/workflows/cron_test_gpu_cuda.yaml)
+[![Daily test (self-hosted, OpenCL)](https://github.com/xsuite/xsuite/actions/workflows/cron_test_gpu_cl.yaml/badge.svg)](https://github.com/xsuite/xsuite/actions/workflows/cron_test_gpu_cl.yaml)
+[![Daily test (self-hosted, CPU)](https://github.com/xsuite/xsuite/actions/workflows/cron_test_sh_cpu.yaml/badge.svg)](https://github.com/xsuite/xsuite/actions/workflows/cron_test_sh_cpu.yaml)
+
+Suite of python packages for multiparticle simulations for particle accelerators.
+
+Documentation is on: <https://xsuite.readthedocs.io/en/latest/>.

xsuite-0.43.1.dist-info/RECORD

@@ -0,0 +1,23 @@
+xsuite/prebuild_kernels.py,sha256=UKX0LinVkIfAvHdC_tHTA--EftEa45kb5z2AgZYpXsg,9795
+xsuite/__init__.py,sha256=ufjglzKEmjK38emaqQUVKzJY6xHjmu_3MeUe53HsYdg,346
+xsuite/kernel_definitions.py,sha256=GIogWOk_86FtDB6QDPOPcwBXsjXMv-Yndpg5ezMeqQ4,1561
+xsuite/cli.py,sha256=fcjr3-__LTzMZqSft-YooX37_KfW3esf7QJ_6zbhbzM,2119
+xsuite/lib/only_xtrack_with_synrad.json,sha256=zRGS2k1aJ5cVUt6NlV1oDcrANQN_POBRphDEqOt_a8I,2540
+xsuite/lib/default_base_config.c,sha256=exYN-mci4V9TYFmlhnni9u1XtulBNnvvJoqfqw2f5iM,4049474
+xsuite/lib/default_base_config.cpython-311-darwin.so,sha256=kEBEKCrjzr3bdr3tK_CjBnFLDeeqfHw-G84jc65VhWs,6835208
+xsuite/lib/non_tracking_kernels.json,sha256=W-JqUfX-jAcMDokBkIEyw-ui-vLBvQCTkWQwjvBQPoc,336
+xsuite/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xsuite/lib/non_tracking_kernels.cpython-311-darwin.so,sha256=nWHqeRpEv7sbu04KIofSawlKvqY7SaTVCI_YU6h2mZQ,487560
+xsuite/lib/default_base_config.json,sha256=hqFfAoZii2_EkvHxlqnOFOmqtplw49gzjFs19geOa00,2937
+xsuite/lib/only_xtrack_with_synrad.cpython-311-darwin.so,sha256=Wyz_Tman5xGA3eOcnr5ldwGv0krV4y83tL73kUVsXzE,5025456
+xsuite/lib/only_xtrack_with_synrad.c,sha256=95PD7jB3GQU7kaiU61cKdxiAfKOlWvbKUYdVzehnfio,2589198
+xsuite/lib/default_no_config.json,sha256=Gfz5JkI0AlkHX-P0TGfjDlUeK1iRvugx5ig8ISx5tIc,2769
+xsuite/lib/default_no_config.c,sha256=2bIH8X5lDR4K3JjwFcFmPp3mdrK88uDuvCpdbZic_b4,4049341
+xsuite/lib/non_tracking_kernels.c,sha256=ET5YGSlbRd8xtgTLDLFjExZqh7t1YSViB6pPsAwsmvM,255491
+xsuite/lib/default_no_config.cpython-311-darwin.so,sha256=sohMAz87gdLri3Qfm-lfeiNBnQqlJszjTb6IH38Jm9M,6851880
+xsuite-0.43.1.dist-info/RECORD,,
+xsuite-0.43.1.dist-info/WHEEL,sha256=sunMa2yiYbrNLGeMVDqEA0ayyJbHlex7SCn1TZrEq60,136
+xsuite-0.43.1.dist-info/entry_points.txt,sha256=uzV5QpynfaC4Yl1ZrvyFjFBr8eWjL8edU1OFT9yF3ds,52
+xsuite-0.43.1.dist-info/top_level.txt,sha256=52YJ7kYjIdNlsPmijwrxp6nR3Y6Atb15UrtFp9xKUkc,7
+xsuite-0.43.1.dist-info/METADATA,sha256=8XN5rgjhuzknULx0zSfTYj45w2j-xchK-6ztRV5r1S4,14429
+xsuite-0.43.1.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356

xsuite-0.43.1.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp311-cp311-macosx_11_0_arm64
+Generator: delocate 0.13.0
+

xsuite-0.43.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+xsuite-prebuild = xsuite.cli:main