semvec/pypi-packages huggingface dataset:
datadog-serverless-compat 0.11.0
Datadog Serverless Compatibility Layer for Python
License: Apache-2.0
Requires Python: <4.0,>=3.9
Keywords: datadog, azure, google, functions

# Datadog Serverless Compatibility Layer for Python

Datadog library for Python to enable tracing and custom metric submission from [Azure Functions](https://azure.microsoft.com/en-us/products/functions) and [Google Cloud Run Functions (1st gen)](https://cloud.google.com/functions/1stgendocs/concepts/overview).

# Getting Started

- [Install Serverless Monitoring for Azure Functions](https://docs.datadoghq.com/serverless/azure_functions/?code-lang=python)
- [Install Serverless Monitoring for Google Cloud Run Functions (1st gen)](https://docs.datadoghq.com/serverless/google_cloud_run/functions_gen1?code-lang=python)
Supermarq 0.5.62
Supermarq is a scalable, application-centric quantum benchmarking suite.
License: Apache-2.0
Requires Python: >=3.9.0

<p align="center">
  <img width="300" src="../docs/source/_static/logos/supermarq-logo.webp">
</p>

---
![Continuous Integration](https://github.com/Infleqtion/client-superstaq/actions/workflows/ci.yml/badge.svg)


# Supermarq: A Scalable Quantum Benchmark Suite

[Supermarq](https://arxiv.org/abs/2202.11045) is a suite of application-oriented benchmarks used to measure the performance of quantum computing systems.

## Installation

The Supermarq package is available via `pip` and can be installed in your current Python environment with the command:

```
pip install supermarq
```

## Install Dev Requirements

This is required if you intend to run checks locally

```
pip install .[dev]
```


## Using Supermarq

The benchmarks are defined as classes within `supermarq/benchmarks/`. Each application
defines two methods; `circuit` and `score`. These methods are used to generate the benchmarking circuit and evaluate its performance
after execution on hardware.

The quantum benchmarks within Supermarq are designed to be scalable, meaning that the benchmarks can be
instantiated and generated for a wide range of circuit sizes and depths.

The [Supermarq tutorial](https://github.com/Infleqtion/client-superstaq/tree/main/supermarq-benchmarks/examples) notebooks contain an end-to-end example of how to execute the GHZ benchmark
using [Superstaq](https://superstaq.infleqtion.com/). The general workflow is as follows:

```python
import supermarq

ghz = supermarq.benchmarks.ghz.GHZ(num_qubits=3)
ghz_circuit = ghz.circuit()
counts = execute_circuit_on_quantum_hardware(ghz_circuit) # For example, via AWS Braket, IBM Qiskit, or Superstaq
score = ghz.score(counts)
```
oslo.limit 2.10.0
Limit enforcement library to assist with quota calculation.
License: Apache-2.0
Requires Python: >=3.10

==========
oslo.limit
==========

.. image:: https://governance.openstack.org/tc/badges/oslo.limit.svg

.. Change things from this point on

.. image:: https://img.shields.io/pypi/v/oslo.limit.svg
    :target: https://pypi.python.org/pypi/oslo.limit/
    :alt: Latest Version

.. image:: https://img.shields.io/pypi/dm/oslo.limit.svg
    :target: https://pypi.python.org/pypi/oslo.limit/
    :alt: Downloads

Oslo.limit is the limit enforcement library to assist with quota calculation.
It aims to provide support for quota enforcement across all OpenStack services.

* Free software: Apache license
* Documentation: https://docs.openstack.org/oslo.limit/latest/
* Source: http://opendev.org/openstack/oslo.limit
* Bugs: http://bugs.launchpad.net/oslo.limit
cirq-superstaq 0.5.62
The Cirq module that provides tools and access to Superstaq.
License: Apache-2.0
Requires Python: >=3.9.0

# `cirq-superstaq`

![cirq-superstaq's default workflow](https://github.com/Infleqtion/client-superstaq/actions/workflows/ci.yml/badge.svg)

This package is used to access Superstaq via a Web API through [Cirq](https://github.com/quantumlib/Cirq).
Cirq programmers can take advantage of the applications, pulse level optimizations, and write-once-target-all
features of Superstaq with this package.

`cirq-superstaq` is [available on PyPI](https://pypi.org/project/cirq-superstaq) and can be installed with:

```
pip install cirq-superstaq
```

Please note that Python version `3.9` or higher is required. For further installation instructions, see [here](https://github.com/Infleqtion/client-superstaq#readme).

### Creating and submitting a circuit through cirq-superstaq

```python
import cirq
import cirq_superstaq as css

q0 = cirq.LineQubit(0)
q1 = cirq.LineQubit(1)

circuit = cirq.Circuit(cirq.H(q0), cirq.CNOT(q0, q1), cirq.measure(q0))

service = css.Service(
    api_key="""Insert superstaq token that you received from https://superstaq.infleqtion.com""",
    verbose=True,
)

# Submitting a circuit to IBM's Fez QPU. Providing the "dry-run" method parameter instructs Superstaq to simulate the circuit, and is available to free trial users.
job = service.create_job(circuit, repetitions=100, target="ibmq_fez_qpu", method="dry-run")
print("This is the job that's created ", job.status())
print(job.counts(0))
```
qiskit-superstaq 0.5.62
The Qiskit module that provides tools and access to Superstaq.
License: Apache-2.0
Requires Python: >=3.9.0

# `qiskit-superstaq`

![qiskit-superstaq's default workflow](https://github.com/Infleqtion/client-superstaq/actions/workflows/ci.yml/badge.svg)

This package is used to access Superstaq via a Web API through [Qiskit](https://qiskit.org/). Qiskit programmers
can take advantage of the applications, pulse level optimizations, and write-once-target-all
features of Superstaq with this package.

`qiskit-superstaq` is [available on PyPI](https://pypi.org/project/qiskit-superstaq/) and can be installed with:

```
pip install qiskit-superstaq
```

Please note that Python version `3.9` or higher is required. See installation instructions [here](https://github.com/Infleqtion/client-superstaq#readme).

### Creating and submitting a circuit through qiskit-superstaq

```python
import qiskit
import qiskit_superstaq as qss

token = "Insert superstaq token that you received from https://superstaq.infleqtion.com"

superstaq = qss.SuperstaqProvider(token)

qc = qiskit.QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure(0, 0)
qc.measure(1, 1)

print(qc)

# Submitting a circuit to IBM's Fez QPU. Providing the "dry-run" method parameter instructs Superstaq to simulate the circuit, and is available to free trial users.
backend = superstaq.get_backend("ibmq_fez_qpu")
job = backend.run(qc, shots=100, method="dry-run")
print(job.result().get_counts())
```
general-superstaq 0.5.62
The general module that provides tools and access to Superstaq.
License: Apache-2.0
Requires Python: >=3.9.0

# general-superstaq
This package contains code that is common across our clients ([cirq-superstaq](https://github.com/Infleqtion/client-superstaq#-cirq-superstaq-) and [qiskit-superstaq](https://github.com/Infleqtion/client-superstaq#-qiskit-superstaq-)) and [Supermarq](https://github.com/Infleqtion/client-superstaq#-supermarq-).