qsharp 1.6.3.dev0__cp38-abi3-win_amd64.whl

qsharp/.data/qsharp_codemirror.js

@@ -0,0 +1,95 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+// This file provides CodeMirror syntax highlighting for Q# magic cells
+// in classic Jupyter Notebooks. It does nothing in other (Jupyter Notebook 7,
+// VS Code, Azure Notebooks, etc.) environments.
+
+// Detect the prerequisites and do nothing if they don't exist.
+if (window.require && window.CodeMirror && window.Jupyter) {
+  // The simple mode plugin for CodeMirror is not loaded by default, so require it.
+  window.require(["codemirror/addon/mode/simple"], function defineMode() {
+    let rules = [
+      {
+        token: "comment",
+        regex: /(\/\/).*/,
+        beginWord: false,
+      },
+      {
+        token: "string",
+        regex: String.raw`^\"(?:[^\"\\]|\\[\s\S])*(?:\"|$)`,
+        beginWord: false,
+      },
+      {
+        token: "keyword",
+        regex: String.raw`(namespace|open|as|operation|function|body|adjoint|newtype|controlled|internal)\b`,
+        beginWord: true,
+      },
+      {
+        token: "keyword",
+        regex: String.raw`(if|elif|else|repeat|until|fixup|for|in|return|fail|within|apply)\b`,
+        beginWord: true,
+      },
+      {
+        token: "keyword",
+        regex: String.raw`(Adjoint|Controlled|Adj|Ctl|is|self|auto|distribute|invert|intrinsic)\b`,
+        beginWord: true,
+      },
+      {
+        token: "keyword",
+        regex: String.raw`(let|set|use|borrow|mutable)\b`,
+        beginWord: true,
+      },
+      {
+        token: "operatorKeyword",
+        regex: String.raw`(not|and|or)\b|(w/)`,
+        beginWord: true,
+      },
+      {
+        token: "operatorKeyword",
+        regex: String.raw`(=)|(!)|(<)|(>)|(\+)|(-)|(\*)|(/)|(\^)|(%)|(\|)|(&&&)|(~~~)|(\.\.\.)|(\.\.)|(\?)`,
+        beginWord: false,
+      },
+      {
+        token: "meta",
+        regex: String.raw`(Int|BigInt|Double|Bool|Qubit|Pauli|Result|Range|String|Unit)\b`,
+        beginWord: true,
+      },
+      {
+        token: "atom",
+        regex: String.raw`(true|false|Pauli(I|X|Y|Z)|One|Zero)\b`,
+        beginWord: true,
+      },
+    ];
+    let simpleRules = [];
+    for (let rule of rules) {
+      simpleRules.push({
+        token: rule.token,
+        regex: new RegExp(rule.regex, "g"),
+        sol: rule.beginWord,
+      });
+      if (rule.beginWord) {
+        // Need an additional rule due to the fact that CodeMirror simple mode doesn't work with ^ token
+        simpleRules.push({
+          token: rule.token,
+          regex: new RegExp(String.raw`\W` + rule.regex, "g"),
+          sol: false,
+        });
+      }
+    }
+
+    // Register the mode defined above with CodeMirror
+    window.CodeMirror.defineSimpleMode("qsharp", { start: simpleRules });
+    window.CodeMirror.defineMIME("text/x-qsharp", "qsharp");
+
+    // Tell Jupyter to associate %%qsharp magic cells with the qsharp mode
+    window.Jupyter.CodeCell.options_default.highlight_modes["qsharp"] = {
+      reg: [/^%%qsharp/],
+    };
+
+    // Force re-highlighting of all cells the first time this code runs
+    for (const cell of window.Jupyter.notebook.get_cells()) {
+      cell.auto_highlight();
+    }
+  });
+}

qsharp/__init__.py

@@ -0,0 +1,49 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from ._qsharp import (
+    init,
+    eval,
+    run,
+    compile,
+    circuit,
+    estimate,
+    set_quantum_seed,
+    set_classical_seed,
+    dump_machine,
+    dump_circuit,
+    StateDump,
+    ShotResult,
+)
+
+from ._native import Result, Pauli, QSharpError, TargetProfile
+
+# IPython notebook specific features
+try:
+    if __IPYTHON__:  # type: ignore
+        from ._ipython import register_magic, enable_classic_notebook_codemirror_mode
+
+        register_magic()
+        enable_classic_notebook_codemirror_mode()
+except NameError:
+    pass
+
+
+__all__ = [
+    "init",
+    "eval",
+    "run",
+    "set_quantum_seed",
+    "set_classical_seed",
+    "dump_machine",
+    "dump_circuit",
+    "compile",
+    "circuit",
+    "estimate",
+    "Result",
+    "Pauli",
+    "QSharpError",
+    "TargetProfile",
+    "StateDump",
+    "ShotResult",
+]

qsharp/_fs.py

@@ -0,0 +1,37 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+import os
+from typing import Dict, List, Tuple
+
+
+def read_file(path: str) -> Tuple[str, str]:
+    with open(path, mode="r", encoding="utf-8-sig") as f:
+        return (path, f.read())
+
+
+def list_directory(dir_path: str) -> List[Dict[str, str]]:
+    def map_dir(e: str) -> Dict[str, str]:
+        return {
+            "path": os.path.join(dir_path, e),
+            "entry_name": e,
+            "type": (
+                "file"
+                if os.path.isfile(os.path.join(dir_path, e))
+                else "folder" if os.path.isdir(os.path.join(dir_path, e)) else "unknown"
+            ),
+        }
+
+    return list(map(map_dir, os.listdir(dir_path)))
+
+
+def resolve(base: str, path: str) -> str:
+    return os.path.normpath(join(base, path))
+
+
+def exists(path) -> bool:
+    return os.path.exists(path)
+
+
+def join(path: str, *paths) -> str:
+    return os.path.join(path, *paths)

qsharp/_http.py

@@ -0,0 +1,10 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+
+def fetch_github(owner: str, repo: str, ref: str, path: str) -> str:
+    import urllib
+
+    path_no_leading_slash = path[1:] if path.startswith("/") else path
+    url = f"https://raw.githubusercontent.com/{owner}/{repo}/{ref}/{path_no_leading_slash}"
+    return urllib.request.urlopen(url).read().decode("utf-8")

qsharp/_ipython.py

@@ -0,0 +1,61 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from IPython.display import display, Javascript, Pretty
+from IPython.core.magic import register_cell_magic
+from ._native import QSharpError
+from ._qsharp import get_interpreter
+import pathlib
+
+
+def register_magic():
+    @register_cell_magic
+    def qsharp(line, cell):
+        """Cell magic to interpret Q# code in Jupyter notebooks."""
+
+        def callback(output):
+            display(output)
+
+        try:
+            return get_interpreter().interpret(cell, callback)
+        except QSharpError as e:
+            raise QSharpCellError(str(e))
+
+
+def enable_classic_notebook_codemirror_mode():
+    """
+    Registers %%qsharp cells with MIME type text/x-qsharp
+    and defines a CodeMirror mode to enable syntax highlighting.
+    This only works in "classic" Jupyter notebooks, not Notebook v7.
+    """
+    js_to_inject = open(
+        pathlib.Path(__file__)
+        .parent.resolve()
+        .joinpath(".data", "qsharp_codemirror.js"),
+        mode="r",
+        encoding="utf-8",
+    ).read()
+
+    # Extend the JavaScript display helper to print nothing when used
+    # in a non-browser context (i.e. IPython console)
+    class JavaScriptWithPlainTextFallback(Javascript):
+        def __repr__(self):
+            return ""
+
+    # This will run the JavaScript in the context of the frontend.
+    display(JavaScriptWithPlainTextFallback(js_to_inject))
+
+
+class QSharpCellError(BaseException):
+    """
+    Error raised when a %%qsharp cell fails.
+    """
+
+    def __init__(self, traceback: str):
+        self.traceback = traceback.splitlines()
+
+    def _render_traceback_(self):
+        # We want to specifically override the traceback so that
+        # the Q# error directly from the interpreter is shown
+        # instead of the Python error.
+        return self.traceback

qsharp/_native.pyi

@@ -0,0 +1,233 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from enum import Enum
+from typing import Any, Callable, ClassVar, Optional, Dict, List
+
+class TargetProfile:
+    """
+    A Q# target profile.
+
+    A target profile describes the capabilities of the hardware or simulator
+    which will be used to run the Q# program.
+    """
+
+    Base: ClassVar[Any]
+    """
+    Target supports the minimal set of capabilities required to run a quantum
+    program.
+
+    This option maps to the Base Profile as defined by the QIR specification.
+    """
+
+    Adaptive_RI: ClassVar[Any]
+    """
+    Target supports the Adaptive profile with integer computation and qubit
+    reset capabilities.
+
+    This profile includes all of the required Adaptive Profile
+    capabilities, as well as the optional integer computation and qubit
+    reset capabilities, as defined by the QIR specification.
+    """
+
+    Unrestricted: ClassVar[Any]
+    """
+    Describes the unrestricted set of capabilities required to run any Q# program.
+    """
+
+class Interpreter:
+    """A Q# interpreter."""
+
+    def __init__(
+        self,
+        target_profile: TargetProfile,
+        language_features: Optional[List[str]],
+        project_root: Optional[str],
+        read_file: Callable[[str], str],
+        list_directory: Callable[[str], str],
+        resolve_path: Callable[[str, str], str],
+    ) -> None:
+        """
+        Initializes the Q# interpreter.
+
+        :param target_profile: The target profile to use for the interpreter.
+        :param project_root: A directory that contains a `qsharp.json` manifest.
+        :param read_file: A function that reads a file from the file system.
+        :param list_directory: A function that lists the contents of a directory.
+        :param resolve_path: A function that joins path segments and normalizes the resulting path.
+        """
+        ...
+
+    def interpret(self, input: str, output_fn: Callable[[Output], None]) -> Any:
+        """
+        Interprets Q# source code.
+
+        :param input: The Q# source code to interpret.
+        :param output_fn: A callback function that will be called with each output.
+
+        :returns value: The value returned by the last statement in the input.
+
+        :raises QSharpError: If there is an error interpreting the input.
+        """
+        ...
+
+    def run(self, entry_expr: str, output_fn: Callable[[Output], None]) -> Any:
+        """
+        Runs the given Q# expression with an independent instance of the simulator.
+
+        :param entry_expr: The entry expression.
+        :param output_fn: A callback function that will be called with each output.
+
+        :returns values: A result or runtime errors.
+
+        :raises QSharpError: If there is an error interpreting the input.
+        """
+        ...
+
+    def qir(self, entry_expr: str) -> str:
+        """
+        Generates QIR from Q# source code.
+
+        :param entry_expr: The entry expression.
+
+        :returns qir: The QIR string.
+        """
+        ...
+
+    def circuit(
+        self,
+        entry_expr: Optional[str],
+        operation: Optional[str],
+    ) -> Circuit:
+        """
+        Synthesizes a circuit for a Q# program. Either an entry
+        expression or an operation must be provided.
+
+        :param entry_expr: An entry expression.
+
+        :param operation: The operation to synthesize. This can be a name of
+        an operation of a lambda expression. The operation must take only
+        qubits or arrays of qubits as parameters.
+
+        :raises QSharpError: If there is an error synthesizing the circuit.
+        """
+        ...
+
+    def estimate(self, entry_expr: str, params: str) -> str:
+        """
+        Estimates resources for Q# source code.
+
+        :param entry_expr: The entry expression.
+        :param params: The parameters to configure estimation.
+
+        :returns resources: The estimated resources.
+        """
+        ...
+
+    def set_quantum_seed(self, seed: Optional[int]) -> None:
+        """
+        Sets the seed for the quantum random number generator.
+
+        :param seed: The seed to use for the quantum random number generator. If None,
+            the seed will be generated from entropy.
+        """
+        ...
+
+    def set_classical_seed(self, seed: Optional[int]) -> None:
+        """
+        Sets the seed for the classical random number generator.
+
+        :param seed: The seed to use for the classical random number generator. If None,
+            the seed will be generated from entropy.
+        """
+        ...
+
+    def dump_machine(self) -> StateDumpData:
+        """
+        Returns the sparse state vector of the simulator as a StateDump object.
+
+        :returns: The state of the simulator.
+        """
+        ...
+
+    def dump_circuit(self) -> Circuit:
+        """
+        Dumps the current circuit state of the interpreter.
+
+        This circuit will contain the gates that have been applied
+        in the simulator up to the current point.
+        """
+        ...
+
+class Result(Enum):
+    """
+    A Q# measurement result.
+    """
+
+    Zero: int
+    One: int
+
+class Pauli(Enum):
+    """
+    A Q# Pauli operator.
+    """
+
+    I: int
+    X: int
+    Y: int
+    Z: int
+
+class Output:
+    """
+    An output returned from the Q# interpreter.
+    Outputs can be a state dumps or messages. These are normally printed to the console.
+    """
+
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def _repr_html_(self) -> str: ...
+    def _repr_latex_(self) -> Optional[str]: ...
+    def state_dump(self) -> Optional[StateDumpData]: ...
+
+class StateDumpData:
+    """
+    A state dump returned from the Q# interpreter.
+    """
+
+    """
+    The number of allocated qubits at the time of the dump.
+    """
+    qubit_count: int
+
+    """
+    Get the amplitudes of the state vector as a dictionary from state integer to
+    complex amplitudes.
+    """
+    def get_dict(self) -> dict: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def _repr_html_(self) -> str: ...
+    def _repr_latex_(self) -> Optional[str]: ...
+
+class Circuit:
+    def json(self) -> str: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+
+class QSharpError(BaseException):
+    """
+    An error returned from the Q# interpreter.
+    """
+
+    ...
+
+def physical_estimates(logical_resources: str, params: str) -> str:
+    """
+    Estimates physical resources from pre-calculated logical resources.
+
+    :param logical_resources: The logical resources to estimate from.
+    :param params: The parameters to configure physical estimation.
+
+    :returns resources: The estimated resources.
+    """
+    ...