compiler-config 0.1.0__tar.gz

compiler_config-0.1.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, oqc-community
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

compiler_config-0.1.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.1
+Name: compiler-config
+Version: 0.1.0
+Summary: 
+Author: jamie
+Author-email: jfriel@oxfordquantumcircuits.com
+Requires-Python: >=3.8.1,<3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Description-Content-Type: text/markdown
+
+# compiler-config
+
+OQC's task level compiler configuration. The compiler-config package is an internal dependency of [QAT](https://github.com/oqc-community/qat) 
+(OQC's compiler and runtime) and will soon be adopted as a dependency of our QCaaS (Quantum Computing as a Service) client. *End users should not need to interact with this package except via QAT or QCAAS client.*
+
+#### Licence
+
+This code in this repository is licensed under the BSD 3-Clause Licence.
+Please see [LICENSE](LICENSE) for more information.

compiler_config-0.1.0/README.md

@@ -0,0 +1,9 @@
+# compiler-config
+
+OQC's task level compiler configuration. The compiler-config package is an internal dependency of [QAT](https://github.com/oqc-community/qat) 
+(OQC's compiler and runtime) and will soon be adopted as a dependency of our QCaaS (Quantum Computing as a Service) client. *End users should not need to interact with this package except via QAT or QCAAS client.*
+
+#### Licence
+
+This code in this repository is licensed under the BSD 3-Clause Licence.
+Please see [LICENSE](LICENSE) for more information.

compiler_config-0.1.0/compiler_config/config.py

@@ -0,0 +1,447 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) 2023 Oxford Quantum Circuits Ltd
+from __future__ import annotations
+
+import inspect
+import re
+import sys
+from enum import Enum, Flag, IntEnum, auto
+from typing import List, Optional
+
+from compiler_config.serialiser import json_dumps, json_loads
+
+
+class InlineResultsProcessing(Flag):
+    """
+    Results transforms applied directly to the read-out value on the QPU. In most
+    situations applied post-execution, but can also be interwoven.
+    """
+
+    # Raw readout from the QPU. Normally Z-axis values for each shot.
+    Raw = auto()
+
+    # Shot results averaged out to get a single 0/1 value for each qubit.
+    Binary = auto()
+
+    # Return the values in numpy arrays not Python lists.
+    NumpyArrays = auto()
+
+    Experiment = Raw | NumpyArrays
+    Program = Binary
+
+    def __repr__(self):
+        return self.name
+
+
+class ResultsFormatting(Flag):
+    # Transforms each shot into binary then counts the instances.
+    # Example for two qubits: { '00': 15, '01': 2524, '10': 250, '11': 730 }
+    BinaryCount = auto()
+
+    # Change results value based on conditions for ease-of-use. Set as a flag because
+    # it means that return values from execution may change format unexpectedly, so
+    # should have a way to disable it for certain uses.
+    DynamicStructureReturn = auto()
+
+    # If your qubit results are lists of binary, squash to one string representation.
+    # Changes 1: [1, 0, 0, 1] to 1: '1001'.
+    # Only works when Binary format is returned.
+    SquashBinaryResultArrays = auto()
+
+    def __repr__(self):
+        return self.name
+
+
+class QuantumResultsFormat:
+    def __init__(self):
+        self.format: Optional[InlineResultsProcessing] = None
+        self.transforms: Optional[ResultsFormatting] = (
+            ResultsFormatting.DynamicStructureReturn
+        )
+
+    def raw(self) -> QuantumResultsFormat:
+        self.format = InlineResultsProcessing.Raw
+        return self
+
+    def binary(self) -> QuantumResultsFormat:
+        self.format = InlineResultsProcessing.Binary
+        return self
+
+    def binary_count(self):
+        """
+        Returns a count of each instance of measured qubit registers.
+        Switches result format to raw.
+        """
+        self.transforms = (
+            ResultsFormatting.BinaryCount | ResultsFormatting.DynamicStructureReturn
+        )
+        self.format = InlineResultsProcessing.Raw
+        return self
+
+    def squash_binary_result_arrays(self):
+        """
+        Squashes binary result list into a singular bit string. Switches results to
+        binary.
+        """
+        self.transforms = (
+            ResultsFormatting.SquashBinaryResultArrays
+            | ResultsFormatting.DynamicStructureReturn
+        )
+        self.format = InlineResultsProcessing.Binary
+        return self
+
+    def __contains__(self, other):
+        if isinstance(other, ResultsFormatting):
+            return self.transforms.__contains__(other)
+        elif isinstance(other, InlineResultsProcessing):
+            return self.format.__contains__(other)
+        return False
+
+    def __or__(self, other):
+        if isinstance(other, ResultsFormatting):
+            self.transforms = self.transforms.__or__(other)
+        elif isinstance(other, InlineResultsProcessing):
+            self.format = self.format.__or__(other)
+        return self
+
+    def __and__(self, other):
+        if isinstance(other, ResultsFormatting):
+            self.transforms = self.transforms.__and__(other)
+        elif isinstance(other, InlineResultsProcessing):
+            self.format = self.format.__and__(other)
+        return self
+
+    def __xor__(self, other):
+        if isinstance(other, ResultsFormatting):
+            self.transforms = self.transforms.__xor__(other)
+        elif isinstance(other, InlineResultsProcessing):
+            self.format = self.format.__xor__(other)
+        return self
+
+    def __repr__(self):
+        return f"Format: {str(self.format)}. Transforms: {str(self.transforms)}."
+
+    def __eq__(self, other):
+        return self.format == other.format and self.transforms == other.transforms
+
+
+class TketOptimizations(Flag):
+    """Flags for the various Tket optimizations we can apply."""
+
+    Empty = auto()
+    DefaultMappingPass = auto()
+    FullPeepholeOptimise = auto()
+    ContextSimp = auto()
+    DirectionalCXGates = auto()
+    CliffordSimp = auto()
+    DecomposeArbitrarilyControlledGates = auto()
+    # EulerAngleReduction = auto()
+    GlobalisePhasedX = auto()
+    # GuidedPauliSimp = auto()
+    KAKDecomposition = auto()
+    # OptimisePhaseGadgets = auto()
+    # PauliSimp = auto()
+    # PauliSquash = auto()
+    PeepholeOptimise2Q = auto()
+    RemoveDiscarded = auto()
+    RemoveBarriers = auto()
+    RemoveRedundancies = auto()
+    ThreeQubitSquash = auto()
+    SimplifyMeasured = auto()
+
+    One = DefaultMappingPass | DirectionalCXGates
+    Two = One | FullPeepholeOptimise | ContextSimp
+
+
+class QiskitOptimizations(Flag):
+    """Flags for the various Qiskit optimizations we can apply."""
+
+    Empty = auto()
+
+
+class QatOptimizations(Flag):
+    """Flags for the various Qat optimizations we can apply."""
+
+    Empty = auto()
+
+
+class MetricsType(Flag):
+    Empty = auto()
+
+    # Returns circuit after optimizations have been run.
+    OptimizedCircuit = auto()
+
+    # Count of transformed instructions after all forms of optimizations have
+    # been performed.
+    OptimizedInstructionCount = auto()
+
+    # Set of basic metrics that should be returned at all times.
+    Default = OptimizedCircuit | OptimizedInstructionCount
+
+    def is_composite(self):
+        """
+        Any flags that are only composed of other ones should be signaled here. This
+        is used for automatic metric generation and whether to build/validate this
+        particular value.
+        """
+        return self == self.Default or self == self.Empty
+
+    def snake_case_name(self):
+        """
+        Generate the Python field name that'll be used to hold the results of this
+        metric.
+        """
+        name = self.name
+        name = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", name)
+        return re.sub("([a-z0-9])([A-Z])", r"\1_\2", name).lower()
+
+
+class ErrorMitigationConfig(Flag):
+    Empty = auto()
+    MatrixMitigation = auto()
+    LinearMitigation = auto()
+
+
+class ExperimentalFeatures:
+    error_mitigation = ErrorMitigationConfig.Empty
+
+
+class CompilerConfig:
+    """
+    Full settings for the compiler. All values are defaulted on initialization.
+
+    If no explicit optimizations are passed then the default set of optimization for the
+    language you're attempting to compile will be applied.
+    """
+
+    def __init__(
+        self,
+        repeats=None,
+        repetition_period=None,
+        results_format: QuantumResultsFormat = None,
+        metrics=MetricsType.Default,
+        active_calibrations=None,
+        optimizations: "OptimizationConfig" = None,
+        error_mitigation: ErrorMitigationConfig = None,
+    ):
+        self.repeats: Optional[int] = repeats
+        self.repetition_period: Optional[float] = repetition_period
+        self.results_format: QuantumResultsFormat = results_format or QuantumResultsFormat()
+        self.metrics: MetricsType = metrics
+        self.active_calibrations: List[CalibrationArguments] = active_calibrations or []
+        self.optimizations: Optional[OptimizationConfig] = optimizations
+        self.error_mitigation: Optional[ErrorMitigationConfig] = error_mitigation
+
+    def to_json(self):
+        return json_dumps(self, serializable_types=get_serializable_types())
+
+    def from_json(self, json: str):
+        vars(self).update(
+            vars(json_loads(json, serializable_types=get_serializable_types()))
+        )
+        return self
+
+    @classmethod
+    def create_from_json(cls, json: str):
+        return CompilerConfig().from_json(json)
+
+    def validate(self, hardware):
+
+        if (
+            self.error_mitigation is not None
+            and self.error_mitigation != ErrorMitigationConfig.Empty
+        ):
+            if (
+                hardware.error_mitigation is None
+                or not hardware.error_mitigation.readout_mitigation
+            ):
+                raise ValueError("Error mitigation not calibrated on this device.")
+            if ResultsFormatting.BinaryCount not in self.results_format:
+                raise ValueError(
+                    "Binary Count format required for readout error mitigation"
+                )
+
+
+class CalibrationArguments:
+    """Base class for individual calibration arguments."""
+
+    def to_json(self):
+        return json_dumps(self)
+
+    def from_json(self, json: str):
+        self.from_dict(json_loads(json))
+
+    def _get_field_names(self):
+        """Get existing field names for all attributes and properties"""
+        existing_field_names = set(vars(self).keys())
+        # Include class properties
+        class_type = type(self)
+        for prop in dir(class_type):
+            if isinstance(getattr(class_type, prop), property):
+                existing_field_names.add(prop)
+
+        return existing_field_names
+
+    def from_dict(self, dict_values):
+        """
+        Loads this dictionary into the arguments. Throws if key dosen't exist on the
+        object.
+        """
+        valid_names = self._get_field_names()
+        invalid_fields = [val for val in dict_values.keys() if val not in valid_names]
+        if any(invalid_fields):
+            raise ValueError(
+                f"Field(s) {','.join(invalid_fields)} are not valid for "
+                f"{self.__class__.__name__}."
+            )
+
+        vars(self).update(dict_values)
+
+
+class Languages(IntEnum):
+    Empty, Qasm2, Qasm3, QIR = range(4)
+
+    def __repr__(self):
+        return self.name
+
+
+class OptimizationConfig:
+    """
+    Base class for instantiated optimizations as well as mix-in classes. Built this way
+    so we can mix and match optimization objects across multiple setups and languages
+    without duplication.
+    """
+
+    def __init__(self):
+        super().__init__()
+
+    def default(self):
+        """Apply default set of optimizations to the current set."""
+        return self
+
+    def disable(self):
+        """Disable all optimizations."""
+        return self
+
+    def minimum(self):
+        """
+        Apply minimum working set for current optimizations.
+        """
+        return self
+
+    def __contains__(self, item):
+        return False
+
+
+class Tket(OptimizationConfig):
+    def __init__(self, tket_optimization=None):
+        super().__init__()
+        self.tket_optimizations: TketOptimizations = TketOptimizations.Empty
+        if tket_optimization is not None:
+            self.tket_optimizations = tket_optimization
+
+    def default(self):
+        self.tket_optimizations = TketOptimizations.One
+        return self
+
+    def disable(self):
+        self.tket_optimizations = TketOptimizations.Empty
+        return self
+
+    def minimum(self):
+        self.tket_optimizations = TketOptimizations.DefaultMappingPass
+        return self
+
+    def __contains__(self, item):
+        if isinstance(item, TketOptimizations) and item in self.tket_optimizations:
+            return True
+        return super().__contains__(item)
+
+
+class Qiskit(OptimizationConfig):
+    def __init__(self):
+        super().__init__()
+        self.qiskit_optimizations: QiskitOptimizations = QiskitOptimizations.Empty
+
+    def default(self):
+        self.qiskit_optimizations = QiskitOptimizations.Empty
+        return self
+
+    def __contains__(self, item):
+        if isinstance(item, QiskitOptimizations) and item in self.qiskit_optimizations:
+            return True
+        return super().__contains__(item)
+
+
+class Qasm2Optimizations(Tket, Qiskit):
+    def __init__(self):
+        super().__init__()
+        self.default()
+
+    def __repr__(self):
+        return f"Qiskit: {self.qiskit_optimizations}. Tket: {self.tket_optimizations}."
+
+
+class Qasm3Optimizations(OptimizationConfig):
+    pass
+
+
+class QIROptimizations(OptimizationConfig):
+    pass
+
+
+def get_optimizer_config(lang: Languages) -> Optional[OptimizationConfig]:
+    """
+    Returns the optimization config for this particular language. None if no valid ones
+    found.
+    """
+    if lang == Languages.Qasm2:
+        return Qasm2Optimizations()
+    elif lang == Languages.Qasm3:
+        return Qasm3Optimizations()
+    elif lang == Languages.QIR:
+        return QIROptimizations()
+    return None
+
+
+def get_config(lang: Languages, **kwargs):
+    """
+    Helper method to build a compiler config for a particular language. Forwards
+    keywords to the CompilerConfig constructor.
+    """
+    config = CompilerConfig(**kwargs)
+    config.optimizations = get_optimizer_config(lang)
+    return config
+
+
+serializable_types_dict = None
+
+
+def get_serializable_types():
+    global serializable_types_dict
+
+    if serializable_types_dict is not None:
+        return serializable_types_dict
+
+    serializable_types = {}
+
+    def update_dict(type):
+        if issubclass(type, Enum):
+            serializable_types.update({f"<enum '{type.__module__}.{type.__name__}'>": type})
+        else:
+            serializable_types.update({str(type): type})
+
+    def get_serializable_types_dict(type):
+        update_dict(type)
+
+        for subclass in type.__subclasses__():
+            get_serializable_types_dict(subclass)
+
+    types_in_module = inspect.getmembers(sys.modules[__name__], inspect.isclass)
+
+    for name, typ in types_in_module:
+        get_serializable_types_dict(typ)
+
+    serializable_types_dict = serializable_types
+
+    return serializable_types_dict

compiler_config-0.1.0/compiler_config/serialiser.py

@@ -0,0 +1,181 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) 2023 Oxford Quantum Circuits Ltd
+import json
+import re
+import sys
+from dataclasses import asdict, is_dataclass
+from enum import Enum
+from importlib import import_module
+from json import JSONDecoder, JSONEncoder
+
+
+# Set of common methods so we don't have to add/remove the custom serializer.
+def json_dumps(*args, serializable_types=None, **kwargs):
+    kwargs.setdefault("cls", CustomJSONEncoder)
+    return json.dumps(*args, serializable_types=serializable_types, **kwargs)
+
+
+def json_loads(*args, serializable_types=None, **kwargs):
+    kwargs.setdefault("cls", CustomJsonDecoder)
+    return json.loads(*args, serializable_types=serializable_types, **kwargs)
+
+
+def json_dump(*args, serializable_types=None, **kwargs):
+    kwargs.setdefault("cls", CustomJSONEncoder)
+    return json.dump(*args, serializable_types=serializable_types, **kwargs)
+
+
+def json_load(*args, serializable_types=None, **kwargs):
+    kwargs.setdefault("cls", CustomJsonDecoder)
+    return json.load(*args, serializable_types=serializable_types, **kwargs)
+
+
+class CustomJsonDecoder(JSONDecoder):
+    def __init__(self, *args, serializable_types=None, model=None, **kwargs):
+        self.serializable_types = serializable_types
+        super().__init__(object_hook=self.default, *args, **kwargs)
+
+    def default(self, obj):
+        if not isinstance(obj, dict):
+            return obj
+
+        # Components are objects directly related to hardware and you never want to serialize them, so we re-link
+        # upon deserialization.
+
+        obj_type = obj.get("$type")
+        if obj_type is None:
+            return obj
+
+        if obj_type == "<class 'tuple'>":
+            return tuple(obj["$data"])
+
+        if self.serializable_types is not None:
+            old_paths = ["scc.compiler.config", "qat.purr.compiler.config"]
+            for old_path in old_paths:
+                if old_path in obj_type:
+                    obj_type = obj_type.replace(old_path, "compiler_config.config")
+                    break
+
+            typ = self.serializable_types.get(obj_type)
+            if typ is None:
+                raise ValueError(f"Invalid type attempted to be serialized: {obj_type}.")
+        else:
+            typ = _get_type(obj_type)
+
+        if issubclass(typ, Enum):
+            return typ(obj["$value"])
+
+        if "$data" in obj:
+            data = obj["$data"]
+            if obj.get("$dataclass", False):
+                fields = self.default(data)
+                return typ(**fields)
+            elif isinstance(data, dict):
+                new_obj = object.__new__(typ)
+                new_obj.__dict__ = {key: self.default(value) for key, value in data.items()}
+                return new_obj
+            elif isinstance(data, str):
+                return typ(data)
+            else:
+                return data
+
+        return obj
+
+
+class CustomJSONEncoder(JSONEncoder):
+    """
+    It is a customised JSON encoder, which allows the serialization of the more complex
+    objects.
+
+    There are four major cases, based on the provided object to be serialized:
+
+    - if the type of the object is supported by the default :class:`JSONEncoder`, than
+      the default method is used.
+    - if the class of the object is a :class:`dataclass`, then the serialization will
+      contain the name of the type, ``dataclass`` flag in order to help at the
+      deserialization, and the dictionary of the fields.
+    - if the object is none from the above, then the type name is saved, and the
+      interior data using ``__dict__``.
+    - if an exception is encountered from any cases from above (e.g. ``__dict__`` is not
+      available in case of complex numbers), then the type name is saved, and the data
+      is the string representation of the object.
+    """
+
+    def __init__(self, *args, serializable_types=None, **kwargs):
+        self.serializable_types = serializable_types
+        super().__init__(*args, **kwargs)
+
+    def default(self, obj):
+        typ = type(obj)
+        if issubclass(typ, Enum):
+            typ_str = f"<enum '{obj.__module__}.{typ.__name__}'>"
+        else:
+            typ_str = str(typ)
+
+        if self.serializable_types is not None:
+            if (
+                typ_str not in self.serializable_types
+                and type(obj).__module__ != "builtins"
+            ):
+                raise ValueError(f"Invalid type attempted to be serialized: {(type(obj))}.")
+
+        try:
+
+            # TODO: Acquire is a special wrapper component, not an actual component. Have a few too many special-cases
+            #   for it now, think about reverting its special status.
+            if is_dataclass(obj):
+                return {
+                    "$type": typ_str,
+                    "$dataclass": True,
+                    "$data": self.default(asdict(obj)),
+                }
+            elif isinstance(obj, Enum):
+                return {"$type": typ_str, "$value": obj.value}
+            elif isinstance(obj, complex):
+                return {"$type": typ_str, "$data": str(obj)}
+            elif isinstance(obj, tuple):
+                return {
+                    "$type": typ_str,
+                    "$data": tuple(self.default(val) for val in obj),
+                }
+
+            if hasattr(obj, "__dict__"):
+                return {
+                    "$type": typ_str,
+                    "$data": {
+                        key: self.default(value) for key, value in obj.__dict__.items()
+                    },
+                }
+        except (TypeError, AttributeError):
+            pass
+
+        return obj
+
+
+_type_name_matcher = r"<(?:class|enum) '((?:\w+\.)*)(\w+)'>"
+
+
+def _get_type(s: str):
+    match = re.match(_type_name_matcher, s)
+    if match:
+        namespace = match.group(1)
+        if namespace != "":
+            expanded_namespace = namespace[:-1].split(".")
+            module_name = expanded_namespace.pop(0)
+            imported_module = import_module(module_name)
+            for item in expanded_namespace:
+                module_name = f"{module_name}.{item}"
+                try:
+                    imported_module = getattr(imported_module, item)
+                except AttributeError:
+                    import_module(module_name)
+                    imported_module = getattr(imported_module, item)
+        else:
+            imported_module = sys.modules["builtins"]
+        try:
+            return getattr(imported_module, match.group(2))
+        except AttributeError:
+            raise AttributeError(
+                f"Class {s} not found in built-in modules or namespace '{namespace}'"
+            )
+    return None

compiler_config-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[tool.poetry]
+name = "compiler-config"
+version = "0.1.0"
+description = ""
+authors = ["jamie <jfriel@oxfordquantumcircuits.com>"]
+readme = "README.md"
+
+packages = [
+    { include = "compiler_config" }
+]
+
+
+[tool.poetry.dependencies]
+python = ">=3.8.1,<3.13"
+
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.3.2"
+isort = "^5.13.2"
+black = "^24.4.2"
+autoflake = "^2.3.1"
+pip-audit = "^2.7.3"
+
+
+[tool.autoflake]
+remove-all-unused-imports = true
+ignore-init-module-imports = true
+ignore-pass-after-docstring = true
+in-place = true
+recursive = true
+
+[tool.isort]
+py_version = 39
+profile = "black"
+line_length = 92
+known_first_party = ["qat"]
+
+[tool.black]
+line-length = 92
+target-version = ["py38", "py39", "py310"]
+
+[tool.poetry.scripts]
+format-code = "poetry_scripts:format_code"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"