qua-libs-core 0.1.0__tar.gz

qua_libs_core-0.1.0/.gitignore

@@ -0,0 +1,28 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+
+# Build artifacts
+build/
+dist/
+*.whl
+*.tar.gz
+
+# Virtual environments / tooling
+.venv/
+.uv/
+uv.lock.*
+graphify-out/
+
+# Test / type caches
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+
+# Editor / OS
+.idea/
+.vscode/
+.DS_Store
+.cursor/

qua_libs_core-0.1.0/LICENSE

@@ -0,0 +1,37 @@
+
+Quantum Machines End User License Agreement for qua-libs-core Software
+
+PLEASE READ CAREFULLY THIS END USER LICENSE AGREEMENT (“EULA”) BEFORE INSTALLING, ACCESSING, DOWNLOADING OR OTHERWISE USING THE SOLUTION (AS DEFINED BELOW) (“USER”, “YOU”) BY QM (AS DEFINED BELOW). BY INSTALLING, HAVING INSTALLED, CONTROLLING, ACCESSING, OR OTHERWISE USING THE SOLUTION IN ANY MANNER, YOU ARE ACCEPTING AND AGREEING TO BE BOUND BY THIS EULA AND CONDITIONS HEREOF AND REPRESENTING THAT YOU HAVE FULL RIGHT, POWER, AND AUTHORITY TO ENTER INTO AND PERFORM HEREUNDER. YOU MAY NOT INSTALL, DEPLOY, CONTROL, ACCESS, OR USE THE SOLUTION IN ANY MANNER BEFORE YOU HAVE ACCEPTED THIS EULA. FURTHERMORE, YOU HEREBY WAIVE ANY RIGHTS OR REQUIREMENTS UNDER ANY LAWS OR REGULATIONS IN ANY JURISDICTION THAT REQUIRE AN ORIGINAL (NON-ELECTRONIC) SIGNATURE OR DELIVERY OR RETENTION OF NON-ELECTRONIC RECORDS, TO THE EXTENT PERMITTED UNDER APPLICABLE LAW. THIS EULA MADE BETWEEN YOU AND Q.M TECHNOLOGIES LTD. AND ITS AFFILIATES (AS DEFINED BELOW) (“QM”). WITH RESPECT TO THE SOLUTION YOU ASSUME ALL RESPONSIBILITY FOR THE SELECTION OF THE SOLUTION, FOR YOUR RELIANCE ON THE RESULTS OF THE USE OF THE SOLUTION AND RELATED SERVICES, AND FOR ANY USE OF THE SOLUTION NOT IN ACCORDANCE WITH THE EULA HEREOF OR AS CONTEMPLATED HEREUNDER.
+THE PARTIES AGREE THAT UNLESS EXPRESSLY AND SPECIFICALLY AGREED TO IN WRITING BY QM , NO OTHER “CLICK THROGH”, “CLICK WRAP”, TERMS AND CONDITIONS OR OTHER STANDARD TERMS (INCLUDING WITHOUT LIMITATION CUSTOEMRS’ PURCHASE TERMS INCLUDING AS REFRESED IN A  QUOTE, OR ORDER), SHALL HAVE ANY FORCE OR EFFECT WITH RESPECT TO THE SOLUTION, THE USE THEREOF AND QM’S RIGHTS, RESPONSIBILITIES AND LIABILITIES, AND IN THE EVENT OF CONFLICT BETWEEN THIS EULA  AND THE PROVISIONS OF ANY SUCH OTHER INSTRUMNETS, THIS EULA SHALL PREVAIL.
+1. DEFINITIONS
+1.1 "Affiliate" means any entity which controls, is controlled, or is under common control with either of the parties. Any entity shall be deemed to "control" another entity if it owns directly or indirectly more than 50% of the outstanding voting securities or capital of another entity or other comparable equity with respect to an entity other than a company.
+1.2 "Documentation" means the standard written materials regarding the Solution issued and generally provided by QM to its customers.
+1.3 "Third Party Components" shall mean collectively any devices and products, whether hardware or software, which are (i) licensed by third parties and that are integrated into or with the Solution, or (ii) third-party equipment operated and/or used with the Solution, including any quantum computer equipment.
+1.4 "Software" shall mean QM’s proprietary software components, provided with and/or incorporated into the Solution.
+1.5 "Solution" shall mean QM’s proprietary dedicated Software, qua-libs-core, for designing, building, deploying, and running portable hybrid quantum-classical applications on top of QM’s proprietary products and services. The Solution specifically excludes QM proprietary products and any SW and HW in such products (or any other related products, either HW, or SW).
+2. LICENSE RIGHTS; RESTRICTIONS
+2.1 QM grants you, subject to full compliance with the EULA and conditions set forth, a non-exclusive, non-transferable, non-sublicensable, limited license to:
+2.1.1 use, access, and operate the Solution as provided, installed, and configured by QM, solely for your internal or personal use and solely with QM’s proprietary products previously purchased by you from QM and other Third Party Components, which specifically allowed to under the Documentation ("Purpose")  and in any event not for any further commercialization or provision of the Solution or any parts thereof, to any third party or for the development of similar products, services, or solutions; and
+2.1.2 access, use, and make verbatim copies of the Documentation provided to you by QM, solely in connection with your internal or personal use of the Solution as permitted hereunder solely for the Purpose, and provided that all copyright notices are included and maintained therein.
+2.2 Use Restrictions.
+2.2.1 Unless otherwise expressly provided herein, you agree that you will not, nor will you allow any third party whether or not on your behalf to: (a) distribute, license, rent, lease, sublicense, loan, sell or otherwise allow any third party to access the Solution; (b) modify (except as specifically allowed by QM in the Documentation as part of your standard use of the Solution, and subject to Section 5 below), alter, copy, transfer, emulate or create any derivative works of the Solution or of any part thereof (including any of the Software components thereof); (c) reverse engineer, decompile, decode, decrypt, disassemble, or in any way attempt to derive source code or designs from the Solution or any part thereof (including of any of the Software components thereof); (d) remove, alter or obscure any copyright, trademark or other proprietary rights notice, on or in, the Solution, any of its components and/or the Documentation; (e) bundle, integrate, or attempt to integrate with the Solution or with any component thereof, any third-party software, hardware or technology other than as expressly permitted in writing by QM (including through the Documentation); (f) use the Solution  for competing development activities, (g) publish or disclose to any third party any technical features, quality, performance or benchmark test, or comparative analyses relating to the Solution, except for your internal use or as expressly permitted by QM in writing; or (h) disable or otherwise circumvent any license management measures included in the Software and/or the Solution. You shall limit access to the Solution to your authorized employees, Affiliates, and personnel, and will administer account information and passwords accordingly, and will cause all such employees, Affiliates, and personnel to comply with the EULA of this EULA.
+2.2.2 Without derogating from the foregoing, you shall take all commercially reasonable precautions to prevent any unauthorized access and/or unauthorized usage of the Solution. You shall be responsible and liable for any act or omission by anyone acting on your (or your Affiliates’) behalf or authorization, and/or anyone having obtained use of or access to the Solution from you (or your Affiliates), including without limitation your employees, representatives, personnel, or your Affiliates, and such Affiliates’ employees, representatives, and personnel ("Representatives"), as if performed by you.
+2.3 Marks and Use of Name. This EULA does not grant you any rights to QM’s trademarks or service marks.
+2.4 Third Party Software. IN ACCEPTING THIS EULA, YOU CONFIRM AND ACKNOWLEDGE THE UTILIZATION OF THIRD-PARTY COMPONENTS, IN THE SOLUTION, OR THE USE OF THE SOLUTION WITH CERTAIN THIRD PARTY COMPONENTS ALLOWED TO UNDER THE DOCUMENTATION AND ACKNOWLEDGE THAT SUCH THIRD-PARTY COMPONENTS ARE BEING INSTALLED WITH YOUR CONSENT. THIRD PARTY COMPONENTS ARE UTILIZED ON AN "AS-IS" BASIS WITHOUT ANY WARRANTY WHATSOEVER AND QM HEREBY EXPRESSLY DISCLAIMS WITH RESPECT TO ANY SUCH THIRD PARTY COMPONENTS, AND TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW ALL WARRANTIES, WHETHER EXPRESS, IMPLIED, OR STATUTORY, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+2.5 Export Restrictions. You acknowledge that the Solution may be subject to applicable export jurisdiction and any other applicable laws and regulations concerning the transfer of the Solution or any part thereof across international borders. You will comply with all applicable national and international laws that apply to your use of the Solution, including the United States Export Administration Regulations, as well as end-user, end-use, and destination restrictions that may be issued by the United States and other governments from time to time.
+3. SUPPORT; DISCLAIMERS
+3.1 Alpha Version. You acknowledge that the Solution including all components thereof, is an Alpha/Beta version that is still under development, and as such (i) is not at the level of performance or compatibility of final, generally available products; (ii) may not operate correctly, (iii) may be further developed or modified; (iv) may not be made for general release, and (v) should not be used in a commercial production environment.
+3.2 THE SOLUTION, IS PROVIDED BY QM "AS-IS" AND QM MAKES NO REPRESENTATIONS OR WARRANTIES, ORAL OR WRITTEN, EXPRESS OR IMPLIED, REGARDING THE SOLUTION, ARISING FROM THE COURSE OF DEALING, COURSE OF PERFORMANCE, USAGE OF TRADE, QUALITY OF INFORMATION, QUIET ENJOYMENT OR OTHERWISE, INCLUDING IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE, OR NON-INTERFERENCE. YOU ACKNOWLEDGE THAT YOU HAVE NOT ENTERED INTO THIS EULA IN RELIANCE UPON ANY WARRANTY OR REPRESENTATION NOT EXPRESSLY CONTAINED IN THIS EULA.
+4. FEES.
+4.1 If you are a paying customer, you shall pay QM the fees described in the Quote added with any applicable VAT or sales taxes (as applicable). Payment shall be due as described in the Quote and made in United States Dollars by wire transfer to QM’s designated bank account. All fees shall be non-cancellable, and the sums paid non-refundable. If you are a paying customer, you are responsible for payment of any taxes resulting from the possession and use of the Solution, except for payment of any taxes based on or related to QM’s income.
+5. PROPRIETARY RIGHTS.
+5.1 You agree and acknowledge that QM is and shall remain the sole and exclusive owner of any and all Intellectual Property rights in or to the Solution, including any Feedback provided by you or generated by QM, and any part thereof, including any modifications, enhancements, improvements, updates and upgrades, and derivative works thereof including if originates, learned or derived from the use of the Solution or any part thereof by you or by any Representatives or from the information you or any Representatives provide to QM in connection with the Solution.
+5.2 "Feedback" shall mean any feedback, including any code, documentation, or any original work of authorship, including any modifications or additions to an existing work, made by you as part of your use of the Solution.
+5.3 "Intellectual Property" shall mean all inventions, ideas, concepts, analyses, (whether patented, or patentable, or not), methods, methodologies, designs, processes, patents, patent applications, rights associated with works of authorship, including copyrights, copyrights applications, copyrights restrictions, moral rights, any information, ancillary materials, devices, results, know-how, and all rights relating to the protection of trade secrets and confidential information; design rights and industrial property rights; mask works, software, all code including source code, object code, firmware; and any other proprietary rights relating to intangible property. Other than as explicitly stated hereunder, no right or license, express or implied, in or to the Intellectual Property of QM, is granted to you or any Representative under this EULA.
+6. LIMITATION OF LIABILITY. IN NO EVENT WILL QM, ITS AFFILIATES, OR THEIR RESPECTIVE DIRECTORS, OFFICERS, SHAREHOLDER, AND EMPLOYEES’ ("QM’S PARTIES") AGGREGATE LIABILITY TO YOU, EXCEED THE AMOUNTS PAID BY YOU TO QM IN RESPECT OF THE SOLUTION. IN NO EVENT WILL QM OR QM PARTIES, HAVE ANY LIABILITY TO YOU FOR ANY INDIRECT, CONSEQUENTIAL, SPECIAL, EXEMPLARY, OR INCIDENTAL DAMAGES, INCLUDING WITHOUT LIMITATION DAMAGES FOR LOST PROFITS OR REVENUES, BUSINESS INTERRUPTION, LOSS OF GOODWILL, COMPUTER FAILURE OR MALFUNCTION, LOSS OF DATA OR BUSINESS INFORMATION ARISING FROM THE INSTALLATION, OPERATION, USE OF OR INABILITY TO USE THE SOLUTION, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES OR IF SUCH POSSIBILITY WAS REASONABLY FORESEEABLE. NO ACTION, REGARDLESS OF FORM, ARISING OUT OF OR RELATING TO THIS EULA MAY BE BROUGHT AGAINST QM MORE THAN TWELVE (12) MONTHS AFTER THE TERMINATION OR EXPIRATION OF THIS EULA.
+7. TERM AND TERMINATION. You will have the rights set forth herein for the duration set forth by QM at its discretion (unless otherwise agreed between QM and you under an applicable written agreement) and only for so long as you comply with this EULA. This EULA and all rights and licenses granted hereunder shall automatically terminate if you breach the EULA hereof and such breach is not cured within fourteen (14) days of written notice of such breach. Sections 1, 2.2, 2.3, 2.4, 2.5, 5, 6, 7, and 8, will survive any termination or expiration of This EULA.
+8. GENERAL
+8.1 Severability. In the event any provision or part of This EULA is held to be invalid or unenforceable by any court of competent jurisdiction, it shall be amended to the extent required to render it valid, legal, and enforceable, or deleted if no such amendment is feasible, and such amendment or deletion shall not affect the enforceability of the other provisions hereof.
+8.2 Waiver. No waiver of any breach of This EULA will be a waiver of any other breach, and no waiver will be effective unless made in writing and signed by an authorized representative of the waiving party. The failure of either party to enforce any rights granted hereunder or to take action against the other party in the event of any breach hereunder shall not be deemed a waiver by that party as to subsequent enforcement of rights or subsequent actions in the event of future breaches.
+8.3 Entire Agreement; Updates. This EULA is in addition to QM’s Terms of Sale and End User License Agreement that related to QM’s proprietary products and services, including without limitation QM’s proprietary Quantum Orchestration™ Platform and applies only with respect to the subject matter hereof between you and QM – i.e., the use of the QM [QUAlibs] Software, any other EULA not specifically changed and/or modified by this EULA, shall be as set forth in QM’s Terms of Sale and End User License Agreement.
+8.4 Governing Law. The validity, interpretation, and performance of this EULA shall be controlled by and construed under the laws of the State of Israel as if performed wholly within Israel and without giving effect to the principles of conflicts of laws. The Parties hereby consent to the exclusive jurisdiction of the courts of Tel Aviv.

qua_libs_core-0.1.0/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: qua-libs-core
+Version: 0.1.0
+Summary: Generic QUA tutorials and shared libraries for modality-specific qua-libs repos
+Project-URL: Homepage, https://github.com/qua-platform/qua-libs-core
+Project-URL: Documentation, https://github.com/qua-platform/qua-libs-core/tree/main/docs
+Project-URL: Repository, https://github.com/qua-platform/qua-libs-core
+Project-URL: Issues, https://github.com/qua-platform/qua-libs-core/issues
+Author-email: Quantum Machines <info@quantum-machines.co>
+License: 
+        Quantum Machines End User License Agreement for qua-libs-core Software
+        
+        PLEASE READ CAREFULLY THIS END USER LICENSE AGREEMENT (“EULA”) BEFORE INSTALLING, ACCESSING, DOWNLOADING OR OTHERWISE USING THE SOLUTION (AS DEFINED BELOW) (“USER”, “YOU”) BY QM (AS DEFINED BELOW). BY INSTALLING, HAVING INSTALLED, CONTROLLING, ACCESSING, OR OTHERWISE USING THE SOLUTION IN ANY MANNER, YOU ARE ACCEPTING AND AGREEING TO BE BOUND BY THIS EULA AND CONDITIONS HEREOF AND REPRESENTING THAT YOU HAVE FULL RIGHT, POWER, AND AUTHORITY TO ENTER INTO AND PERFORM HEREUNDER. YOU MAY NOT INSTALL, DEPLOY, CONTROL, ACCESS, OR USE THE SOLUTION IN ANY MANNER BEFORE YOU HAVE ACCEPTED THIS EULA. FURTHERMORE, YOU HEREBY WAIVE ANY RIGHTS OR REQUIREMENTS UNDER ANY LAWS OR REGULATIONS IN ANY JURISDICTION THAT REQUIRE AN ORIGINAL (NON-ELECTRONIC) SIGNATURE OR DELIVERY OR RETENTION OF NON-ELECTRONIC RECORDS, TO THE EXTENT PERMITTED UNDER APPLICABLE LAW. THIS EULA MADE BETWEEN YOU AND Q.M TECHNOLOGIES LTD. AND ITS AFFILIATES (AS DEFINED BELOW) (“QM”). WITH RESPECT TO THE SOLUTION YOU ASSUME ALL RESPONSIBILITY FOR THE SELECTION OF THE SOLUTION, FOR YOUR RELIANCE ON THE RESULTS OF THE USE OF THE SOLUTION AND RELATED SERVICES, AND FOR ANY USE OF THE SOLUTION NOT IN ACCORDANCE WITH THE EULA HEREOF OR AS CONTEMPLATED HEREUNDER.
+        THE PARTIES AGREE THAT UNLESS EXPRESSLY AND SPECIFICALLY AGREED TO IN WRITING BY QM , NO OTHER “CLICK THROGH”, “CLICK WRAP”, TERMS AND CONDITIONS OR OTHER STANDARD TERMS (INCLUDING WITHOUT LIMITATION CUSTOEMRS’ PURCHASE TERMS INCLUDING AS REFRESED IN A  QUOTE, OR ORDER), SHALL HAVE ANY FORCE OR EFFECT WITH RESPECT TO THE SOLUTION, THE USE THEREOF AND QM’S RIGHTS, RESPONSIBILITIES AND LIABILITIES, AND IN THE EVENT OF CONFLICT BETWEEN THIS EULA  AND THE PROVISIONS OF ANY SUCH OTHER INSTRUMNETS, THIS EULA SHALL PREVAIL.
+        1. DEFINITIONS
+        1.1 "Affiliate" means any entity which controls, is controlled, or is under common control with either of the parties. Any entity shall be deemed to "control" another entity if it owns directly or indirectly more than 50% of the outstanding voting securities or capital of another entity or other comparable equity with respect to an entity other than a company.
+        1.2 "Documentation" means the standard written materials regarding the Solution issued and generally provided by QM to its customers.
+        1.3 "Third Party Components" shall mean collectively any devices and products, whether hardware or software, which are (i) licensed by third parties and that are integrated into or with the Solution, or (ii) third-party equipment operated and/or used with the Solution, including any quantum computer equipment.
+        1.4 "Software" shall mean QM’s proprietary software components, provided with and/or incorporated into the Solution.
+        1.5 "Solution" shall mean QM’s proprietary dedicated Software, qua-libs-core, for designing, building, deploying, and running portable hybrid quantum-classical applications on top of QM’s proprietary products and services. The Solution specifically excludes QM proprietary products and any SW and HW in such products (or any other related products, either HW, or SW).
+        2. LICENSE RIGHTS; RESTRICTIONS
+        2.1 QM grants you, subject to full compliance with the EULA and conditions set forth, a non-exclusive, non-transferable, non-sublicensable, limited license to:
+        2.1.1 use, access, and operate the Solution as provided, installed, and configured by QM, solely for your internal or personal use and solely with QM’s proprietary products previously purchased by you from QM and other Third Party Components, which specifically allowed to under the Documentation ("Purpose")  and in any event not for any further commercialization or provision of the Solution or any parts thereof, to any third party or for the development of similar products, services, or solutions; and
+        2.1.2 access, use, and make verbatim copies of the Documentation provided to you by QM, solely in connection with your internal or personal use of the Solution as permitted hereunder solely for the Purpose, and provided that all copyright notices are included and maintained therein.
+        2.2 Use Restrictions.
+        2.2.1 Unless otherwise expressly provided herein, you agree that you will not, nor will you allow any third party whether or not on your behalf to: (a) distribute, license, rent, lease, sublicense, loan, sell or otherwise allow any third party to access the Solution; (b) modify (except as specifically allowed by QM in the Documentation as part of your standard use of the Solution, and subject to Section 5 below), alter, copy, transfer, emulate or create any derivative works of the Solution or of any part thereof (including any of the Software components thereof); (c) reverse engineer, decompile, decode, decrypt, disassemble, or in any way attempt to derive source code or designs from the Solution or any part thereof (including of any of the Software components thereof); (d) remove, alter or obscure any copyright, trademark or other proprietary rights notice, on or in, the Solution, any of its components and/or the Documentation; (e) bundle, integrate, or attempt to integrate with the Solution or with any component thereof, any third-party software, hardware or technology other than as expressly permitted in writing by QM (including through the Documentation); (f) use the Solution  for competing development activities, (g) publish or disclose to any third party any technical features, quality, performance or benchmark test, or comparative analyses relating to the Solution, except for your internal use or as expressly permitted by QM in writing; or (h) disable or otherwise circumvent any license management measures included in the Software and/or the Solution. You shall limit access to the Solution to your authorized employees, Affiliates, and personnel, and will administer account information and passwords accordingly, and will cause all such employees, Affiliates, and personnel to comply with the EULA of this EULA.
+        2.2.2 Without derogating from the foregoing, you shall take all commercially reasonable precautions to prevent any unauthorized access and/or unauthorized usage of the Solution. You shall be responsible and liable for any act or omission by anyone acting on your (or your Affiliates’) behalf or authorization, and/or anyone having obtained use of or access to the Solution from you (or your Affiliates), including without limitation your employees, representatives, personnel, or your Affiliates, and such Affiliates’ employees, representatives, and personnel ("Representatives"), as if performed by you.
+        2.3 Marks and Use of Name. This EULA does not grant you any rights to QM’s trademarks or service marks.
+        2.4 Third Party Software. IN ACCEPTING THIS EULA, YOU CONFIRM AND ACKNOWLEDGE THE UTILIZATION OF THIRD-PARTY COMPONENTS, IN THE SOLUTION, OR THE USE OF THE SOLUTION WITH CERTAIN THIRD PARTY COMPONENTS ALLOWED TO UNDER THE DOCUMENTATION AND ACKNOWLEDGE THAT SUCH THIRD-PARTY COMPONENTS ARE BEING INSTALLED WITH YOUR CONSENT. THIRD PARTY COMPONENTS ARE UTILIZED ON AN "AS-IS" BASIS WITHOUT ANY WARRANTY WHATSOEVER AND QM HEREBY EXPRESSLY DISCLAIMS WITH RESPECT TO ANY SUCH THIRD PARTY COMPONENTS, AND TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW ALL WARRANTIES, WHETHER EXPRESS, IMPLIED, OR STATUTORY, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+        2.5 Export Restrictions. You acknowledge that the Solution may be subject to applicable export jurisdiction and any other applicable laws and regulations concerning the transfer of the Solution or any part thereof across international borders. You will comply with all applicable national and international laws that apply to your use of the Solution, including the United States Export Administration Regulations, as well as end-user, end-use, and destination restrictions that may be issued by the United States and other governments from time to time.
+        3. SUPPORT; DISCLAIMERS
+        3.1 Alpha Version. You acknowledge that the Solution including all components thereof, is an Alpha/Beta version that is still under development, and as such (i) is not at the level of performance or compatibility of final, generally available products; (ii) may not operate correctly, (iii) may be further developed or modified; (iv) may not be made for general release, and (v) should not be used in a commercial production environment.
+        3.2 THE SOLUTION, IS PROVIDED BY QM "AS-IS" AND QM MAKES NO REPRESENTATIONS OR WARRANTIES, ORAL OR WRITTEN, EXPRESS OR IMPLIED, REGARDING THE SOLUTION, ARISING FROM THE COURSE OF DEALING, COURSE OF PERFORMANCE, USAGE OF TRADE, QUALITY OF INFORMATION, QUIET ENJOYMENT OR OTHERWISE, INCLUDING IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE, OR NON-INTERFERENCE. YOU ACKNOWLEDGE THAT YOU HAVE NOT ENTERED INTO THIS EULA IN RELIANCE UPON ANY WARRANTY OR REPRESENTATION NOT EXPRESSLY CONTAINED IN THIS EULA.
+        4. FEES.
+        4.1 If you are a paying customer, you shall pay QM the fees described in the Quote added with any applicable VAT or sales taxes (as applicable). Payment shall be due as described in the Quote and made in United States Dollars by wire transfer to QM’s designated bank account. All fees shall be non-cancellable, and the sums paid non-refundable. If you are a paying customer, you are responsible for payment of any taxes resulting from the possession and use of the Solution, except for payment of any taxes based on or related to QM’s income.
+        5. PROPRIETARY RIGHTS.
+        5.1 You agree and acknowledge that QM is and shall remain the sole and exclusive owner of any and all Intellectual Property rights in or to the Solution, including any Feedback provided by you or generated by QM, and any part thereof, including any modifications, enhancements, improvements, updates and upgrades, and derivative works thereof including if originates, learned or derived from the use of the Solution or any part thereof by you or by any Representatives or from the information you or any Representatives provide to QM in connection with the Solution.
+        5.2 "Feedback" shall mean any feedback, including any code, documentation, or any original work of authorship, including any modifications or additions to an existing work, made by you as part of your use of the Solution.
+        5.3 "Intellectual Property" shall mean all inventions, ideas, concepts, analyses, (whether patented, or patentable, or not), methods, methodologies, designs, processes, patents, patent applications, rights associated with works of authorship, including copyrights, copyrights applications, copyrights restrictions, moral rights, any information, ancillary materials, devices, results, know-how, and all rights relating to the protection of trade secrets and confidential information; design rights and industrial property rights; mask works, software, all code including source code, object code, firmware; and any other proprietary rights relating to intangible property. Other than as explicitly stated hereunder, no right or license, express or implied, in or to the Intellectual Property of QM, is granted to you or any Representative under this EULA.
+        6. LIMITATION OF LIABILITY. IN NO EVENT WILL QM, ITS AFFILIATES, OR THEIR RESPECTIVE DIRECTORS, OFFICERS, SHAREHOLDER, AND EMPLOYEES’ ("QM’S PARTIES") AGGREGATE LIABILITY TO YOU, EXCEED THE AMOUNTS PAID BY YOU TO QM IN RESPECT OF THE SOLUTION. IN NO EVENT WILL QM OR QM PARTIES, HAVE ANY LIABILITY TO YOU FOR ANY INDIRECT, CONSEQUENTIAL, SPECIAL, EXEMPLARY, OR INCIDENTAL DAMAGES, INCLUDING WITHOUT LIMITATION DAMAGES FOR LOST PROFITS OR REVENUES, BUSINESS INTERRUPTION, LOSS OF GOODWILL, COMPUTER FAILURE OR MALFUNCTION, LOSS OF DATA OR BUSINESS INFORMATION ARISING FROM THE INSTALLATION, OPERATION, USE OF OR INABILITY TO USE THE SOLUTION, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES OR IF SUCH POSSIBILITY WAS REASONABLY FORESEEABLE. NO ACTION, REGARDLESS OF FORM, ARISING OUT OF OR RELATING TO THIS EULA MAY BE BROUGHT AGAINST QM MORE THAN TWELVE (12) MONTHS AFTER THE TERMINATION OR EXPIRATION OF THIS EULA.
+        7. TERM AND TERMINATION. You will have the rights set forth herein for the duration set forth by QM at its discretion (unless otherwise agreed between QM and you under an applicable written agreement) and only for so long as you comply with this EULA. This EULA and all rights and licenses granted hereunder shall automatically terminate if you breach the EULA hereof and such breach is not cured within fourteen (14) days of written notice of such breach. Sections 1, 2.2, 2.3, 2.4, 2.5, 5, 6, 7, and 8, will survive any termination or expiration of This EULA.
+        8. GENERAL
+        8.1 Severability. In the event any provision or part of This EULA is held to be invalid or unenforceable by any court of competent jurisdiction, it shall be amended to the extent required to render it valid, legal, and enforceable, or deleted if no such amendment is feasible, and such amendment or deletion shall not affect the enforceability of the other provisions hereof.
+        8.2 Waiver. No waiver of any breach of This EULA will be a waiver of any other breach, and no waiver will be effective unless made in writing and signed by an authorized representative of the waiving party. The failure of either party to enforce any rights granted hereunder or to take action against the other party in the event of any breach hereunder shall not be deemed a waiver by that party as to subsequent enforcement of rights or subsequent actions in the event of future breaches.
+        8.3 Entire Agreement; Updates. This EULA is in addition to QM’s Terms of Sale and End User License Agreement that related to QM’s proprietary products and services, including without limitation QM’s proprietary Quantum Orchestration™ Platform and applies only with respect to the subject matter hereof between you and QM – i.e., the use of the QM [QUAlibs] Software, any other EULA not specifically changed and/or modified by this EULA, shall be as set forth in QM’s Terms of Sale and End User License Agreement.
+        8.4 Governing Law. The validity, interpretation, and performance of this EULA shall be controlled by and construed under the laws of the State of Israel as if performed wholly within Israel and without giving effect to the principles of conflicts of laws. The Parties hereby consent to the exclusive jurisdiction of the courts of Tel Aviv.
+License-File: LICENSE
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: <3.13,>=3.10
+Requires-Dist: opentelemetry-api>=1.20.0
+Requires-Dist: opentelemetry-exporter-otlp>=1.20.0
+Requires-Dist: opentelemetry-sdk>=1.20.0
+Requires-Dist: tomli>=2.0.1; python_version < '3.11'
+Requires-Dist: uptrace>=1.20.0
+Provides-Extra: tutorials
+Requires-Dist: matplotlib>=3.2.2; extra == 'tutorials'
+Requires-Dist: numpy>=1.18.5; extra == 'tutorials'
+Requires-Dist: plotly>=5.24.1; extra == 'tutorials'
+Requires-Dist: qm-qua>=1.2.0; extra == 'tutorials'
+Requires-Dist: qm-saas; extra == 'tutorials'
+Requires-Dist: qualang-tools>=0.19.0; extra == 'tutorials'
+Requires-Dist: scipy>=1.7.0; extra == 'tutorials'
+Description-Content-Type: text/markdown
+
+![Banner](GITHUB-BANNER.jpg)
+
+[![discord](https://img.shields.io/discord/806244683403100171?label=QUA&logo=Discord&style=plastic)](https://discord.gg/7FfhhpswbP)
+[![License](https://img.shields.io/badge/license-Proprietary-blue.svg)](./LICENSE)
+
+<!-- Netlify (docs deploy) and Zenodo (citable DOI) badges are placeholders;
+     fill in the IDs once this repo has its own Netlify site and Zenodo record. -->
+[![Netlify Status](https://api.netlify.com/api/v1/badges/REPLACE_WITH_NETLIFY_SITE_ID/deploy-status)](https://app.netlify.com/sites/qua-libs-core/deploys)
+[![DOI](https://zenodo.org/badge/REPLACE_WITH_ZENODO_ID.svg)](https://zenodo.org/badge/latestdoi/REPLACE_WITH_ZENODO_ID)
+
+# QUA Libraries
+
+Hey! Glad to see you there!
+
+Welcome to the QUA libraries. Your one-stop-shop for a batteries-included QUA experience.
+
+This repo is where we share the general-purpose tutorials and tools that aren't tied to any particular qubit platform, and it points you to the platform-specific libraries below.
+
+It includes:
+* The ["Tutorials"](./Tutorials) folder contains various tutorials and guides for working with the OPX — timing, streams, demodulation, simulation, macros, Octave, and more.
+
+## Installing
+
+Install `qua-libs-core` from PyPI:
+
+```bash
+pip install qua-libs-core
+```
+That gives you the importable `qua_libs_core` package, including `qua_libs_core.telemetry` used across the qua-libs repositories, without the QUA SDK.
+
+Or clone this repository for tutorials and the installer in addition to telemetry:
+
+```bash
+git clone https://github.com/qua-platform/qua-libs-core
+cd qua-libs-core
+uv sync --extra tutorials
+```
+
+Documentation for telemetry is seen in
+[`qua_libs_core.telemetry`](docs/telemetry/README.md).
+
+### QUA Libraries installer
+
+For a batteries-included modality setup (clone, virtualenv, QUAlibrate, optional
+local Uptrace), use [`tools/installer/`](tools/installer/README.md).
+See [telemetry installer docs](docs/telemetry/INSTALLER.md) for Docker and config
+file behavior.
+
+## QUA libraries by platform
+
+Examples, use cases, and calibration protocols for specific qubit platforms live in their own repositories:
+
+| Repository | Platform |
+|---|---|
+| [qua-libs-superconducting](https://github.com/qua-platform/qua-libs-superconducting) | Superconducting transmons |
+| [qua-libs-nv](https://github.com/qua-platform/qua-libs-nv) | NV / optically addressable spin qubits |
+| [qua-libs-quantum-dots](https://github.com/qua-platform/qua-libs-quantum-dots) | Quantum dots |
+| [qua-libs-neutral-atoms](https://github.com/qua-platform/qua-libs-neutral-atoms) | Neutral atoms (Rydberg, cavity locking) |
+| [qua-libs-trapped-ion](https://github.com/qua-platform/qua-libs-trapped-ion) | Trapped ions |
+
+## Support and Contribution
+This is a beta version of the repo, and thus, if you see quirks and inaccuracies please tell us!
+Love to see some example that's not yet included? tell us! Have a request for a general purpose procedure? tell us!
+Already have something cool that others could use? Open a pull request! You can follow [this guide](./CONTRIBUTING.md) and feel free to contact us if you need any help.
+Issue reporting and requests should be done via the [GitHub issues system](https://github.com/qua-platform/qua-libs-core/issues), that should give a transparent experience where all users can see what's coming and which issues are already known.
+We hope this repo becomes a useful resource, giving real contribution to the community, and we'd love to see your ideas and contributions too!

qua_libs_core-0.1.0/README.md

@@ -0,0 +1,66 @@
+![Banner](GITHUB-BANNER.jpg)
+
+[![discord](https://img.shields.io/discord/806244683403100171?label=QUA&logo=Discord&style=plastic)](https://discord.gg/7FfhhpswbP)
+[![License](https://img.shields.io/badge/license-Proprietary-blue.svg)](./LICENSE)
+
+<!-- Netlify (docs deploy) and Zenodo (citable DOI) badges are placeholders;
+     fill in the IDs once this repo has its own Netlify site and Zenodo record. -->
+[![Netlify Status](https://api.netlify.com/api/v1/badges/REPLACE_WITH_NETLIFY_SITE_ID/deploy-status)](https://app.netlify.com/sites/qua-libs-core/deploys)
+[![DOI](https://zenodo.org/badge/REPLACE_WITH_ZENODO_ID.svg)](https://zenodo.org/badge/latestdoi/REPLACE_WITH_ZENODO_ID)
+
+# QUA Libraries
+
+Hey! Glad to see you there!
+
+Welcome to the QUA libraries. Your one-stop-shop for a batteries-included QUA experience.
+
+This repo is where we share the general-purpose tutorials and tools that aren't tied to any particular qubit platform, and it points you to the platform-specific libraries below.
+
+It includes:
+* The ["Tutorials"](./Tutorials) folder contains various tutorials and guides for working with the OPX — timing, streams, demodulation, simulation, macros, Octave, and more.
+
+## Installing
+
+Install `qua-libs-core` from PyPI:
+
+```bash
+pip install qua-libs-core
+```
+That gives you the importable `qua_libs_core` package, including `qua_libs_core.telemetry` used across the qua-libs repositories, without the QUA SDK.
+
+Or clone this repository for tutorials and the installer in addition to telemetry:
+
+```bash
+git clone https://github.com/qua-platform/qua-libs-core
+cd qua-libs-core
+uv sync --extra tutorials
+```
+
+Documentation for telemetry is seen in
+[`qua_libs_core.telemetry`](docs/telemetry/README.md).
+
+### QUA Libraries installer
+
+For a batteries-included modality setup (clone, virtualenv, QUAlibrate, optional
+local Uptrace), use [`tools/installer/`](tools/installer/README.md).
+See [telemetry installer docs](docs/telemetry/INSTALLER.md) for Docker and config
+file behavior.
+
+## QUA libraries by platform
+
+Examples, use cases, and calibration protocols for specific qubit platforms live in their own repositories:
+
+| Repository | Platform |
+|---|---|
+| [qua-libs-superconducting](https://github.com/qua-platform/qua-libs-superconducting) | Superconducting transmons |
+| [qua-libs-nv](https://github.com/qua-platform/qua-libs-nv) | NV / optically addressable spin qubits |
+| [qua-libs-quantum-dots](https://github.com/qua-platform/qua-libs-quantum-dots) | Quantum dots |
+| [qua-libs-neutral-atoms](https://github.com/qua-platform/qua-libs-neutral-atoms) | Neutral atoms (Rydberg, cavity locking) |
+| [qua-libs-trapped-ion](https://github.com/qua-platform/qua-libs-trapped-ion) | Trapped ions |
+
+## Support and Contribution
+This is a beta version of the repo, and thus, if you see quirks and inaccuracies please tell us!
+Love to see some example that's not yet included? tell us! Have a request for a general purpose procedure? tell us!
+Already have something cool that others could use? Open a pull request! You can follow [this guide](./CONTRIBUTING.md) and feel free to contact us if you need any help.
+Issue reporting and requests should be done via the [GitHub issues system](https://github.com/qua-platform/qua-libs-core/issues), that should give a transparent experience where all users can see what's coming and which issues are already known.
+We hope this repo becomes a useful resource, giving real contribution to the community, and we'd love to see your ideas and contributions too!

qua_libs_core-0.1.0/pyproject.toml

@@ -0,0 +1,71 @@
+# qua-libs-core: generic QUA tutorials, shared tooling, and the `qua_libs_core`
+# package (including `qua_libs_core.telemetry` for modality repositories).
+
+[project]
+name = "qua-libs-core"
+dynamic = ["version"]
+description = "Generic QUA tutorials and shared libraries for modality-specific qua-libs repos"
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [{ name = "Quantum Machines", email = "info@quantum-machines.co" }]
+requires-python = ">=3.10,<3.13"
+classifiers = [
+    "License :: Other/Proprietary License",
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "uptrace>=1.20.0",
+    "opentelemetry-api>=1.20.0",
+    "opentelemetry-sdk>=1.20.0",
+    "opentelemetry-exporter-otlp>=1.20.0",
+    "tomli>=2.0.1; python_version < '3.11'",
+]
+
+[project.optional-dependencies]
+tutorials = [
+    "qm-qua>=1.2.0",
+    "qualang-tools>=0.19.0",
+    "qm-saas",
+    "numpy>=1.18.5",
+    "scipy>=1.7.0",
+    "matplotlib>=3.2.2",
+    "plotly>=5.24.1",
+]
+
+[project.urls]
+Homepage = "https://github.com/qua-platform/qua-libs-core"
+Documentation = "https://github.com/qua-platform/qua-libs-core/tree/main/docs"
+Repository = "https://github.com/qua-platform/qua-libs-core"
+Issues = "https://github.com/qua-platform/qua-libs-core/issues"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+path = "qua_libs_core/__init__.py"
+
+[tool.hatch.build.targets.sdist]
+only-include = ["qua_libs_core"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["qua_libs_core"]
+
+[dependency-groups]
+dev = ["black>=24.3,<25", "ruff>=0.6,<1", "pytest>=8.0", "pre-commit>=4.0"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.black]
+line-length = 120
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+# `from qm.qua import *` is the idiomatic QUA style (F403/F405); single-letter
+# names like I/Q/l are standard in physics code (E741). Ignoring these keeps
+# ruff's output useful. Run locally with: uv run ruff check .
+ignore = ["F403", "F405", "E741"]

qua_libs_core-0.1.0/qua_libs_core/__init__.py

@@ -0,0 +1,10 @@
+"""qua-libs-core importable package.
+
+Currently ships the shared ``telemetry`` subpackage — OpenTelemetry + Uptrace
+instrumentation used by the per-modality qua-libs repos. Telemetry is off by
+default; see ``docs/telemetry/`` for usage. Import as::
+
+    from qua_libs_core.telemetry import instrument_calibration_node
+"""
+
+__version__ = "0.1.0"

qua_libs_core-0.1.0/qua_libs_core/telemetry/__init__.py

@@ -0,0 +1,50 @@
+"""
+Telemetry module for OpenTelemetry + Uptrace integration.
+
+Example usage:
+    from qua_libs_core.telemetry import init_telemetry, trace_function, trace_span
+
+    # Initialize once at application startup (reads .qua-libs/telemetry.toml)
+    init_telemetry()
+
+    # Option 1: Use decorator for automatic instrumentation
+    @trace_function("my_function")
+    def my_function():
+        ...
+
+    # Option 2: Use context manager for manual spans
+    with trace_span("my_operation"):
+        ...
+"""
+
+from .config import TelemetryConfig, init_telemetry, get_tracer
+from .decorators import trace_function, trace_async_function
+from .context_managers import trace_span, trace_span_with_attributes
+from .utils import (
+    set_span_attribute,
+    add_span_event,
+    record_exception,
+    set_span_status,
+    get_current_span,
+)
+from .calibration_node import instrument_calibration_node
+from .project_config import PROJECT_CONFIG, load_project_config
+
+
+__all__ = [
+    "TelemetryConfig",
+    "init_telemetry",
+    "get_tracer",
+    "trace_function",
+    "trace_async_function",
+    "trace_span",
+    "trace_span_with_attributes",
+    "set_span_attribute",
+    "add_span_event",
+    "record_exception",
+    "set_span_status",
+    "get_current_span",
+    "instrument_calibration_node",
+    "PROJECT_CONFIG",
+    "load_project_config",
+]

qua_libs_core-0.1.0/qua_libs_core/telemetry/calibration_node.py

@@ -0,0 +1,157 @@
+"""
+Centralized telemetry instrumentation for calibration nodes.
+
+Usage:
+    from qua_libs_core.telemetry import instrument_calibration_node
+
+    node = QualibrationNode[Parameters, Quam](name="my_node", ...)
+    instrument_calibration_node(node)  # call once, before any @node.run_action defs
+
+    @node.run_action(skip_if=...)
+    def create_qua_program(node):
+        ...  # unchanged — telemetry is added automatically
+"""
+
+import functools
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+import uptrace
+from opentelemetry.trace import Status, StatusCode
+
+from .config import init_telemetry, TelemetryConfig, get_tracer
+from .project_config import load_project_config
+
+
+STANDARD_FUNCTIONS = [
+    "custom_param",
+    "create_qua_program",
+    "simulate_qua_program",
+    "execute_qua_program",
+    "load_data",
+    "analyse_data",
+    "plot_data",
+    "update_state",
+    "save_results",
+]
+
+# Parameter attributes to capture from node.parameters when available
+_OPTIONAL_ATTRS = ["operation", "num_shots", "timeout", "load_data_id"]
+
+
+def instrument_calibration_node(
+    node,
+    config: Optional[TelemetryConfig] = None,
+    extra_attributes: Optional[List[str]] = None,
+    resource_attributes: Optional[Dict[str, Any]] = None,
+) -> None:
+    """
+    Instrument a calibration node's standard run_action functions with telemetry spans.
+
+    Patches node.run_action so every function listed in STANDARD_FUNCTIONS that is
+    subsequently decorated with @node.run_action gets automatically wrapped in a
+    trace span. Functions not in STANDARD_FUNCTIONS are passed through unchanged.
+
+    Call this ONCE, immediately after node creation and BEFORE any @node.run_action
+    function definitions.
+
+    Args:
+        node: A QualibrationNode instance.
+        config: Optional TelemetryConfig. If None, reloads ``.qua-libs/telemetry.toml``
+            from the current working directory (and parents).
+        extra_attributes: Optional list of additional parameter names to capture
+            from node.parameters as span attributes (extends the default set of
+            operation, num_shots, timeout, load_data_id).
+        resource_attributes: Optional dict of resource-level attributes passed to
+            Uptrace (e.g., experiment.category, experiment.run_at). Only takes
+            effect on the first init_telemetry call per process.
+
+    Advanced usage — accessing the span inside a function:
+        from qua_libs_core.telemetry import get_current_span, set_span_attribute
+
+        @node.run_action(skip_if=node.parameters.simulate)
+        def analyse_data(node):
+            span = get_current_span()
+            set_span_attribute(span, "fit.q1", "successful")
+
+        The span is also available via node.namespace["_telemetry_span"].
+    """
+    if config is None:
+        config = load_project_config()
+
+    # Auto-populate resource attributes from node name and current time
+    auto_attrs = {
+        "experiment.node": node.name,
+        "experiment.run_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+    }
+    # User-provided resource_attributes override auto ones
+    merged_attrs = {
+        **auto_attrs,
+        **(config.resource_attributes or {}),
+        **(resource_attributes or {}),
+    }
+
+    if merged_attrs != (config.resource_attributes or {}):
+        config = TelemetryConfig(
+            dsn=config.dsn,
+            service_name=config.service_name,
+            service_version=config.service_version,
+            deployment_environment=config.deployment_environment,
+            enabled=config.enabled,
+            resource_attributes=merged_attrs,
+        )
+
+    init_telemetry(config)
+
+    node_name = node.name
+    original_run_action = node.run_action
+
+    param_attributes = list(_OPTIONAL_ATTRS)
+    if extra_attributes:
+        param_attributes.extend(extra_attributes)
+
+    def traced_run_action(*args, **kwargs):
+        decorator = original_run_action(*args, **kwargs)
+
+        def wrapping_decorator(fn):
+            if fn.__name__ not in STANDARD_FUNCTIONS:
+                return decorator(fn)
+
+            @functools.wraps(fn)
+            def traced_fn(*fn_args, **fn_kwargs):
+                tracer = get_tracer()
+                attrs = {"node": node_name}
+
+                # Collect optional span attributes from node.parameters
+                if fn_args:
+                    params = getattr(fn_args[0], "parameters", None)
+                    if params is not None:
+                        for attr in param_attributes:
+                            val = getattr(params, attr, None)
+                            if val is not None:
+                                attrs[attr] = str(val)
+
+                with tracer.start_as_current_span(f"{node_name}.{fn.__name__}") as span:
+                    for key, value in attrs.items():
+                        span.set_attribute(key, value)
+                    node.namespace["_telemetry_span"] = span
+                    try:
+                        result = fn(*fn_args, **fn_kwargs)
+                        if fn.__name__ == "save_results":
+                            try:
+                                uptrace.force_flush()
+                            except Exception:
+                                pass
+                        return result
+                    except Exception as e:
+                        span.record_exception(e)
+                        span.set_status(Status(StatusCode.ERROR, str(e)))
+                        raise
+                    finally:
+                        node.namespace.pop("_telemetry_span", None)
+
+            return decorator(traced_fn)
+
+        return wrapping_decorator
+
+    node.run_action = traced_run_action

qua_libs_core-0.1.0/qua_libs_core/telemetry/config.py

@@ -0,0 +1,138 @@
+"""
+Telemetry configuration and initialization module.
+"""
+
+import logging
+import os
+from typing import Optional, Dict, Any
+from opentelemetry import trace
+import uptrace
+
+logger = logging.getLogger(__name__)
+
+# pylint: disable=too-many-arguments,too-many-positional-arguments,too-few-public-methods
+
+
+class TelemetryConfig:
+    """Configuration class for telemetry settings."""
+
+    def __init__(
+        self,
+        dsn: Optional[str] = None,
+        service_name: Optional[str] = None,
+        service_version: Optional[str] = None,
+        deployment_environment: Optional[str] = None,
+        enabled: Optional[bool] = None,
+        resource_attributes: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Initialize telemetry configuration.
+
+        Args:
+            dsn: Uptrace DSN (defaults to UPTRACE_DSN env var)
+            service_name: Service name (defaults to UPTRACE_SERVICE_NAME env var or "qua-libs")
+            service_version: Service version (defaults to UPTRACE_SERVICE_VERSION env var or "1.0.0")
+            deployment_environment: Deployment environment (defaults to UPTRACE_ENV env var or "production")
+            enabled: Whether telemetry is enabled (defaults to UPTRACE_ENABLED env var or False)
+            resource_attributes: Extra key-value metadata attached to every span automatically
+        """
+        self.dsn = dsn or os.getenv("UPTRACE_DSN")
+        self.resource_attributes = resource_attributes or {}
+        self.service_name = service_name or os.getenv("UPTRACE_SERVICE_NAME", "qua-libs")
+        self.service_version = service_version or os.getenv("UPTRACE_SERVICE_VERSION", "1.0.0")
+        self.deployment_environment = deployment_environment or os.getenv("UPTRACE_ENV", "production")
+
+        # Off by default. Enable via .qua-libs/telemetry.toml, UPTRACE_ENABLED=true, or enabled=True.
+        enabled_str = os.getenv("UPTRACE_ENABLED", "false").lower()
+        self.enabled = enabled if enabled is not None else (enabled_str in ("true", "1", "yes"))
+
+        # Note: Enabled-but-no-DSN is handled in init_telemetry; do not raise in __init__.
+
+
+# Global state
+_telemetry_initialized = False
+_tracer = None
+
+
+def init_telemetry(config: Optional[TelemetryConfig] = None) -> None:
+    """
+    Initialize OpenTelemetry with Uptrace.
+
+    This should be called once at application startup.
+    Subsequent calls are safe and will be ignored.
+
+    Args:
+        config: TelemetryConfig instance. If None, loads from .qua-libs/telemetry.toml,
+            environment variables, and built-in defaults via load_project_config().
+    """
+    global _telemetry_initialized, _tracer
+
+    if _telemetry_initialized:
+        return
+
+    if config is None:
+        from .project_config import load_project_config
+
+        config = load_project_config()
+
+    if not config.enabled:
+        logger.info(
+            "Telemetry is disabled (off by default). "
+            "Set enabled=true in .qua-libs/telemetry.toml, UPTRACE_ENABLED=true, "
+            "or pass TelemetryConfig(enabled=True, dsn=...) to enable."
+        )
+        _telemetry_initialized = True
+        return
+
+    if not config.dsn:
+        # Enabled but no destination configured. Stay disabled rather than crash —
+        # telemetry must never break a calibration run.
+        logger.warning(
+            "Telemetry is enabled but no Uptrace DSN was provided. "
+            "Set UPTRACE_DSN (or pass dsn=...). Telemetry stays disabled."
+        )
+        _telemetry_initialized = True
+        return
+
+    try:
+        uptrace.configure_opentelemetry(
+            dsn=config.dsn,
+            service_name=config.service_name,
+            service_version=config.service_version,
+            deployment_environment=config.deployment_environment,
+            resource_attributes=config.resource_attributes,
+        )
+        _tracer = trace.get_tracer(config.service_name, config.service_version)
+        _telemetry_initialized = True
+        logger.info("Telemetry initialized: %s v%s", config.service_name, config.service_version)
+    except Exception as e:
+        logger.warning("Failed to initialize telemetry: %s", e)
+        # Continue without telemetry rather than crashing
+        _telemetry_initialized = True
+
+
+def get_tracer(name: Optional[str] = None, version: Optional[str] = None):
+    """
+    Get the OpenTelemetry tracer instance.
+
+    Args:
+        name: Optional tracer name (defaults to service name from config)
+        version: Optional tracer version (defaults to service version from config)
+
+    Returns:
+        Tracer instance. Returns a no-op tracer if telemetry is not initialized or disabled.
+    """
+    global _tracer, _telemetry_initialized
+
+    if not _telemetry_initialized:
+        # Auto-initialize if not done yet
+        init_telemetry()
+
+    if _tracer is None:
+        # Return a no-op tracer if telemetry is disabled
+        return trace.NoOpTracer()
+
+    if name or version:
+        return trace.get_tracer(name or "qua-libs", version or "1.0.0")
+
+    return _tracer

qua_libs_core-0.1.0/qua_libs_core/telemetry/context_managers.py

@@ -0,0 +1,65 @@
+"""
+Context managers for manual span creation.
+"""
+
+from contextlib import contextmanager
+from typing import Optional, Dict, Any
+from .config import get_tracer
+
+
+@contextmanager
+def trace_span(
+    span_name: str,
+    attributes: Optional[Dict[str, Any]] = None,
+    tracer_name: Optional[str] = None,
+    tracer_version: Optional[str] = None,
+):
+    """
+    Context manager for creating a trace span.
+
+    Args:
+        span_name: Name for the span
+        attributes: Dictionary of attributes to set on the span
+        tracer_name: Optional custom tracer name
+        tracer_version: Optional custom tracer version
+
+    Example:
+        with trace_span("process_data", attributes={"component": "processor"}):
+            # Your code here
+            result = process(data)
+    """
+    tracer = get_tracer(tracer_name, tracer_version)
+
+    with tracer.start_as_current_span(span_name) as span:
+        if attributes:
+            for key, value in attributes.items():
+                span.set_attribute(key, value)
+        yield span
+
+
+@contextmanager
+def trace_span_with_attributes(
+    span_name: str,
+    tracer_name: Optional[str] = None,
+    tracer_version: Optional[str] = None,
+):
+    """
+    Context manager that yields a span for manual attribute setting.
+
+    This is useful when you need to set attributes dynamically within the span.
+
+    Args:
+        span_name: Name for the span
+        tracer_name: Optional custom tracer name
+        tracer_version: Optional custom tracer version
+
+    Example:
+        with trace_span_with_attributes("simulation") as span:
+            span.set_attribute("duration", 100)
+            span.set_attribute("iterations", 50)
+            # Your code here
+    """
+    tracer = get_tracer(tracer_name, tracer_version)
+
+    with tracer.start_as_current_span(span_name) as span:
+        yield span

qua_libs_core-0.1.0/qua_libs_core/telemetry/decorators.py

@@ -0,0 +1,131 @@
+"""
+Decorators for automatic function instrumentation.
+"""
+
+import functools
+from typing import Callable, Any, Optional, Dict
+from opentelemetry.trace import StatusCode
+from .config import get_tracer
+from .utils import record_exception, set_span_status
+
+
+def trace_function(
+    span_name: Optional[str] = None,
+    attributes: Optional[Dict[str, Any]] = None,
+    capture_args: bool = False,
+    capture_result: bool = False,
+):
+    """
+    Decorator to automatically trace a function with OpenTelemetry.
+
+    Args:
+        span_name: Name for the span (defaults to function name)
+        attributes: Dictionary of attributes to set on the span
+        capture_args: Whether to capture function arguments as span attributes
+        capture_result: Whether to capture function return value as span attribute
+
+    Example:
+        @trace_function("process_data", attributes={"component": "data_processor"})
+        def process_data(x, y):
+            return x + y
+
+        @trace_function(capture_args=True, capture_result=True)
+        def calculate(a, b):
+            return a * b
+    """
+
+    def decorator(func: Callable) -> Callable:
+        name = span_name or f"{func.__module__}.{func.__name__}"
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            tracer = get_tracer()
+
+            with tracer.start_as_current_span(name) as span:
+                # Set initial attributes
+                if attributes:
+                    for key, value in attributes.items():
+                        span.set_attribute(key, value)
+
+                # Capture function arguments
+                if capture_args:
+                    for i, arg in enumerate(args):
+                        span.set_attribute(f"function.arg.{i}", str(arg))
+                    for key, value in kwargs.items():
+                        span.set_attribute(f"function.kwarg.{key}", str(value))
+
+                try:
+                    result = func(*args, **kwargs)
+
+                    # Capture result
+                    if capture_result:
+                        span.set_attribute("function.result", str(result))
+
+                    return result
+                except Exception as e:
+                    record_exception(span, e)
+                    set_span_status(span, StatusCode.ERROR, str(e))
+                    raise
+
+        return wrapper
+
+    return decorator
+
+
+def trace_async_function(
+    span_name: Optional[str] = None,
+    attributes: Optional[Dict[str, Any]] = None,
+    capture_args: bool = False,
+    capture_result: bool = False,
+):
+    """
+    Decorator to automatically trace an async function with OpenTelemetry.
+
+    Args:
+        span_name: Name for the span (defaults to function name)
+        attributes: Dictionary of attributes to set on the span
+        capture_args: Whether to capture function arguments as span attributes
+        capture_result: Whether to capture function return value as span attribute
+
+    Example:
+        @trace_async_function("async_process")
+        async def async_process(data):
+            return await process(data)
+    """
+
+    def decorator(func: Callable) -> Callable:
+        name = span_name or f"{func.__module__}.{func.__name__}"
+
+        @functools.wraps(func)
+        async def wrapper(*args, **kwargs):
+            tracer = get_tracer()
+
+            with tracer.start_as_current_span(name) as span:
+                # Set initial attributes
+                if attributes:
+                    for key, value in attributes.items():
+                        span.set_attribute(key, value)
+
+                # Capture function arguments
+                if capture_args:
+                    for i, arg in enumerate(args):
+                        span.set_attribute(f"function.arg.{i}", str(arg))
+                    for key, value in kwargs.items():
+                        span.set_attribute(f"function.kwarg.{key}", str(value))
+
+                try:
+                    result = await func(*args, **kwargs)
+
+                    # Capture result
+                    if capture_result:
+                        span.set_attribute("function.result", str(result))
+
+                    return result
+                except Exception as e:
+                    record_exception(span, e)
+                    set_span_status(span, StatusCode.ERROR, str(e))
+                    raise
+
+        return wrapper
+
+    return decorator

qua_libs_core-0.1.0/qua_libs_core/telemetry/file_config.py

@@ -0,0 +1,137 @@
+"""
+Load project-level telemetry settings from ``.qua-libs/telemetry.toml``.
+
+Create this file at the repository root:
+
+  ``<install>/.qua-libs/telemetry.toml``
+
+Discovery walks upward from the current working directory.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+from typing import Any, Mapping, Optional
+
+from .config import TelemetryConfig
+
+CONFIG_DIR_NAME = ".qua-libs"
+CONFIG_FILE_NAME = "telemetry.toml"
+ENV_CONFIG_PATH = "QUA_LIBS_TELEMETRY_CONFIG"
+
+
+def _load_toml(path: Path) -> dict[str, Any]:
+    if sys.version_info >= (3, 11):
+        import tomllib
+
+        loader = tomllib.load
+    else:
+        import tomli
+
+        loader = tomli.load
+
+    with path.open("rb") as handle:
+        return loader(handle)
+
+
+def _as_bool(value: Any) -> bool:
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        return value.lower() in ("true", "1", "yes")
+    return bool(value)
+
+
+def find_telemetry_config_file(start: Optional[Path] = None) -> Optional[Path]:
+    """
+    Locate the project telemetry config file.
+
+    Search order:
+      1. ``QUA_LIBS_TELEMETRY_CONFIG`` env var (explicit path)
+      2. Walk upward from *start* (default: cwd) for ``.qua-libs/telemetry.toml``
+    """
+    env_path = os.getenv(ENV_CONFIG_PATH)
+    if env_path:
+        path = Path(env_path).expanduser()
+        return path if path.is_file() else None
+
+    current = (start or Path.cwd()).resolve()
+    for directory in (current, *current.parents):
+        candidate = directory / CONFIG_DIR_NAME / CONFIG_FILE_NAME
+        if candidate.is_file():
+            return candidate
+    return None
+
+
+def load_telemetry_file_config(start: Optional[Path] = None) -> Optional[dict[str, Any]]:
+    """Return the ``[telemetry]`` table from the project config file, if present."""
+    path = find_telemetry_config_file(start)
+    if path is None:
+        return None
+
+    data = _load_toml(path)
+    section = data.get("telemetry")
+    if section is None:
+        return None
+    if not isinstance(section, dict):
+        raise ValueError(f"{path}: [telemetry] must be a table")
+    return section
+
+
+def _resolve_enabled(file_value: Any, default: bool) -> bool:
+    env = os.getenv("UPTRACE_ENABLED")
+    if env is not None:
+        return env.lower() in ("true", "1", "yes")
+    if file_value is not None:
+        return _as_bool(file_value)
+    return default
+
+
+def _resolve_str(file_value: Any, env_name: str, default: str) -> str:
+    env = os.getenv(env_name)
+    if env:
+        return env
+    if file_value is not None:
+        return str(file_value)
+    return default
+
+
+def _resolve_optional_str(file_value: Any, env_name: str) -> Optional[str]:
+    env = os.getenv(env_name)
+    if env:
+        return env
+    if file_value is not None:
+        return str(file_value)
+    return None
+
+
+def build_project_config(
+    *,
+    defaults: Mapping[str, Any],
+    file_values: Optional[Mapping[str, Any]] = None,
+) -> TelemetryConfig:
+    """
+    Build a :class:`TelemetryConfig` from defaults, an optional TOML file, and env vars.
+
+    Environment variables override file values; file values override *defaults*.
+    """
+    file_values = file_values or {}
+
+    resource_attributes = file_values.get("resource_attributes")
+    if resource_attributes is not None and not isinstance(resource_attributes, dict):
+        raise ValueError("[telemetry].resource_attributes must be a table")
+
+    return TelemetryConfig(
+        dsn=_resolve_optional_str(file_values.get("dsn"), "UPTRACE_DSN"),
+        service_name=_resolve_str(file_values.get("service_name"), "UPTRACE_SERVICE_NAME", defaults["service_name"]),
+        service_version=_resolve_str(
+            file_values.get("service_version"), "UPTRACE_SERVICE_VERSION", defaults["service_version"]
+        ),
+        deployment_environment=_resolve_str(
+            file_values.get("deployment_environment"), "UPTRACE_ENV", defaults["deployment_environment"]
+        ),
+        enabled=_resolve_enabled(file_values.get("enabled"), defaults.get("enabled", False)),
+        resource_attributes=resource_attributes or {},
+    )

qua_libs_core-0.1.0/qua_libs_core/telemetry/project_config.py

@@ -0,0 +1,33 @@
+"""
+Project-wide telemetry configuration.
+
+Telemetry is off by default. Enable it with ``.qua-libs/telemetry.toml`` or
+environment variables (``UPTRACE_ENABLED``, ``UPTRACE_DSN``, …).
+
+Resolution order per setting: environment variables, then TOML, then the defaults
+below.
+"""
+
+from pathlib import Path
+from typing import Optional
+
+from .config import TelemetryConfig
+from .file_config import build_project_config, load_telemetry_file_config
+
+_PROJECT_DEFAULTS = {
+    "service_name": "qua-libs",
+    "service_version": "1.0.0",
+    "deployment_environment": "production",
+    "enabled": False,
+}
+
+
+def load_project_config(start: Optional[Path] = None) -> TelemetryConfig:
+    """Load telemetry settings from defaults, TOML, and environment variables."""
+    return build_project_config(
+        defaults=_PROJECT_DEFAULTS,
+        file_values=load_telemetry_file_config(start),
+    )
+
+
+PROJECT_CONFIG = load_project_config()

qua_libs_core-0.1.0/qua_libs_core/telemetry/utils.py

@@ -0,0 +1,105 @@
+"""
+Utility functions for working with spans.
+"""
+
+from typing import Any, Optional
+from opentelemetry.trace import Span, Status, StatusCode
+
+
+def set_span_attribute(span: Span, key: str, value: Any) -> None:
+    """
+    Set an attribute on a span.
+
+    Args:
+        span: The span to set the attribute on
+        key: Attribute key
+        value: Attribute value (will be converted to string if not a supported type)
+
+    Example:
+        with trace_span("operation") as span:
+            set_span_attribute(span, "user.id", user_id)
+    """
+    span.set_attribute(key, value)
+
+
+def add_span_event(span: Span, name: str, attributes: Optional[dict] = None) -> None:
+    """
+    Add an event to a span.
+
+    Args:
+        span: The span to add the event to
+        name: Event name
+        attributes: Optional dictionary of event attributes
+
+    Example:
+        with trace_span("operation") as span:
+            add_span_event(span, "checkpoint_reached", {"checkpoint": 1})
+    """
+    span.add_event(name, attributes or {})
+
+
+def record_exception(span: Span, exception: Exception, attributes: Optional[dict] = None) -> None:
+    """
+    Record an exception on a span.
+
+    Args:
+        span: The span to record the exception on
+        exception: The exception to record
+        attributes: Optional additional attributes
+
+    Example:
+        try:
+            risky_operation()
+        except Exception as e:
+            with trace_span("operation") as span:
+                record_exception(span, e)
+                raise
+    """
+    span.record_exception(exception, attributes)
+
+
+def set_span_status(
+    span: Span,
+    status_code: StatusCode,
+    description: Optional[str] = None,
+) -> None:
+    """
+    Set the status of a span.
+
+    Args:
+        span: The span to set the status on
+        status_code: StatusCode (OK, ERROR, UNSET)
+        description: Optional status description
+
+    Example:
+        with trace_span("operation") as span:
+            try:
+                result = operation()
+                set_span_status(span, StatusCode.OK)
+            except Exception as e:
+                set_span_status(span, StatusCode.ERROR, str(e))
+    """
+    span.set_status(Status(status_code, description))
+
+
+def get_current_span() -> Span:
+    """
+    Get the currently active telemetry span.
+
+    Use this inside any @node.run_action function that has been
+    instrumented with instrument_calibration_node() to access the
+    span and set custom attributes dynamically.
+
+    Returns:
+        The current active span, or a no-op span if none is active.
+
+    Example:
+        @node.run_action(skip_if=node.parameters.simulate)
+        def analyse_data(node):
+            span = get_current_span()
+            # ... do analysis ...
+            set_span_attribute(span, "fit.q1", "successful")
+    """
+    from opentelemetry import trace
+
+    return trace.get_current_span()