classiq 0.92.0__py3-none-any.whl → 0.99.0__py3-none-any.whl

classiq/applications/qsvm/qsvm.py

@@ -1,11 +0,0 @@
-from classiq.interface.applications.qsvm import Data, Labels, QSVMData
-
-__all__ = [
-    "Data",
-    "Labels",
-    "QSVMData",
-]
-
-
-def __dir__() -> list[str]:
-    return __all__

classiq/evaluators/qmod_expression_visitors/qmod_expression_bwc.py

@@ -1,129 +0,0 @@
-import ast
-from typing import Any, cast
-
-import sympy
-
-MAX_PIECEWISE_LOOPS = 1000
-
-
-# FIXME: Remove with deprecation (CLS-3214)
-class QmodExpressionBwc(ast.NodeTransformer):
-    def visit_Call(self, node: ast.Call) -> Any:
-        node = cast(ast.Call, self.generic_visit(node))
-        if not isinstance(node.func, ast.Name):
-            return node
-        func = node.func.id
-        args = node.args
-        kwargs = node.keywords
-        num_args = len(args)
-        num_kwargs = len(kwargs)
-
-        if func == "BitwiseNot":
-            if num_args != 1 or num_kwargs != 0:
-                return node
-            return ast.UnaryOp(op=ast.Invert(), operand=args[0])
-        if func == "LShift":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.BinOp(left=args[0], op=ast.LShift(), right=args[1])
-        if func == "RShift":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.BinOp(left=args[0], op=ast.RShift(), right=args[1])
-        if func == "BitwiseOr":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.BinOp(left=args[0], op=ast.BitOr(), right=args[1])
-        if func == "BitwiseXor":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.BinOp(left=args[0], op=ast.BitXor(), right=args[1])
-        if func == "BitwiseAnd":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.BinOp(left=args[0], op=ast.BitAnd(), right=args[1])
-
-        if func == "LogicalXor":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.BinOp(left=args[0], op=ast.BitXor(), right=args[1])
-
-        if func == "Eq":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.Compare(left=args[0], ops=[ast.Eq()], comparators=[args[1]])
-        if func == "Ne":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.Compare(left=args[0], ops=[ast.NotEq()], comparators=[args[1]])
-        if func == "Lt":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.Compare(left=args[0], ops=[ast.Lt()], comparators=[args[1]])
-        if func == "Le":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.Compare(left=args[0], ops=[ast.LtE()], comparators=[args[1]])
-        if func == "Gt":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.Compare(left=args[0], ops=[ast.Gt()], comparators=[args[1]])
-        if func == "Ge":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.Compare(left=args[0], ops=[ast.GtE()], comparators=[args[1]])
-
-        if func == "do_subscript":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.Subscript(value=args[0], slice=args[1])
-
-        if func == "get_field":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            attr = args[1]
-            if not isinstance(attr, ast.Constant):
-                return node
-            return ast.Attribute(value=args[0], attr=attr.value)
-
-        if func == "Piecewise":
-            if num_args == 0:
-                return node
-            first_piece = args[0]
-            if not isinstance(first_piece, ast.Tuple) or len(first_piece.elts) != 2:
-                return node
-            first_cond = first_piece.elts[1]
-            if isinstance(first_cond, ast.BinOp):
-                first_cond = first_cond.right
-            if not isinstance(first_cond, ast.Compare) or len(first_cond.ops) != 1:
-                return node
-            index_var_node = first_cond.left
-            if not isinstance(index_var_node, ast.Name):
-                return node
-            index_var = index_var_node.id
-            last_cond = args[-1]
-            if not isinstance(last_cond, ast.Tuple) or len(last_cond.elts) != 2:
-                return node
-            last_value = last_cond.elts[0]
-            if not isinstance(last_value, ast.Constant) and (
-                not isinstance(last_value, ast.UnaryOp)
-                or not isinstance(last_value.operand, ast.Constant)
-            ):
-                return node
-            dummy_var_name = f"{index_var}_not_it"
-            last_cond.elts[0] = ast.Name(id=dummy_var_name)
-            items: list = []
-            idx = 0
-            for idx in range(MAX_PIECEWISE_LOOPS):
-                item = sympy.sympify(ast.unparse(node), locals={index_var: idx})
-                if str(item) == dummy_var_name:
-                    items.append(last_value)
-                    break
-                items.append(ast.parse(str(item), mode="eval").body)
-            if idx == MAX_PIECEWISE_LOOPS:
-                return node
-            return ast.Subscript(
-                value=ast.List(elts=items), slice=ast.Name(id=index_var)
-            )
-
-        return node

classiq/execution/iqcc.py

@@ -1,128 +0,0 @@
-import time
-import webbrowser
-
-from classiq.interface.exceptions import ClassiqError
-from classiq.interface.execution.iqcc import (
-    IQCCAuthItemDetails,
-    IQCCInitAuthData,
-    IQCCListAuthMethods,
-    IQCCListAuthTargets,
-    IQCCProbeAuthData,
-)
-
-from classiq._internals.api_wrapper import ApiWrapper
-from classiq._internals.async_utils import syncify_function
-
-
-async def list_iqcc_auth_scopes_async() -> list[IQCCAuthItemDetails]:
-    """List available authentication scopes in IQCC Bounday.
-
-    Returns:
-        The available authentication scopes.
-    """
-    response = await ApiWrapper().call_iqcc_list_auth_scopes()
-    return response.items
-
-
-list_iqcc_auth_scopes = syncify_function(list_iqcc_auth_scopes_async)
-
-
-async def list_iqcc_auth_methods_async(auth_scope_id: str) -> list[IQCCAuthItemDetails]:
-    """List available authentication methods in IQCC Bounday for a specific scope.
-
-    Args:
-        auth_scope_id: The ID of the IQCC Boundary authentication scope.
-
-    Returns:
-        The available authentication methods.
-    """
-    response = await ApiWrapper().call_iqcc_list_auth_methods(
-        IQCCListAuthMethods(auth_scope_id=auth_scope_id)
-    )
-    return response.items
-
-
-list_iqcc_auth_methods = syncify_function(list_iqcc_auth_methods_async)
-
-
-async def generate_iqcc_token_async(
-    auth_scope_id: str,
-    auth_method_id: str,
-    timeout: float = 120,
-    probe_interval: float = 1,
-    print_auth_url: bool = True,
-) -> str:
-    """Interactively generate a token for use in IQCC backends.
-
-    Args:
-        auth_scope_id: The ID of the IQCC Boundary authentication scope.
-        auth_method_id: The ID of the IQCC Boundary authentication method.
-        timeout: Number of seconds to wait for the interactive authentication to complete.
-        probe_interval: Number of seconds to wait between probes of the authentication.
-        print_auth_url: Whether to print the authentication URL, useful for headless machines with no browser.
-
-    Returns:
-        The authentication token string to use directly in `IQCCBackendPreferences`.
-
-    Raises:
-        ClassiqError: In case timeout has reached before a successful authentication.
-    """
-    initiate_response = await ApiWrapper().call_iqcc_init_auth(
-        IQCCInitAuthData(auth_scope_id=auth_scope_id, auth_method_id=auth_method_id)
-    )
-
-    if print_auth_url:
-        print("Please proceed with authentication on your web browser.")  # noqa: T201
-        print("If no window has opened, use this link to authenticate:")  # noqa: T201
-        print(initiate_response.auth_url)  # noqa: T201
-
-    webbrowser.open_new_tab(initiate_response.auth_url)
-
-    start_time = time.monotonic()
-    while True:
-        time.sleep(probe_interval)
-        probe_response = await ApiWrapper().call_iqcc_probe_auth(
-            IQCCProbeAuthData(
-                auth_scope_id=auth_scope_id,
-                auth_method_id=auth_method_id,
-                token_id=initiate_response.token_id,
-            )
-        )
-        if probe_response is not None:
-            return probe_response.auth_token
-
-        if time.monotonic() - start_time > timeout:
-            raise ClassiqError(
-                f"Timeout has reached while probing IQCC authentication. Please try again and make sure to authenticate within {timeout} seconds, or increase the timeout."
-            )
-
-
-generate_iqcc_token = syncify_function(generate_iqcc_token_async)
-
-
-async def list_iqcc_auth_targets_async(
-    auth_scope_id: str,
-    auth_method_id: str,
-    auth_token: str,
-) -> list[IQCCAuthItemDetails]:
-    """List available authentication targets in IQCC Boundary for the user.
-
-    Args:
-        auth_scope_id: The ID of the IQCC Boundary authentication scope.
-        auth_method_id: The ID of the IQCC Boundary authentication method.
-        auth_token: The authentication token string returned from `generate_iqcc_token_async`.
-
-    Returns:
-        The available authentication targets.
-    """
-    response = await ApiWrapper().call_iqcc_list_auth_targets(
-        IQCCListAuthTargets(
-            auth_scope_id=auth_scope_id,
-            auth_method_id=auth_method_id,
-            auth_token=auth_token,
-        )
-    )
-    return response.items
-
-
-list_iqcc_auth_target = syncify_function(list_iqcc_auth_targets_async)

classiq/interface/applications/qsvm.py

@@ -1,117 +0,0 @@
-from collections.abc import Iterable as IterableType, Sequence
-from typing import (
-    Any,
-    Optional,
-    Union,
-)
-
-import numpy as np
-import pydantic
-from numpy.typing import ArrayLike
-from pydantic import ConfigDict, field_validator
-
-from classiq.interface.helpers.versioned_model import VersionedModel
-
-DataList = list[list[float]]
-LabelsInt = list[int]
-
-
-def listify(obj: Union[IterableType, ArrayLike]) -> list:
-    if isinstance(obj, np.ndarray):
-        return obj.tolist()
-    elif isinstance(obj, Sequence) and obj and isinstance(obj[0], np.ndarray):
-        return np.array(obj).tolist()
-    elif isinstance(obj, list):
-        return obj
-    else:
-        return list(obj)  # type: ignore[arg-type]
-
-
-def validate_array_to_list(name: str) -> Any:
-    @field_validator(name, mode="before")
-    def _listify(cls: type[pydantic.BaseModel], value: Any) -> Any:
-        return listify(value)
-
-    return _listify
-
-
-Shape = tuple[int, ...]
-
-
-class QSVMInternalState(VersionedModel):
-    underscore_sparse: bool
-    class_weight: list
-    classes: list
-    underscore_gamma: float
-    underscore_base_fit: list
-    support: list
-    support_vectors: list
-    underscore_n_support: list
-    dual_coef_2: list
-    intercept: list
-    underscore_p_a: list
-    underscore_p_b: list
-    fit_status: int
-    shape_fit: Shape
-    underscore_intercept: list
-    dual_coef: list
-
-    class_weight__shape: Shape
-    classes__shape: Shape
-    underscore_base_fit__shape: Shape
-    support__shape: Shape
-    support_vectors__shape: Shape
-    underscore_n_support__shape: Shape
-    dual_coef_2__shape: Shape
-    intercept__shape: Shape
-    underscore_p_a__shape: Shape
-    underscore_p_b__shape: Shape
-    underscore_intercept__shape: Shape
-    dual_coef__shape: Shape
-
-    set_class_weight = validate_array_to_list("class_weight")
-    set_classes = validate_array_to_list("classes")
-    set_underscore_base_fit = validate_array_to_list("underscore_base_fit")
-    set_support = validate_array_to_list("support")
-    set_support_vectors = validate_array_to_list("support_vectors")
-    set_underscore_n_support = validate_array_to_list("underscore_n_support")
-    set_dual_coef_2 = validate_array_to_list("dual_coef_2")
-    set_intercept = validate_array_to_list("intercept")
-    set_underscore_p_a = validate_array_to_list("underscore_p_a")
-    set_underscore_p_b = validate_array_to_list("underscore_p_b")
-    set_underscore_intercept = validate_array_to_list("underscore_intercept")
-    set_dual_coef = validate_array_to_list("dual_coef")
-
-
-class QSVMData(VersionedModel):
-    data: DataList
-    labels: Optional[LabelsInt] = None
-    internal_state: Optional[QSVMInternalState] = None
-    model_config = ConfigDict(extra="forbid")
-
-    @pydantic.field_validator("data", mode="before")
-    @classmethod
-    def set_data(cls, data: Union[IterableType, ArrayLike]) -> list:
-        return listify(data)
-
-    @pydantic.field_validator("labels", mode="before")
-    @classmethod
-    def set_labels(
-        cls, labels: Optional[Union[IterableType, ArrayLike]]
-    ) -> Optional[list]:
-        if labels is None:
-            return None
-        else:
-            return listify(labels)
-
-
-class QSVMTestResult(VersionedModel):
-    data: float  # between 0 to 1
-
-
-class QSVMPredictResult(VersionedModel):
-    data: list  # serialized np.array
-
-
-Data = Union[DataList, np.ndarray]
-Labels = Union[list[Any], np.ndarray]

classiq/interface/chemistry/elements.py

@@ -1,120 +0,0 @@
-ELEMENTS = [
-    "H",
-    "He",
-    "Li",
-    "Be",
-    "B",
-    "C",
-    "N",
-    "O",
-    "F",
-    "Ne",
-    "Na",
-    "Mg",
-    "Al",
-    "Si",
-    "P",
-    "S",
-    "Cl",
-    "Ar",
-    "K",
-    "Ca",
-    "Sc",
-    "Ti",
-    "V",
-    "Cr",
-    "Mn",
-    "Fe",
-    "Co",
-    "Ni",
-    "Cu",
-    "Zn",
-    "Ga",
-    "Ge",
-    "As",
-    "Se",
-    "Br",
-    "Kr",
-    "Rb",
-    "Sr",
-    "Y",
-    "Zr",
-    "Nb",
-    "Mo",
-    "Tc",
-    "Ru",
-    "Rh",
-    "Pd",
-    "Ag",
-    "Cd",
-    "In",
-    "Sn",
-    "Sb",
-    "Te",
-    "I",
-    "Xe",
-    "Cs",
-    "Ba",
-    "La",
-    "Ce",
-    "Pr",
-    "Nd",
-    "Pm",
-    "Sm",
-    "Eu",
-    "Gd",
-    "Tb",
-    "Dy",
-    "Ho",
-    "Er",
-    "Tm",
-    "Yb",
-    "Lu",
-    "Hf",
-    "Ta",
-    "W",
-    "Re",
-    "Os",
-    "Ir",
-    "Pt",
-    "Au",
-    "Hg",
-    "Tl",
-    "Pb",
-    "Bi",
-    "Po",
-    "At",
-    "Rn",
-    "Fr",
-    "Ra",
-    "Ac",
-    "Th",
-    "Pa",
-    "U",
-    "Np",
-    "Pu",
-    "Am",
-    "Cm",
-    "Bk",
-    "Cf",
-    "Es",
-    "Fm",
-    "Md",
-    "No",
-    "Lr",
-    "Rf",
-    "Db",
-    "Sg",
-    "Bh",
-    "Hs",
-    "Mt",
-    "Ds",
-    "Rg",
-    "Cn",
-    "Nh",
-    "Fl",
-    "Mc",
-    "Lv",
-    "Ts",
-    "Og",
-]